add some babel stuff

node_modules/@babel/template/lib/builder.js

@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createTemplateBuilder;
+
+var _options = require("./options");
+
+var _string = _interopRequireDefault(require("./string"));
+
+var _literal = _interopRequireDefault(require("./literal"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var NO_PLACEHOLDER = (0, _options.validate)({
+  placeholderPattern: false
+});
+
+function createTemplateBuilder(formatter, defaultOpts) {
+  var templateFnCache = new WeakMap();
+  var templateAstCache = new WeakMap();
+  var cachedOpts = defaultOpts || (0, _options.validate)(null);
+  return Object.assign(function (tpl) {
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+
+    if (typeof tpl === "string") {
+      if (args.length > 1) throw new Error("Unexpected extra params.");
+      return extendedTrace((0, _string.default)(formatter, tpl, (0, _options.merge)(cachedOpts, (0, _options.validate)(args[0]))));
+    } else if (Array.isArray(tpl)) {
+      var builder = templateFnCache.get(tpl);
+
+      if (!builder) {
+        builder = (0, _literal.default)(formatter, tpl, cachedOpts);
+        templateFnCache.set(tpl, builder);
+      }
+
+      return extendedTrace(builder(args));
+    } else if (typeof tpl === "object" && tpl) {
+      if (args.length > 0) throw new Error("Unexpected extra params.");
+      return createTemplateBuilder(formatter, (0, _options.merge)(cachedOpts, (0, _options.validate)(tpl)));
+    }
+
+    throw new Error("Unexpected template param " + typeof tpl);
+  }, {
+    ast: function ast(tpl) {
+      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+        args[_key2 - 1] = arguments[_key2];
+      }
+
+      if (typeof tpl === "string") {
+        if (args.length > 1) throw new Error("Unexpected extra params.");
+        return (0, _string.default)(formatter, tpl, (0, _options.merge)((0, _options.merge)(cachedOpts, (0, _options.validate)(args[0])), NO_PLACEHOLDER))();
+      } else if (Array.isArray(tpl)) {
+        var builder = templateAstCache.get(tpl);
+
+        if (!builder) {
+          builder = (0, _literal.default)(formatter, tpl, (0, _options.merge)(cachedOpts, NO_PLACEHOLDER));
+          templateAstCache.set(tpl, builder);
+        }
+
+        return builder(args)();
+      }
+
+      throw new Error("Unexpected template param " + typeof tpl);
+    }
+  });
+}
+
+function extendedTrace(fn) {
+  var rootStack = "";
+
+  try {
+    throw new Error();
+  } catch (error) {
+    if (error.stack) {
+      rootStack = error.stack.split("\n").slice(3).join("\n");
+    }
+  }
+
+  return function (arg) {
+    try {
+      return fn(arg);
+    } catch (err) {
+      err.stack += "\n    =============\n" + rootStack;
+      throw err;
+    }
+  };
+}

node_modules/@babel/template/lib/formatters.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.program = exports.expression = exports.statement = exports.statements = exports.smart = void 0;
+
+function makeStatementFormatter(fn) {
+  return {
+    code: function code(str) {
+      return "/* @babel/template */;\n" + str;
+    },
+    validate: function validate() {},
+    unwrap: function unwrap(ast) {
+      return fn(ast.program.body.slice(1));
+    }
+  };
+}
+
+var smart = makeStatementFormatter(function (body) {
+  if (body.length > 1) {
+    return body;
+  } else {
+    return body[0];
+  }
+});
+exports.smart = smart;
+var statements = makeStatementFormatter(function (body) {
+  return body;
+});
+exports.statements = statements;
+var statement = makeStatementFormatter(function (body) {
+  if (body.length === 0) {
+    throw new Error("Found nothing to return.");
+  }
+
+  if (body.length > 1) {
+    throw new Error("Found multiple statements but wanted one");
+  }
+
+  return body[0];
+});
+exports.statement = statement;
+var expression = {
+  code: function code(str) {
+    return "(\n" + str + "\n)";
+  },
+  validate: function validate(_ref) {
+    var program = _ref.program;
+
+    if (program.body.length > 1) {
+      throw new Error("Found multiple statements but wanted one");
+    }
+
+    var expression = program.body[0].expression;
+
+    if (expression.start === 0) {
+      throw new Error("Parse result included parens.");
+    }
+  },
+  unwrap: function unwrap(ast) {
+    return ast.program.body[0].expression;
+  }
+};
+exports.expression = expression;
+var program = {
+  code: function code(str) {
+    return str;
+  },
+  validate: function validate() {},
+  unwrap: function unwrap(ast) {
+    return ast.program;
+  }
+};
+exports.program = program;

node_modules/@babel/template/lib/index.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.program = exports.expression = exports.statements = exports.statement = exports.smart = void 0;
+
+var formatters = _interopRequireWildcard(require("./formatters"));
+
+var _builder = _interopRequireDefault(require("./builder"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+var smart = (0, _builder.default)(formatters.smart);
+exports.smart = smart;
+var statement = (0, _builder.default)(formatters.statement);
+exports.statement = statement;
+var statements = (0, _builder.default)(formatters.statements);
+exports.statements = statements;
+var expression = (0, _builder.default)(formatters.expression);
+exports.expression = expression;
+var program = (0, _builder.default)(formatters.program);
+exports.program = program;
+
+var _default = Object.assign(smart.bind(undefined), {
+  smart: smart,
+  statement: statement,
+  statements: statements,
+  expression: expression,
+  program: program,
+  ast: smart.ast
+});
+
+exports.default = _default;

node_modules/@babel/template/lib/literal.js

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = literalTemplate;
+
+var _options = require("./options");
+
+var _parse = _interopRequireDefault(require("./parse"));
+
+var _populate = _interopRequireDefault(require("./populate"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function literalTemplate(formatter, tpl, opts) {
+  var _buildLiteralData = buildLiteralData(formatter, tpl, opts),
+      metadata = _buildLiteralData.metadata,
+      names = _buildLiteralData.names;
+
+  return function (arg) {
+    var defaultReplacements = arg.reduce(function (acc, replacement, i) {
+      acc[names[i]] = replacement;
+      return acc;
+    }, {});
+    return function (arg) {
+      var replacements = (0, _options.normalizeReplacements)(arg);
+
+      if (replacements) {
+        Object.keys(replacements).forEach(function (key) {
+          if (Object.prototype.hasOwnProperty.call(defaultReplacements, key)) {
+            throw new Error("Unexpected replacement overlap.");
+          }
+        });
+      }
+
+      return formatter.unwrap((0, _populate.default)(metadata, replacements ? Object.assign(replacements, defaultReplacements) : defaultReplacements));
+    };
+  };
+}
+
+function buildLiteralData(formatter, tpl, opts) {
+  var names;
+  var nameSet;
+  var metadata;
+  var prefix = "";
+
+  do {
+    prefix += "$";
+    var result = buildTemplateCode(tpl, prefix);
+    names = result.names;
+    nameSet = new Set(names);
+    metadata = (0, _parse.default)(formatter, formatter.code(result.code), {
+      parser: opts.parser,
+      placeholderWhitelist: new Set(result.names.concat(opts.placeholderWhitelist ? Array.from(opts.placeholderWhitelist) : [])),
+      placeholderPattern: opts.placeholderPattern,
+      preserveComments: opts.preserveComments
+    });
+  } while (metadata.placeholders.some(function (placeholder) {
+    return placeholder.isDuplicate && nameSet.has(placeholder.name);
+  }));
+
+  return {
+    metadata: metadata,
+    names: names
+  };
+}
+
+function buildTemplateCode(tpl, prefix) {
+  var names = [];
+  var code = tpl[0];
+
+  for (var i = 1; i < tpl.length; i++) {
+    var value = "" + prefix + (i - 1);
+    names.push(value);
+    code += value + tpl[i];
+  }
+
+  return {
+    names: names,
+    code: code
+  };
+}

node_modules/@babel/template/lib/options.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.merge = merge;
+exports.validate = validate;
+exports.normalizeReplacements = normalizeReplacements;
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function merge(a, b) {
+  var _b$placeholderWhiteli = b.placeholderWhitelist,
+      placeholderWhitelist = _b$placeholderWhiteli === void 0 ? a.placeholderWhitelist : _b$placeholderWhiteli,
+      _b$placeholderPattern = b.placeholderPattern,
+      placeholderPattern = _b$placeholderPattern === void 0 ? a.placeholderPattern : _b$placeholderPattern,
+      _b$preserveComments = b.preserveComments,
+      preserveComments = _b$preserveComments === void 0 ? a.preserveComments : _b$preserveComments;
+  return {
+    parser: Object.assign({}, a.parser, b.parser),
+    placeholderWhitelist: placeholderWhitelist,
+    placeholderPattern: placeholderPattern,
+    preserveComments: preserveComments
+  };
+}
+
+function validate(opts) {
+  if (opts != null && typeof opts !== "object") {
+    throw new Error("Unknown template options.");
+  }
+
+  var _ref = opts || {},
+      placeholderWhitelist = _ref.placeholderWhitelist,
+      placeholderPattern = _ref.placeholderPattern,
+      preserveComments = _ref.preserveComments,
+      parser = _objectWithoutProperties(_ref, ["placeholderWhitelist", "placeholderPattern", "preserveComments"]);
+
+  if (placeholderWhitelist != null && !(placeholderWhitelist instanceof Set)) {
+    throw new Error("'.placeholderWhitelist' must be a Set, null, or undefined");
+  }
+
+  if (placeholderPattern != null && !(placeholderPattern instanceof RegExp) && placeholderPattern !== false) {
+    throw new Error("'.placeholderPattern' must be a RegExp, false, null, or undefined");
+  }
+
+  if (preserveComments != null && typeof preserveComments !== "boolean") {
+    throw new Error("'.preserveComments' must be a boolean, null, or undefined");
+  }
+
+  return {
+    parser: parser,
+    placeholderWhitelist: placeholderWhitelist || undefined,
+    placeholderPattern: placeholderPattern == null ? undefined : placeholderPattern,
+    preserveComments: preserveComments == null ? false : preserveComments
+  };
+}
+
+function normalizeReplacements(replacements) {
+  if (Array.isArray(replacements)) {
+    return replacements.reduce(function (acc, replacement, i) {
+      acc["$" + i] = replacement;
+      return acc;
+    }, {});
+  } else if (typeof replacements === "object" || replacements == null) {
+    return replacements || undefined;
+  }
+
+  throw new Error("Template replacements must be an array, object, null, or undefined");
+}

node_modules/@babel/template/lib/parse.js

@@ -0,0 +1,156 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = parseAndBuildMetadata;
+
+function t() {
+  var data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _babylon() {
+  var data = require("babylon");
+
+  _babylon = function _babylon() {
+    return data;
+  };
+
+  return data;
+}
+
+function _codeFrame() {
+  var data = require("@babel/code-frame");
+
+  _codeFrame = function _codeFrame() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+var PATTERN = /^[_$A-Z0-9]+$/;
+
+function parseAndBuildMetadata(formatter, code, opts) {
+  var ast = parseWithCodeFrame(code, opts.parser);
+  var placeholderWhitelist = opts.placeholderWhitelist,
+      _opts$placeholderPatt = opts.placeholderPattern,
+      placeholderPattern = _opts$placeholderPatt === void 0 ? PATTERN : _opts$placeholderPatt,
+      preserveComments = opts.preserveComments;
+  t().removePropertiesDeep(ast, {
+    preserveComments: preserveComments
+  });
+  formatter.validate(ast);
+  var placeholders = [];
+  var placeholderNames = new Set();
+  t().traverse(ast, placeholderVisitorHandler, {
+    placeholders: placeholders,
+    placeholderNames: placeholderNames,
+    placeholderWhitelist: placeholderWhitelist,
+    placeholderPattern: placeholderPattern
+  });
+  return {
+    ast: ast,
+    placeholders: placeholders,
+    placeholderNames: placeholderNames
+  };
+}
+
+function placeholderVisitorHandler(node, ancestors, state) {
+  var name;
+
+  if (t().isIdentifier(node) || t().isJSXIdentifier(node)) {
+    name = node.name;
+  } else if (t().isStringLiteral(node)) {
+    name = node.value;
+  } else {
+    return;
+  }
+
+  if ((!state.placeholderPattern || !state.placeholderPattern.test(name)) && (!state.placeholderWhitelist || !state.placeholderWhitelist.has(name))) {
+    return;
+  }
+
+  ancestors = ancestors.slice();
+  var _ancestors = ancestors[ancestors.length - 1],
+      parent = _ancestors.node,
+      key = _ancestors.key;
+  var type;
+
+  if (t().isStringLiteral(node)) {
+    type = "string";
+  } else if (t().isNewExpression(parent) && key === "arguments" || t().isCallExpression(parent) && key === "arguments" || t().isFunction(parent) && key === "params") {
+    type = "param";
+  } else if (t().isExpressionStatement(parent)) {
+    type = "statement";
+    ancestors = ancestors.slice(0, -1);
+  } else {
+    type = "other";
+  }
+
+  state.placeholders.push({
+    name: name,
+    type: type,
+    resolve: function resolve(ast) {
+      return resolveAncestors(ast, ancestors);
+    },
+    isDuplicate: state.placeholderNames.has(name)
+  });
+  state.placeholderNames.add(name);
+}
+
+function resolveAncestors(ast, ancestors) {
+  var parent = ast;
+
+  for (var i = 0; i < ancestors.length - 1; i++) {
+    var _ancestors$i = ancestors[i],
+        _key = _ancestors$i.key,
+        _index = _ancestors$i.index;
+
+    if (_index === undefined) {
+      parent = parent[_key];
+    } else {
+      parent = parent[_key][_index];
+    }
+  }
+
+  var _ancestors2 = ancestors[ancestors.length - 1],
+      key = _ancestors2.key,
+      index = _ancestors2.index;
+  return {
+    parent: parent,
+    key: key,
+    index: index
+  };
+}
+
+function parseWithCodeFrame(code, parserOpts) {
+  parserOpts = Object.assign({
+    allowReturnOutsideFunction: true,
+    allowSuperOutsideMethod: true,
+    sourceType: "module"
+  }, parserOpts);
+
+  try {
+    return (0, _babylon().parse)(code, parserOpts);
+  } catch (err) {
+    var loc = err.loc;
+
+    if (loc) {
+      err.message += "\n" + (0, _codeFrame().codeFrameColumns)(code, {
+        start: loc
+      });
+      err.code = "BABEL_TEMPLATE_PARSE_ERROR";
+    }
+
+    throw err;
+  }
+}

node_modules/@babel/template/lib/populate.js

@@ -0,0 +1,131 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = populatePlaceholders;
+
+function t() {
+  var data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function t() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function populatePlaceholders(metadata, replacements) {
+  var ast = t().cloneNode(metadata.ast);
+
+  if (replacements) {
+    metadata.placeholders.forEach(function (placeholder) {
+      if (!Object.prototype.hasOwnProperty.call(replacements, placeholder.name)) {
+        var placeholderName = placeholder.name;
+        throw new Error("Error: No substitution given for \"" + placeholderName + "\". If this is not meant to be a\n            placeholder you may want to consider passing one of the following options to @babel/template:\n            - { placeholderPattern: false, placeholderWhitelist: new Set(['" + placeholderName + "'])}\n            - { placeholderPattern: /^" + placeholderName + "$/ }");
+      }
+    });
+    Object.keys(replacements).forEach(function (key) {
+      if (!metadata.placeholderNames.has(key)) {
+        throw new Error("Unknown substitution \"" + key + "\" given");
+      }
+    });
+  }
+
+  metadata.placeholders.slice().reverse().forEach(function (placeholder) {
+    try {
+      applyReplacement(placeholder, ast, replacements && replacements[placeholder.name] || null);
+    } catch (e) {
+      e.message = "@babel/template placeholder \"" + placeholder.name + "\": " + e.message;
+      throw e;
+    }
+  });
+  return ast;
+}
+
+function applyReplacement(placeholder, ast, replacement) {
+  if (placeholder.isDuplicate) {
+    if (Array.isArray(replacement)) {
+      replacement = replacement.map(function (node) {
+        return t().cloneNode(node);
+      });
+    } else if (typeof replacement === "object") {
+      replacement = t().cloneNode(replacement);
+    }
+  }
+
+  var _placeholder$resolve = placeholder.resolve(ast),
+      parent = _placeholder$resolve.parent,
+      key = _placeholder$resolve.key,
+      index = _placeholder$resolve.index;
+
+  if (placeholder.type === "string") {
+    if (typeof replacement === "string") {
+      replacement = t().stringLiteral(replacement);
+    }
+
+    if (!replacement || !t().isStringLiteral(replacement)) {
+      throw new Error("Expected string substitution");
+    }
+  } else if (placeholder.type === "statement") {
+    if (index === undefined) {
+      if (!replacement) {
+        replacement = t().emptyStatement();
+      } else if (Array.isArray(replacement)) {
+        replacement = t().blockStatement(replacement);
+      } else if (typeof replacement === "string") {
+        replacement = t().expressionStatement(t().identifier(replacement));
+      } else if (!t().isStatement(replacement)) {
+        replacement = t().expressionStatement(replacement);
+      }
+    } else {
+      if (replacement && !Array.isArray(replacement)) {
+        if (typeof replacement === "string") {
+          replacement = t().identifier(replacement);
+        }
+
+        if (!t().isStatement(replacement)) {
+          replacement = t().expressionStatement(replacement);
+        }
+      }
+    }
+  } else if (placeholder.type === "param") {
+    if (typeof replacement === "string") {
+      replacement = t().identifier(replacement);
+    }
+
+    if (index === undefined) throw new Error("Assertion failure.");
+  } else {
+    if (typeof replacement === "string") {
+      replacement = t().identifier(replacement);
+    }
+
+    if (Array.isArray(replacement)) {
+      throw new Error("Cannot replace single expression with an array.");
+    }
+  }
+
+  if (index === undefined) {
+    t().validate(parent, key, replacement);
+    parent[key] = replacement;
+  } else {
+    var items = parent[key].slice();
+
+    if (placeholder.type === "statement" || placeholder.type === "param") {
+      if (replacement == null) {
+        items.splice(index, 1);
+      } else if (Array.isArray(replacement)) {
+        items.splice.apply(items, [index, 1].concat(replacement));
+      } else {
+        items[index] = replacement;
+      }
+    } else {
+      items[index] = replacement;
+    }
+
+    t().validate(parent, key, items);
+    parent[key] = items;
+  }
+}

node_modules/@babel/template/lib/string.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = stringTemplate;
+
+var _options = require("./options");
+
+var _parse = _interopRequireDefault(require("./parse"));
+
+var _populate = _interopRequireDefault(require("./populate"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function stringTemplate(formatter, code, opts) {
+  code = formatter.code(code);
+  var metadata;
+  return function (arg) {
+    var replacements = (0, _options.normalizeReplacements)(arg);
+    if (!metadata) metadata = (0, _parse.default)(formatter, code, opts);
+    return formatter.unwrap((0, _populate.default)(metadata, replacements));
+  };
+}