Added node_modules for the updating to work properly.

10 files changed, 942 insertions, 0 deletions

diff --git a/node_modules/@babel/core/lib/transformation/block-hoist-plugin.js b/node_modules/@babel/core/lib/transformation/block-hoist-plugin.js
new file mode 100644
index 0000000..a3b0b41
--- /dev/null
+++ b/node_modules/@babel/core/lib/transformation/block-hoist-plugin.js
@@ -0,0 +1,94 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = loadBlockHoistPlugin;
+
+function _traverse() {
+  const data = require("@babel/traverse");
+
+  _traverse = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _plugin = require("../config/plugin");
+
+let LOADED_PLUGIN;
+
+function loadBlockHoistPlugin() {
+  if (!LOADED_PLUGIN) {
+    LOADED_PLUGIN = new _plugin.default(Object.assign({}, blockHoistPlugin, {
+      visitor: _traverse().default.explode(blockHoistPlugin.visitor)
+    }), {});
+  }
+
+  return LOADED_PLUGIN;
+}
+
+function priority(bodyNode) {
+  const priority = bodyNode == null ? void 0 : bodyNode._blockHoist;
+  if (priority == null) return 1;
+  if (priority === true) return 2;
+  return priority;
+}
+
+function stableSort(body) {
+  const buckets = Object.create(null);
+
+  for (let i = 0; i < body.length; i++) {
+    const n = body[i];
+    const p = priority(n);
+    const bucket = buckets[p] || (buckets[p] = []);
+    bucket.push(n);
+  }
+
+  const keys = Object.keys(buckets).map(k => +k).sort((a, b) => b - a);
+  let index = 0;
+
+  for (const key of keys) {
+    const bucket = buckets[key];
+
+    for (const n of bucket) {
+      body[index++] = n;
+    }
+  }
+
+  return body;
+}
+
+const blockHoistPlugin = {
+  name: "internal.blockHoist",
+  visitor: {
+    Block: {
+      exit({
+        node
+      }) {
+        const {
+          body
+        } = node;
+        let max = Math.pow(2, 30) - 1;
+        let hasChange = false;
+
+        for (let i = 0; i < body.length; i++) {
+          const n = body[i];
+          const p = priority(n);
+
+          if (p > max) {
+            hasChange = true;
+            break;
+          }
+
+          max = p;
+        }
+
+        if (!hasChange) return;
+        node.body = stableSort(body.slice());
+      }
+
+    }
+  }
+};
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/transformation/file/file.js b/node_modules/@babel/core/lib/transformation/file/file.js
new file mode 100644
index 0000000..3728ec5
--- /dev/null
+++ b/node_modules/@babel/core/lib/transformation/file/file.js
@@ -0,0 +1,254 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function helpers() {
+  const data = require("@babel/helpers");
+
+  helpers = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _traverse() {
+  const data = require("@babel/traverse");
+
+  _traverse = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _codeFrame() {
+  const data = require("@babel/code-frame");
+
+  _codeFrame = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _t() {
+  const data = require("@babel/types");
+
+  _t = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _helperModuleTransforms() {
+  const data = require("@babel/helper-module-transforms");
+
+  _helperModuleTransforms = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _semver() {
+  const data = require("semver");
+
+  _semver = function () {
+    return data;
+  };
+
+  return data;
+}
+
+const {
+  cloneNode,
+  interpreterDirective
+} = _t();
+
+const errorVisitor = {
+  enter(path, state) {
+    const loc = path.node.loc;
+
+    if (loc) {
+      state.loc = loc;
+      path.stop();
+    }
+  }
+
+};
+
+class File {
+  constructor(options, {
+    code,
+    ast,
+    inputMap
+  }) {
+    this._map = new Map();
+    this.opts = void 0;
+    this.declarations = {};
+    this.path = null;
+    this.ast = {};
+    this.scope = void 0;
+    this.metadata = {};
+    this.code = "";
+    this.inputMap = null;
+    this.hub = {
+      file: this,
+      getCode: () => this.code,
+      getScope: () => this.scope,
+      addHelper: this.addHelper.bind(this),
+      buildError: this.buildCodeFrameError.bind(this)
+    };
+    this.opts = options;
+    this.code = code;
+    this.ast = ast;
+    this.inputMap = inputMap;
+    this.path = _traverse().NodePath.get({
+      hub: this.hub,
+      parentPath: null,
+      parent: this.ast,
+      container: this.ast,
+      key: "program"
+    }).setContext();
+    this.scope = this.path.scope;
+  }
+
+  get shebang() {
+    const {
+      interpreter
+    } = this.path.node;
+    return interpreter ? interpreter.value : "";
+  }
+
+  set shebang(value) {
+    if (value) {
+      this.path.get("interpreter").replaceWith(interpreterDirective(value));
+    } else {
+      this.path.get("interpreter").remove();
+    }
+  }
+
+  set(key, val) {
+    if (key === "helpersNamespace") {
+      throw new Error("Babel 7.0.0-beta.56 has dropped support for the 'helpersNamespace' utility." + "If you are using @babel/plugin-external-helpers you will need to use a newer " + "version than the one you currently have installed. " + "If you have your own implementation, you'll want to explore using 'helperGenerator' " + "alongside 'file.availableHelper()'.");
+    }
+
+    this._map.set(key, val);
+  }
+
+  get(key) {
+    return this._map.get(key);
+  }
+
+  has(key) {
+    return this._map.has(key);
+  }
+
+  getModuleName() {
+    return (0, _helperModuleTransforms().getModuleName)(this.opts, this.opts);
+  }
+
+  addImport() {
+    throw new Error("This API has been removed. If you're looking for this " + "functionality in Babel 7, you should import the " + "'@babel/helper-module-imports' module and use the functions exposed " + " from that module, such as 'addNamed' or 'addDefault'.");
+  }
+
+  availableHelper(name, versionRange) {
+    let minVersion;
+
+    try {
+      minVersion = helpers().minVersion(name);
+    } catch (err) {
+      if (err.code !== "BABEL_HELPER_UNKNOWN") throw err;
+      return false;
+    }
+
+    if (typeof versionRange !== "string") return true;
+    if (_semver().valid(versionRange)) versionRange = `^${versionRange}`;
+    return !_semver().intersects(`<${minVersion}`, versionRange) && !_semver().intersects(`>=8.0.0`, versionRange);
+  }
+
+  addHelper(name) {
+    const declar = this.declarations[name];
+    if (declar) return cloneNode(declar);
+    const generator = this.get("helperGenerator");
+
+    if (generator) {
+      const res = generator(name);
+      if (res) return res;
+    }
+
+    helpers().ensure(name, File);
+    const uid = this.declarations[name] = this.scope.generateUidIdentifier(name);
+    const dependencies = {};
+
+    for (const dep of helpers().getDependencies(name)) {
+      dependencies[dep] = this.addHelper(dep);
+    }
+
+    const {
+      nodes,
+      globals
+    } = helpers().get(name, dep => dependencies[dep], uid, Object.keys(this.scope.getAllBindings()));
+    globals.forEach(name => {
+      if (this.path.scope.hasBinding(name, true)) {
+        this.path.scope.rename(name);
+      }
+    });
+    nodes.forEach(node => {
+      node._compact = true;
+    });
+    this.path.unshiftContainer("body", nodes);
+    this.path.get("body").forEach(path => {
+      if (nodes.indexOf(path.node) === -1) return;
+      if (path.isVariableDeclaration()) this.scope.registerDeclaration(path);
+    });
+    return uid;
+  }
+
+  addTemplateObject() {
+    throw new Error("This function has been moved into the template literal transform itself.");
+  }
+
+  buildCodeFrameError(node, msg, _Error = SyntaxError) {
+    let loc = node && (node.loc || node._loc);
+
+    if (!loc && node) {
+      const state = {
+        loc: null
+      };
+      (0, _traverse().default)(node, errorVisitor, this.scope, state);
+      loc = state.loc;
+      let txt = "This is an error on an internal node. Probably an internal error.";
+      if (loc) txt += " Location has been estimated.";
+      msg += ` (${txt})`;
+    }
+
+    if (loc) {
+      const {
+        highlightCode = true
+      } = this.opts;
+      msg += "\n" + (0, _codeFrame().codeFrameColumns)(this.code, {
+        start: {
+          line: loc.start.line,
+          column: loc.start.column + 1
+        },
+        end: loc.end && loc.start.line === loc.end.line ? {
+          line: loc.end.line,
+          column: loc.end.column + 1
+        } : undefined
+      }, {
+        highlightCode
+      });
+    }
+
+    return new _Error(msg);
+  }
+
+}
+
+exports.default = File;
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/transformation/file/generate.js b/node_modules/@babel/core/lib/transformation/file/generate.js
new file mode 100644
index 0000000..def05ca
--- /dev/null
+++ b/node_modules/@babel/core/lib/transformation/file/generate.js
@@ -0,0 +1,90 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = generateCode;
+
+function _convertSourceMap() {
+  const data = require("convert-source-map");
+
+  _convertSourceMap = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _generator() {
+  const data = require("@babel/generator");
+
+  _generator = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _mergeMap = require("./merge-map");
+
+function generateCode(pluginPasses, file) {
+  const {
+    opts,
+    ast,
+    code,
+    inputMap
+  } = file;
+  const {
+    generatorOpts
+  } = opts;
+  const results = [];
+
+  for (const plugins of pluginPasses) {
+    for (const plugin of plugins) {
+      const {
+        generatorOverride
+      } = plugin;
+
+      if (generatorOverride) {
+        const result = generatorOverride(ast, generatorOpts, code, _generator().default);
+        if (result !== undefined) results.push(result);
+      }
+    }
+  }
+
+  let result;
+
+  if (results.length === 0) {
+    result = (0, _generator().default)(ast, generatorOpts, code);
+  } else if (results.length === 1) {
+    result = results[0];
+
+    if (typeof result.then === "function") {
+      throw new Error(`You appear to be using an async codegen plugin, ` + `which your current version of Babel does not support. ` + `If you're using a published plugin, ` + `you may need to upgrade your @babel/core version.`);
+    }
+  } else {
+    throw new Error("More than one plugin attempted to override codegen.");
+  }
+
+  let {
+    code: outputCode,
+    map: outputMap
+  } = result;
+
+  if (outputMap && inputMap) {
+    outputMap = (0, _mergeMap.default)(inputMap.toObject(), outputMap, generatorOpts.sourceFileName);
+  }
+
+  if (opts.sourceMaps === "inline" || opts.sourceMaps === "both") {
+    outputCode += "\n" + _convertSourceMap().fromObject(outputMap).toComment();
+  }
+
+  if (opts.sourceMaps === "inline") {
+    outputMap = null;
+  }
+
+  return {
+    outputCode,
+    outputMap
+  };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/transformation/file/merge-map.js b/node_modules/@babel/core/lib/transformation/file/merge-map.js
new file mode 100644
index 0000000..af1da89
--- /dev/null
+++ b/node_modules/@babel/core/lib/transformation/file/merge-map.js
@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = mergeSourceMap;
+
+function _remapping() {
+  const data = require("@ampproject/remapping");
+
+  _remapping = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function mergeSourceMap(inputMap, map, sourceFileName) {
+  const source = sourceFileName.replace(/\\/g, "/");
+  let found = false;
+
+  const result = _remapping()(rootless(map), (s, ctx) => {
+    if (s === source && !found) {
+      found = true;
+      ctx.source = "";
+      return rootless(inputMap);
+    }
+
+    return null;
+  });
+
+  if (typeof inputMap.sourceRoot === "string") {
+    result.sourceRoot = inputMap.sourceRoot;
+  }
+
+  return Object.assign({}, result);
+}
+
+function rootless(map) {
+  return Object.assign({}, map, {
+    sourceRoot: null
+  });
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/transformation/index.js b/node_modules/@babel/core/lib/transformation/index.js
new file mode 100644
index 0000000..1f8422e
--- /dev/null
+++ b/node_modules/@babel/core/lib/transformation/index.js
@@ -0,0 +1,127 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.run = run;
+
+function _traverse() {
+  const data = require("@babel/traverse");
+
+  _traverse = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _pluginPass = require("./plugin-pass");
+
+var _blockHoistPlugin = require("./block-hoist-plugin");
+
+var _normalizeOpts = require("./normalize-opts");
+
+var _normalizeFile = require("./normalize-file");
+
+var _generate = require("./file/generate");
+
+var _deepArray = require("../config/helpers/deep-array");
+
+function* run(config, code, ast) {
+  const file = yield* (0, _normalizeFile.default)(config.passes, (0, _normalizeOpts.default)(config), code, ast);
+  const opts = file.opts;
+
+  try {
+    yield* transformFile(file, config.passes);
+  } catch (e) {
+    var _opts$filename;
+
+    e.message = `${(_opts$filename = opts.filename) != null ? _opts$filename : "unknown"}: ${e.message}`;
+
+    if (!e.code) {
+      e.code = "BABEL_TRANSFORM_ERROR";
+    }
+
+    throw e;
+  }
+
+  let outputCode, outputMap;
+
+  try {
+    if (opts.code !== false) {
+      ({
+        outputCode,
+        outputMap
+      } = (0, _generate.default)(config.passes, file));
+    }
+  } catch (e) {
+    var _opts$filename2;
+
+    e.message = `${(_opts$filename2 = opts.filename) != null ? _opts$filename2 : "unknown"}: ${e.message}`;
+
+    if (!e.code) {
+      e.code = "BABEL_GENERATE_ERROR";
+    }
+
+    throw e;
+  }
+
+  return {
+    metadata: file.metadata,
+    options: opts,
+    ast: opts.ast === true ? file.ast : null,
+    code: outputCode === undefined ? null : outputCode,
+    map: outputMap === undefined ? null : outputMap,
+    sourceType: file.ast.program.sourceType,
+    externalDependencies: (0, _deepArray.flattenToSet)(config.externalDependencies)
+  };
+}
+
+function* transformFile(file, pluginPasses) {
+  for (const pluginPairs of pluginPasses) {
+    const passPairs = [];
+    const passes = [];
+    const visitors = [];
+
+    for (const plugin of pluginPairs.concat([(0, _blockHoistPlugin.default)()])) {
+      const pass = new _pluginPass.default(file, plugin.key, plugin.options);
+      passPairs.push([plugin, pass]);
+      passes.push(pass);
+      visitors.push(plugin.visitor);
+    }
+
+    for (const [plugin, pass] of passPairs) {
+      const fn = plugin.pre;
+
+      if (fn) {
+        const result = fn.call(pass, file);
+        yield* [];
+
+        if (isThenable(result)) {
+          throw new Error(`You appear to be using an plugin with an async .pre, ` + `which your current version of Babel does not support. ` + `If you're using a published plugin, you may need to upgrade ` + `your @babel/core version.`);
+        }
+      }
+    }
+
+    const visitor = _traverse().default.visitors.merge(visitors, passes, file.opts.wrapPluginVisitorMethod);
+
+    (0, _traverse().default)(file.ast, visitor, file.scope);
+
+    for (const [plugin, pass] of passPairs) {
+      const fn = plugin.post;
+
+      if (fn) {
+        const result = fn.call(pass, file);
+        yield* [];
+
+        if (isThenable(result)) {
+          throw new Error(`You appear to be using an plugin with an async .post, ` + `which your current version of Babel does not support. ` + `If you're using a published plugin, you may need to upgrade ` + `your @babel/core version.`);
+        }
+      }
+    }
+  }
+}
+
+function isThenable(val) {
+  return !!val && (typeof val === "object" || typeof val === "function") && !!val.then && typeof val.then === "function";
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/transformation/normalize-file.js b/node_modules/@babel/core/lib/transformation/normalize-file.js
new file mode 100644
index 0000000..dc434ed
--- /dev/null
+++ b/node_modules/@babel/core/lib/transformation/normalize-file.js
@@ -0,0 +1,167 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = normalizeFile;
+
+function _fs() {
+  const data = require("fs");
+
+  _fs = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _path() {
+  const data = require("path");
+
+  _path = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _debug() {
+  const data = require("debug");
+
+  _debug = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _t() {
+  const data = require("@babel/types");
+
+  _t = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _convertSourceMap() {
+  const data = require("convert-source-map");
+
+  _convertSourceMap = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _file = require("./file/file");
+
+var _parser = require("../parser");
+
+var _cloneDeep = require("./util/clone-deep");
+
+const {
+  file,
+  traverseFast
+} = _t();
+
+const debug = _debug()("babel:transform:file");
+
+const LARGE_INPUT_SOURCEMAP_THRESHOLD = 1000000;
+
+function* normalizeFile(pluginPasses, options, code, ast) {
+  code = `${code || ""}`;
+
+  if (ast) {
+    if (ast.type === "Program") {
+      ast = file(ast, [], []);
+    } else if (ast.type !== "File") {
+      throw new Error("AST root must be a Program or File node");
+    }
+
+    if (options.cloneInputAst) {
+      ast = (0, _cloneDeep.default)(ast);
+    }
+  } else {
+    ast = yield* (0, _parser.default)(pluginPasses, options, code);
+  }
+
+  let inputMap = null;
+
+  if (options.inputSourceMap !== false) {
+    if (typeof options.inputSourceMap === "object") {
+      inputMap = _convertSourceMap().fromObject(options.inputSourceMap);
+    }
+
+    if (!inputMap) {
+      const lastComment = extractComments(INLINE_SOURCEMAP_REGEX, ast);
+
+      if (lastComment) {
+        try {
+          inputMap = _convertSourceMap().fromComment(lastComment);
+        } catch (err) {
+          debug("discarding unknown inline input sourcemap", err);
+        }
+      }
+    }
+
+    if (!inputMap) {
+      const lastComment = extractComments(EXTERNAL_SOURCEMAP_REGEX, ast);
+
+      if (typeof options.filename === "string" && lastComment) {
+        try {
+          const match = EXTERNAL_SOURCEMAP_REGEX.exec(lastComment);
+
+          const inputMapContent = _fs().readFileSync(_path().resolve(_path().dirname(options.filename), match[1]));
+
+          if (inputMapContent.length > LARGE_INPUT_SOURCEMAP_THRESHOLD) {
+            debug("skip merging input map > 1 MB");
+          } else {
+            inputMap = _convertSourceMap().fromJSON(inputMapContent);
+          }
+        } catch (err) {
+          debug("discarding unknown file input sourcemap", err);
+        }
+      } else if (lastComment) {
+        debug("discarding un-loadable file input sourcemap");
+      }
+    }
+  }
+
+  return new _file.default(options, {
+    code,
+    ast,
+    inputMap
+  });
+}
+
+const INLINE_SOURCEMAP_REGEX = /^[@#]\s+sourceMappingURL=data:(?:application|text)\/json;(?:charset[:=]\S+?;)?base64,(?:.*)$/;
+const EXTERNAL_SOURCEMAP_REGEX = /^[@#][ \t]+sourceMappingURL=([^\s'"`]+)[ \t]*$/;
+
+function extractCommentsFromList(regex, comments, lastComment) {
+  if (comments) {
+    comments = comments.filter(({
+      value
+    }) => {
+      if (regex.test(value)) {
+        lastComment = value;
+        return false;
+      }
+
+      return true;
+    });
+  }
+
+  return [comments, lastComment];
+}
+
+function extractComments(regex, ast) {
+  let lastComment = null;
+  traverseFast(ast, node => {
+    [node.leadingComments, lastComment] = extractCommentsFromList(regex, node.leadingComments, lastComment);
+    [node.innerComments, lastComment] = extractCommentsFromList(regex, node.innerComments, lastComment);
+    [node.trailingComments, lastComment] = extractCommentsFromList(regex, node.trailingComments, lastComment);
+  });
+  return lastComment;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/transformation/normalize-opts.js b/node_modules/@babel/core/lib/transformation/normalize-opts.js
new file mode 100644
index 0000000..6e2cb00
--- /dev/null
+++ b/node_modules/@babel/core/lib/transformation/normalize-opts.js
@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = normalizeOptions;
+
+function _path() {
+  const data = require("path");
+
+  _path = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function normalizeOptions(config) {
+  const {
+    filename,
+    cwd,
+    filenameRelative = typeof filename === "string" ? _path().relative(cwd, filename) : "unknown",
+    sourceType = "module",
+    inputSourceMap,
+    sourceMaps = !!inputSourceMap,
+    sourceRoot = config.options.moduleRoot,
+    sourceFileName = _path().basename(filenameRelative),
+    comments = true,
+    compact = "auto"
+  } = config.options;
+  const opts = config.options;
+  const options = Object.assign({}, opts, {
+    parserOpts: Object.assign({
+      sourceType: _path().extname(filenameRelative) === ".mjs" ? "module" : sourceType,
+      sourceFileName: filename,
+      plugins: []
+    }, opts.parserOpts),
+    generatorOpts: Object.assign({
+      filename,
+      auxiliaryCommentBefore: opts.auxiliaryCommentBefore,
+      auxiliaryCommentAfter: opts.auxiliaryCommentAfter,
+      retainLines: opts.retainLines,
+      comments,
+      shouldPrintComment: opts.shouldPrintComment,
+      compact,
+      minified: opts.minified,
+      sourceMaps,
+      sourceRoot,
+      sourceFileName
+    }, opts.generatorOpts)
+  });
+
+  for (const plugins of config.passes) {
+    for (const plugin of plugins) {
+      if (plugin.manipulateOptions) {
+        plugin.manipulateOptions(options, options.parserOpts);
+      }
+    }
+  }
+
+  return options;
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/transformation/plugin-pass.js b/node_modules/@babel/core/lib/transformation/plugin-pass.js
new file mode 100644
index 0000000..920558a
--- /dev/null
+++ b/node_modules/@babel/core/lib/transformation/plugin-pass.js
@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+class PluginPass {
+  constructor(file, key, options) {
+    this._map = new Map();
+    this.key = void 0;
+    this.file = void 0;
+    this.opts = void 0;
+    this.cwd = void 0;
+    this.filename = void 0;
+    this.key = key;
+    this.file = file;
+    this.opts = options || {};
+    this.cwd = file.opts.cwd;
+    this.filename = file.opts.filename;
+  }
+
+  set(key, val) {
+    this._map.set(key, val);
+  }
+
+  get(key) {
+    return this._map.get(key);
+  }
+
+  availableHelper(name, versionRange) {
+    return this.file.availableHelper(name, versionRange);
+  }
+
+  addHelper(name) {
+    return this.file.addHelper(name);
+  }
+
+  addImport() {
+    return this.file.addImport();
+  }
+
+  buildCodeFrameError(node, msg, _Error) {
+    return this.file.buildCodeFrameError(node, msg, _Error);
+  }
+
+}
+
+exports.default = PluginPass;
+{
+  PluginPass.prototype.getModuleName = function getModuleName() {
+    return this.file.getModuleName();
+  };
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/transformation/util/clone-deep-browser.js b/node_modules/@babel/core/lib/transformation/util/clone-deep-browser.js
new file mode 100644
index 0000000..a42de82
--- /dev/null
+++ b/node_modules/@babel/core/lib/transformation/util/clone-deep-browser.js
@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+const serialized = "$$ babel internal serialized type" + Math.random();
+
+function serialize(key, value) {
+  if (typeof value !== "bigint") return value;
+  return {
+    [serialized]: "BigInt",
+    value: value.toString()
+  };
+}
+
+function revive(key, value) {
+  if (!value || typeof value !== "object") return value;
+  if (value[serialized] !== "BigInt") return value;
+  return BigInt(value.value);
+}
+
+function _default(value) {
+  return JSON.parse(JSON.stringify(value, serialize), revive);
+}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/transformation/util/clone-deep.js b/node_modules/@babel/core/lib/transformation/util/clone-deep.js
new file mode 100644
index 0000000..35fbd09
--- /dev/null
+++ b/node_modules/@babel/core/lib/transformation/util/clone-deep.js
@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+function _v() {
+  const data = require("v8");
+
+  _v = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _cloneDeepBrowser = require("./clone-deep-browser");
+
+function _default(value) {
+  if (_v().deserialize && _v().serialize) {
+    return _v().deserialize(_v().serialize(value));
+  }
+
+  return (0, _cloneDeepBrowser.default)(value);
+}
\ No newline at end of file