add some babel stuff

node_modules/@babel/core/lib/config/caching.js

@@ -0,0 +1,223 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makeStrongCache = makeStrongCache;
+exports.makeWeakCache = makeWeakCache;
+
+function makeStrongCache(handler) {
+  return makeCachedFunction(new Map(), handler);
+}
+
+function makeWeakCache(handler) {
+  return makeCachedFunction(new WeakMap(), handler);
+}
+
+function makeCachedFunction(callCache, handler) {
+  return function cachedFunction(arg, data) {
+    var cachedValue = callCache.get(arg);
+
+    if (cachedValue) {
+      for (var _iterator = cachedValue, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+        var _ref2;
+
+        if (_isArray) {
+          if (_i >= _iterator.length) break;
+          _ref2 = _iterator[_i++];
+        } else {
+          _i = _iterator.next();
+          if (_i.done) break;
+          _ref2 = _i.value;
+        }
+
+        var _ref3 = _ref2;
+        var _value = _ref3.value,
+            _valid = _ref3.valid;
+        if (_valid(data)) return _value;
+      }
+    }
+
+    var cache = new CacheConfigurator(data);
+    var value = handler(arg, cache);
+    if (!cache.configured()) cache.forever();
+    cache.deactivate();
+
+    switch (cache.mode()) {
+      case "forever":
+        cachedValue = [{
+          value: value,
+          valid: function valid() {
+            return true;
+          }
+        }];
+        callCache.set(arg, cachedValue);
+        break;
+
+      case "invalidate":
+        cachedValue = [{
+          value: value,
+          valid: cache.validator()
+        }];
+        callCache.set(arg, cachedValue);
+        break;
+
+      case "valid":
+        if (cachedValue) {
+          cachedValue.push({
+            value: value,
+            valid: cache.validator()
+          });
+        } else {
+          cachedValue = [{
+            value: value,
+            valid: cache.validator()
+          }];
+          callCache.set(arg, cachedValue);
+        }
+
+    }
+
+    return value;
+  };
+}
+
+var CacheConfigurator = function () {
+  function CacheConfigurator(data) {
+    this._active = true;
+    this._never = false;
+    this._forever = false;
+    this._invalidate = false;
+    this._configured = false;
+    this._pairs = [];
+    this._data = data;
+  }
+
+  var _proto = CacheConfigurator.prototype;
+
+  _proto.simple = function simple() {
+    return makeSimpleConfigurator(this);
+  };
+
+  _proto.mode = function mode() {
+    if (this._never) return "never";
+    if (this._forever) return "forever";
+    if (this._invalidate) return "invalidate";
+    return "valid";
+  };
+
+  _proto.forever = function forever() {
+    if (!this._active) {
+      throw new Error("Cannot change caching after evaluation has completed.");
+    }
+
+    if (this._never) {
+      throw new Error("Caching has already been configured with .never()");
+    }
+
+    this._forever = true;
+    this._configured = true;
+  };
+
+  _proto.never = function never() {
+    if (!this._active) {
+      throw new Error("Cannot change caching after evaluation has completed.");
+    }
+
+    if (this._forever) {
+      throw new Error("Caching has already been configured with .forever()");
+    }
+
+    this._never = true;
+    this._configured = true;
+  };
+
+  _proto.using = function using(handler) {
+    if (!this._active) {
+      throw new Error("Cannot change caching after evaluation has completed.");
+    }
+
+    if (this._never || this._forever) {
+      throw new Error("Caching has already been configured with .never or .forever()");
+    }
+
+    this._configured = true;
+    var key = handler(this._data);
+
+    this._pairs.push([key, handler]);
+
+    return key;
+  };
+
+  _proto.invalidate = function invalidate(handler) {
+    if (!this._active) {
+      throw new Error("Cannot change caching after evaluation has completed.");
+    }
+
+    if (this._never || this._forever) {
+      throw new Error("Caching has already been configured with .never or .forever()");
+    }
+
+    this._invalidate = true;
+    this._configured = true;
+    var key = handler(this._data);
+
+    this._pairs.push([key, handler]);
+
+    return key;
+  };
+
+  _proto.validator = function validator() {
+    var pairs = this._pairs;
+    return function (data) {
+      return pairs.every(function (_ref4) {
+        var key = _ref4[0],
+            fn = _ref4[1];
+        return key === fn(data);
+      });
+    };
+  };
+
+  _proto.deactivate = function deactivate() {
+    this._active = false;
+  };
+
+  _proto.configured = function configured() {
+    return this._configured;
+  };
+
+  return CacheConfigurator;
+}();
+
+function makeSimpleConfigurator(cache) {
+  function cacheFn(val) {
+    if (typeof val === "boolean") {
+      if (val) cache.forever();else cache.never();
+      return;
+    }
+
+    return cache.using(val);
+  }
+
+  cacheFn.forever = function () {
+    return cache.forever();
+  };
+
+  cacheFn.never = function () {
+    return cache.never();
+  };
+
+  cacheFn.using = function (cb) {
+    return cache.using(function () {
+      return cb();
+    });
+  };
+
+  cacheFn.invalidate = function (cb) {
+    return cache.invalidate(function () {
+      return cb();
+    });
+  };
+
+  return cacheFn;
+}

node_modules/@babel/core/lib/config/config-chain.js

@@ -0,0 +1,558 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildRootChain = buildRootChain;
+exports.buildPresetChain = void 0;
+
+function _path() {
+  var data = _interopRequireDefault(require("path"));
+
+  _path = function _path() {
+    return data;
+  };
+
+  return data;
+}
+
+function _micromatch() {
+  var data = _interopRequireDefault(require("micromatch"));
+
+  _micromatch = function _micromatch() {
+    return data;
+  };
+
+  return data;
+}
+
+function _debug() {
+  var data = _interopRequireDefault(require("debug"));
+
+  _debug = function _debug() {
+    return data;
+  };
+
+  return data;
+}
+
+var _options = require("./validation/options");
+
+var _files = require("./files");
+
+var _caching = require("./caching");
+
+var _configDescriptors = require("./config-descriptors");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var debug = (0, _debug().default)("babel:config:config-chain");
+var buildPresetChain = makeChainWalker({
+  init: function init(arg) {
+    return arg;
+  },
+  root: function root(preset) {
+    return loadPresetDescriptors(preset);
+  },
+  env: function env(preset, envName) {
+    return loadPresetEnvDescriptors(preset)(envName);
+  },
+  overrides: function overrides(preset, index) {
+    return loadPresetOverridesDescriptors(preset)(index);
+  },
+  overridesEnv: function overridesEnv(preset, index, envName) {
+    return loadPresetOverridesEnvDescriptors(preset)(index)(envName);
+  }
+});
+exports.buildPresetChain = buildPresetChain;
+var loadPresetDescriptors = (0, _caching.makeWeakCache)(function (preset) {
+  return buildRootDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors);
+});
+var loadPresetEnvDescriptors = (0, _caching.makeWeakCache)(function (preset) {
+  return (0, _caching.makeStrongCache)(function (envName) {
+    return buildEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, envName);
+  });
+});
+var loadPresetOverridesDescriptors = (0, _caching.makeWeakCache)(function (preset) {
+  return (0, _caching.makeStrongCache)(function (index) {
+    return buildOverrideDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index);
+  });
+});
+var loadPresetOverridesEnvDescriptors = (0, _caching.makeWeakCache)(function (preset) {
+  return (0, _caching.makeStrongCache)(function (index) {
+    return (0, _caching.makeStrongCache)(function (envName) {
+      return buildOverrideEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index, envName);
+    });
+  });
+});
+
+function buildRootChain(opts, context) {
+  var programmaticChain = loadProgrammaticChain({
+    options: opts,
+    dirname: context.cwd
+  }, context);
+  if (!programmaticChain) return null;
+  var _opts$root = opts.root,
+      rootDir = _opts$root === void 0 ? "." : _opts$root,
+      _opts$babelrc = opts.babelrc,
+      babelrc = _opts$babelrc === void 0 ? true : _opts$babelrc,
+      babelrcRoots = opts.babelrcRoots,
+      _opts$configFile = opts.configFile,
+      configFileName = _opts$configFile === void 0 ? true : _opts$configFile;
+
+  var absoluteRoot = _path().default.resolve(context.cwd, rootDir);
+
+  var configFile;
+
+  if (typeof configFileName === "string") {
+    configFile = (0, _files.loadConfig)(configFileName, context.cwd, context.envName);
+  } else if (configFileName === true) {
+    configFile = (0, _files.findRootConfig)(absoluteRoot, context.envName);
+  }
+
+  var configFileChain = emptyChain();
+
+  if (configFile) {
+    var result = loadFileChain(configFile, context);
+    if (!result) return null;
+    mergeChain(configFileChain, result);
+  }
+
+  var pkgData = typeof context.filename === "string" ? (0, _files.findPackageData)(context.filename) : null;
+  var ignoreFile, babelrcFile;
+  var fileChain = emptyChain();
+
+  if (babelrc && pkgData && babelrcLoadEnabled(context, pkgData, babelrcRoots, absoluteRoot)) {
+    var _findRelativeConfig = (0, _files.findRelativeConfig)(pkgData, context.envName);
+
+    ignoreFile = _findRelativeConfig.ignore;
+    babelrcFile = _findRelativeConfig.config;
+
+    if (ignoreFile && shouldIgnore(context, ignoreFile.ignore, null, ignoreFile.dirname)) {
+      return null;
+    }
+
+    if (babelrcFile) {
+      var _result = loadFileChain(babelrcFile, context);
+
+      if (!_result) return null;
+      mergeChain(fileChain, _result);
+    }
+  }
+
+  var chain = mergeChain(mergeChain(mergeChain(emptyChain(), configFileChain), fileChain), programmaticChain);
+  return {
+    plugins: dedupDescriptors(chain.plugins),
+    presets: dedupDescriptors(chain.presets),
+    options: chain.options.map(function (o) {
+      return normalizeOptions(o);
+    }),
+    ignore: ignoreFile || undefined,
+    babelrc: babelrcFile || undefined,
+    config: configFile || undefined
+  };
+}
+
+function babelrcLoadEnabled(context, pkgData, babelrcRoots, absoluteRoot) {
+  if (typeof babelrcRoots === "boolean") return babelrcRoots;
+
+  if (babelrcRoots === undefined) {
+    return pkgData.directories.indexOf(absoluteRoot) !== -1;
+  }
+
+  var babelrcPatterns = babelrcRoots;
+  if (!Array.isArray(babelrcPatterns)) babelrcPatterns = [babelrcPatterns];
+  babelrcPatterns = babelrcPatterns.map(function (pat) {
+    return _path().default.resolve(context.cwd, pat);
+  });
+
+  if (babelrcPatterns.length === 1 && babelrcPatterns[0] === absoluteRoot) {
+    return pkgData.directories.indexOf(absoluteRoot) !== -1;
+  }
+
+  return (0, _micromatch().default)(pkgData.directories, babelrcPatterns).length > 0;
+}
+
+var loadProgrammaticChain = makeChainWalker({
+  init: function init(arg) {
+    return arg;
+  },
+  root: function root(input) {
+    return buildRootDescriptors(input, "base", _configDescriptors.createCachedDescriptors);
+  },
+  env: function env(input, envName) {
+    return buildEnvDescriptors(input, "base", _configDescriptors.createCachedDescriptors, envName);
+  },
+  overrides: function overrides(input, index) {
+    return buildOverrideDescriptors(input, "base", _configDescriptors.createCachedDescriptors, index);
+  },
+  overridesEnv: function overridesEnv(input, index, envName) {
+    return buildOverrideEnvDescriptors(input, "base", _configDescriptors.createCachedDescriptors, index, envName);
+  }
+});
+var loadFileChain = makeChainWalker({
+  init: function init(input) {
+    return validateFile(input);
+  },
+  root: function root(file) {
+    return loadFileDescriptors(file);
+  },
+  env: function env(file, envName) {
+    return loadFileEnvDescriptors(file)(envName);
+  },
+  overrides: function overrides(file, index) {
+    return loadFileOverridesDescriptors(file)(index);
+  },
+  overridesEnv: function overridesEnv(file, index, envName) {
+    return loadFileOverridesEnvDescriptors(file)(index)(envName);
+  }
+});
+var validateFile = (0, _caching.makeWeakCache)(function (file) {
+  return {
+    filepath: file.filepath,
+    dirname: file.dirname,
+    options: (0, _options.validate)("file", file.options)
+  };
+});
+var loadFileDescriptors = (0, _caching.makeWeakCache)(function (file) {
+  return buildRootDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors);
+});
+var loadFileEnvDescriptors = (0, _caching.makeWeakCache)(function (file) {
+  return (0, _caching.makeStrongCache)(function (envName) {
+    return buildEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, envName);
+  });
+});
+var loadFileOverridesDescriptors = (0, _caching.makeWeakCache)(function (file) {
+  return (0, _caching.makeStrongCache)(function (index) {
+    return buildOverrideDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index);
+  });
+});
+var loadFileOverridesEnvDescriptors = (0, _caching.makeWeakCache)(function (file) {
+  return (0, _caching.makeStrongCache)(function (index) {
+    return (0, _caching.makeStrongCache)(function (envName) {
+      return buildOverrideEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index, envName);
+    });
+  });
+});
+
+function buildRootDescriptors(_ref, alias, descriptors) {
+  var dirname = _ref.dirname,
+      options = _ref.options;
+  return descriptors(dirname, options, alias);
+}
+
+function buildEnvDescriptors(_ref2, alias, descriptors, envName) {
+  var dirname = _ref2.dirname,
+      options = _ref2.options;
+  var opts = options.env && options.env[envName];
+  return opts ? descriptors(dirname, opts, alias + ".env[\"" + envName + "\"]") : null;
+}
+
+function buildOverrideDescriptors(_ref3, alias, descriptors, index) {
+  var dirname = _ref3.dirname,
+      options = _ref3.options;
+  var opts = options.overrides && options.overrides[index];
+  if (!opts) throw new Error("Assertion failure - missing override");
+  return descriptors(dirname, opts, alias + ".overrides[" + index + "]");
+}
+
+function buildOverrideEnvDescriptors(_ref4, alias, descriptors, index, envName) {
+  var dirname = _ref4.dirname,
+      options = _ref4.options;
+  var override = options.overrides && options.overrides[index];
+  if (!override) throw new Error("Assertion failure - missing override");
+  var opts = override.env && override.env[envName];
+  return opts ? descriptors(dirname, opts, alias + ".overrides[" + index + "].env[\"" + envName + "\"]") : null;
+}
+
+function makeChainWalker(_ref5) {
+  var init = _ref5.init,
+      root = _ref5.root,
+      env = _ref5.env,
+      overrides = _ref5.overrides,
+      overridesEnv = _ref5.overridesEnv;
+  return function (arg, context, files) {
+    if (files === void 0) {
+      files = new Set();
+    }
+
+    var input = init(arg);
+    var dirname = input.dirname;
+    var flattenedConfigs = [];
+    var rootOpts = root(input);
+
+    if (configIsApplicable(rootOpts, dirname, context)) {
+      flattenedConfigs.push(rootOpts);
+      var envOpts = env(input, context.envName);
+
+      if (envOpts && configIsApplicable(envOpts, dirname, context)) {
+        flattenedConfigs.push(envOpts);
+      }
+
+      (rootOpts.options.overrides || []).forEach(function (_, index) {
+        var overrideOps = overrides(input, index);
+
+        if (configIsApplicable(overrideOps, dirname, context)) {
+          flattenedConfigs.push(overrideOps);
+          var overrideEnvOpts = overridesEnv(input, index, context.envName);
+
+          if (overrideEnvOpts && configIsApplicable(overrideEnvOpts, dirname, context)) {
+            flattenedConfigs.push(overrideEnvOpts);
+          }
+        }
+      });
+    }
+
+    if (flattenedConfigs.some(function (_ref6) {
+      var _ref6$options = _ref6.options,
+          ignore = _ref6$options.ignore,
+          only = _ref6$options.only;
+      return shouldIgnore(context, ignore, only, dirname);
+    })) {
+      return null;
+    }
+
+    var chain = emptyChain();
+
+    for (var _i = 0; _i < flattenedConfigs.length; _i++) {
+      var op = flattenedConfigs[_i];
+
+      if (!mergeExtendsChain(chain, op.options, dirname, context, files)) {
+        return null;
+      }
+
+      mergeChainOpts(chain, op);
+    }
+
+    return chain;
+  };
+}
+
+function mergeExtendsChain(chain, opts, dirname, context, files) {
+  if (opts.extends === undefined) return true;
+  var file = (0, _files.loadConfig)(opts.extends, dirname, context.envName);
+
+  if (files.has(file)) {
+    throw new Error("Configuration cycle detected loading " + file.filepath + ".\n" + "File already loaded following the config chain:\n" + Array.from(files, function (file) {
+      return " - " + file.filepath;
+    }).join("\n"));
+  }
+
+  files.add(file);
+  var fileChain = loadFileChain(file, context, files);
+  files.delete(file);
+  if (!fileChain) return false;
+  mergeChain(chain, fileChain);
+  return true;
+}
+
+function mergeChain(target, source) {
+  var _target$options, _target$plugins, _target$presets;
+
+  (_target$options = target.options).push.apply(_target$options, source.options);
+
+  (_target$plugins = target.plugins).push.apply(_target$plugins, source.plugins);
+
+  (_target$presets = target.presets).push.apply(_target$presets, source.presets);
+
+  return target;
+}
+
+function mergeChainOpts(target, _ref7) {
+  var _target$plugins2, _target$presets2;
+
+  var options = _ref7.options,
+      plugins = _ref7.plugins,
+      presets = _ref7.presets;
+  target.options.push(options);
+
+  (_target$plugins2 = target.plugins).push.apply(_target$plugins2, plugins());
+
+  (_target$presets2 = target.presets).push.apply(_target$presets2, presets());
+
+  return target;
+}
+
+function emptyChain() {
+  return {
+    options: [],
+    presets: [],
+    plugins: []
+  };
+}
+
+function normalizeOptions(opts) {
+  var options = Object.assign({}, opts);
+  delete options.extends;
+  delete options.env;
+  delete options.plugins;
+  delete options.presets;
+  delete options.passPerPreset;
+  delete options.ignore;
+  delete options.only;
+
+  if (options.sourceMap) {
+    options.sourceMaps = options.sourceMap;
+    delete options.sourceMap;
+  }
+
+  return options;
+}
+
+function dedupDescriptors(items) {
+  var map = new Map();
+  var descriptors = [];
+
+  for (var _iterator = items, _isArray = Array.isArray(_iterator), _i2 = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+    var _ref8;
+
+    if (_isArray) {
+      if (_i2 >= _iterator.length) break;
+      _ref8 = _iterator[_i2++];
+    } else {
+      _i2 = _iterator.next();
+      if (_i2.done) break;
+      _ref8 = _i2.value;
+    }
+
+    var item = _ref8;
+
+    if (typeof item.value === "function") {
+      var fnKey = item.value;
+      var nameMap = map.get(fnKey);
+
+      if (!nameMap) {
+        nameMap = new Map();
+        map.set(fnKey, nameMap);
+      }
+
+      var desc = nameMap.get(item.name);
+
+      if (!desc) {
+        desc = {
+          value: null
+        };
+        descriptors.push(desc);
+        if (!item.ownPass) nameMap.set(item.name, desc);
+      }
+
+      if (item.options === false) {
+        desc.value = null;
+      } else {
+        desc.value = item;
+      }
+    } else {
+      descriptors.push({
+        value: item
+      });
+    }
+  }
+
+  return descriptors.reduce(function (acc, desc) {
+    if (desc.value) acc.push(desc.value);
+    return acc;
+  }, []);
+}
+
+function configIsApplicable(_ref9, dirname, context) {
+  var options = _ref9.options;
+  return (options.test === undefined || configFieldIsApplicable(context, options.test, dirname)) && (options.include === undefined || configFieldIsApplicable(context, options.include, dirname)) && (options.exclude === undefined || !configFieldIsApplicable(context, options.exclude, dirname));
+}
+
+function configFieldIsApplicable(context, test, dirname) {
+  if (context.filename === null) {
+    throw new Error("Configuration contains explicit test/include/exclude checks, but no filename was passed to Babel");
+  }
+
+  var ctx = context;
+  var patterns = Array.isArray(test) ? test : [test];
+  return matchesPatterns(ctx, patterns, dirname, false);
+}
+
+function shouldIgnore(context, ignore, only, dirname) {
+  if (ignore) {
+    if (context.filename === null) {
+      throw new Error("Configuration contains ignore checks, but no filename was passed to Babel");
+    }
+
+    var ctx = context;
+
+    if (matchesPatterns(ctx, ignore, dirname)) {
+      debug("Ignored %o because it matched one of %O from %o", context.filename, ignore, dirname);
+      return true;
+    }
+  }
+
+  if (only) {
+    if (context.filename === null) {
+      throw new Error("Configuration contains ignore checks, but no filename was passed to Babel");
+    }
+
+    var _ctx = context;
+
+    if (!matchesPatterns(_ctx, only, dirname)) {
+      debug("Ignored %o because it failed to match one of %O from %o", context.filename, only, dirname);
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function matchesPatterns(context, patterns, dirname, allowNegation) {
+  if (allowNegation === void 0) {
+    allowNegation = true;
+  }
+
+  var res = [];
+  var strings = [];
+  var fns = [];
+  patterns.forEach(function (pattern) {
+    if (typeof pattern === "string") strings.push(pattern);else if (typeof pattern === "function") fns.push(pattern);else res.push(pattern);
+  });
+  var filename = context.filename;
+  if (res.some(function (re) {
+    return re.test(context.filename);
+  })) return true;
+  if (fns.some(function (fn) {
+    return fn(filename);
+  })) return true;
+
+  if (strings.length > 0) {
+    var possibleDirs = getPossibleDirs(context);
+    var absolutePatterns = strings.map(function (pattern) {
+      var negate = pattern[0] === "!";
+
+      if (negate && !allowNegation) {
+        throw new Error("Negation of file paths is not supported.");
+      }
+
+      if (negate) pattern = pattern.slice(1);
+      return (negate ? "!" : "") + _path().default.resolve(dirname, pattern);
+    });
+
+    if ((0, _micromatch().default)(possibleDirs, absolutePatterns, {
+      nocase: true,
+      nonegate: !allowNegation
+    }).length > 0) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+var getPossibleDirs = (0, _caching.makeWeakCache)(function (context) {
+  var current = context.filename;
+  if (current === null) return [];
+  var possibleDirs = [current];
+
+  while (true) {
+    var previous = current;
+    current = _path().default.dirname(current);
+    if (previous === current) break;
+    possibleDirs.push(current);
+  }
+
+  return possibleDirs;
+});

node_modules/@babel/core/lib/config/config-descriptors.js

@@ -0,0 +1,225 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCachedDescriptors = createCachedDescriptors;
+exports.createUncachedDescriptors = createUncachedDescriptors;
+exports.createDescriptor = createDescriptor;
+
+var _files = require("./files");
+
+var _item = require("./item");
+
+var _caching = require("./caching");
+
+function createCachedDescriptors(dirname, options, alias) {
+  var plugins = options.plugins,
+      presets = options.presets,
+      passPerPreset = options.passPerPreset;
+  return {
+    options: options,
+    plugins: plugins ? function () {
+      return createCachedPluginDescriptors(plugins, dirname)(alias);
+    } : function () {
+      return [];
+    },
+    presets: presets ? function () {
+      return createCachedPresetDescriptors(presets, dirname)(alias)(!!passPerPreset);
+    } : function () {
+      return [];
+    }
+  };
+}
+
+function createUncachedDescriptors(dirname, options, alias) {
+  var plugins;
+  var presets;
+  return {
+    options: options,
+    plugins: function (_plugins) {
+      function plugins() {
+        return _plugins.apply(this, arguments);
+      }
+
+      plugins.toString = function () {
+        return _plugins.toString();
+      };
+
+      return plugins;
+    }(function () {
+      if (!plugins) {
+        plugins = createPluginDescriptors(options.plugins || [], dirname, alias);
+      }
+
+      return plugins;
+    }),
+    presets: function (_presets) {
+      function presets() {
+        return _presets.apply(this, arguments);
+      }
+
+      presets.toString = function () {
+        return _presets.toString();
+      };
+
+      return presets;
+    }(function () {
+      if (!presets) {
+        presets = createPresetDescriptors(options.presets || [], dirname, alias, !!options.passPerPreset);
+      }
+
+      return presets;
+    })
+  };
+}
+
+var createCachedPresetDescriptors = (0, _caching.makeWeakCache)(function (items, cache) {
+  var dirname = cache.using(function (dir) {
+    return dir;
+  });
+  return (0, _caching.makeStrongCache)(function (alias) {
+    return (0, _caching.makeStrongCache)(function (passPerPreset) {
+      return createPresetDescriptors(items, dirname, alias, passPerPreset);
+    });
+  });
+});
+var createCachedPluginDescriptors = (0, _caching.makeWeakCache)(function (items, cache) {
+  var dirname = cache.using(function (dir) {
+    return dir;
+  });
+  return (0, _caching.makeStrongCache)(function (alias) {
+    return createPluginDescriptors(items, dirname, alias);
+  });
+});
+
+function createPresetDescriptors(items, dirname, alias, passPerPreset) {
+  return createDescriptors("preset", items, dirname, alias, passPerPreset);
+}
+
+function createPluginDescriptors(items, dirname, alias) {
+  return createDescriptors("plugin", items, dirname, alias);
+}
+
+function createDescriptors(type, items, dirname, alias, ownPass) {
+  var descriptors = items.map(function (item, index) {
+    return createDescriptor(item, dirname, {
+      type: type,
+      alias: alias + "$" + index,
+      ownPass: !!ownPass
+    });
+  });
+  assertNoDuplicates(descriptors);
+  return descriptors;
+}
+
+function createDescriptor(pair, dirname, _ref) {
+  var type = _ref.type,
+      alias = _ref.alias,
+      ownPass = _ref.ownPass;
+  var desc = (0, _item.getItemDescriptor)(pair);
+
+  if (desc) {
+    return desc;
+  }
+
+  var name;
+  var options;
+  var value = pair;
+
+  if (Array.isArray(value)) {
+    if (value.length === 3) {
+      var _value = value;
+      value = _value[0];
+      options = _value[1];
+      name = _value[2];
+    } else {
+      var _value2 = value;
+      value = _value2[0];
+      options = _value2[1];
+    }
+  }
+
+  var file = undefined;
+  var filepath = null;
+
+  if (typeof value === "string") {
+    if (typeof type !== "string") {
+      throw new Error("To resolve a string-based item, the type of item must be given");
+    }
+
+    var resolver = type === "plugin" ? _files.loadPlugin : _files.loadPreset;
+    var _request = value;
+
+    var _resolver = resolver(value, dirname);
+
+    filepath = _resolver.filepath;
+    value = _resolver.value;
+    file = {
+      request: _request,
+      resolved: filepath
+    };
+  }
+
+  if (!value) {
+    throw new Error("Unexpected falsy value: " + String(value));
+  }
+
+  if (typeof value === "object" && value.__esModule) {
+    if (value.default) {
+      value = value.default;
+    } else {
+      throw new Error("Must export a default export when using ES6 modules.");
+    }
+  }
+
+  if (typeof value !== "object" && typeof value !== "function") {
+    throw new Error("Unsupported format: " + typeof value + ". Expected an object or a function.");
+  }
+
+  if (filepath !== null && typeof value === "object" && value) {
+    throw new Error("Plugin/Preset files are not allowed to export objects, only functions. In " + filepath);
+  }
+
+  return {
+    name: name,
+    alias: filepath || alias,
+    value: value,
+    options: options,
+    dirname: dirname,
+    ownPass: ownPass,
+    file: file
+  };
+}
+
+function assertNoDuplicates(items) {
+  var map = new Map();
+
+  for (var _iterator = items, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+    var _ref2;
+
+    if (_isArray) {
+      if (_i >= _iterator.length) break;
+      _ref2 = _iterator[_i++];
+    } else {
+      _i = _iterator.next();
+      if (_i.done) break;
+      _ref2 = _i.value;
+    }
+
+    var item = _ref2;
+    if (typeof item.value !== "function") continue;
+    var nameMap = map.get(item.value);
+
+    if (!nameMap) {
+      nameMap = new Set();
+      map.set(item.value, nameMap);
+    }
+
+    if (nameMap.has(item.name)) {
+      throw new Error(["Duplicate plugin/preset detected.", "If you'd like to use two separate instances of a plugin,", "they neen separate names, e.g.", "", "  plugins: [", "    ['some-plugin', {}],", "    ['some-plugin', {}, 'some unique name'],", "  ]"].join("\n"));
+    }
+
+    nameMap.add(item.name);
+  }
+}

node_modules/@babel/core/lib/config/files/configuration.js

@@ -0,0 +1,283 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findRelativeConfig = findRelativeConfig;
+exports.findRootConfig = findRootConfig;
+exports.loadConfig = loadConfig;
+
+function _debug() {
+  var data = _interopRequireDefault(require("debug"));
+
+  _debug = function _debug() {
+    return data;
+  };
+
+  return data;
+}
+
+function _path() {
+  var data = _interopRequireDefault(require("path"));
+
+  _path = function _path() {
+    return data;
+  };
+
+  return data;
+}
+
+function _fs() {
+  var data = _interopRequireDefault(require("fs"));
+
+  _fs = function _fs() {
+    return data;
+  };
+
+  return data;
+}
+
+function _json() {
+  var data = _interopRequireDefault(require("json5"));
+
+  _json = function _json() {
+    return data;
+  };
+
+  return data;
+}
+
+function _resolve() {
+  var data = _interopRequireDefault(require("resolve"));
+
+  _resolve = function _resolve() {
+    return data;
+  };
+
+  return data;
+}
+
+var _caching = require("../caching");
+
+var _configApi = _interopRequireDefault(require("../helpers/config-api"));
+
+var _utils = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var debug = (0, _debug().default)("babel:config:loading:files:configuration");
+var BABEL_CONFIG_JS_FILENAME = "babel.config.js";
+var BABELRC_FILENAME = ".babelrc";
+var BABELRC_JS_FILENAME = ".babelrc.js";
+var BABELIGNORE_FILENAME = ".babelignore";
+
+function findRelativeConfig(packageData, envName) {
+  var config = null;
+  var ignore = null;
+
+  var dirname = _path().default.dirname(packageData.filepath);
+
+  var _loop = function _loop() {
+    if (_isArray) {
+      if (_i >= _iterator.length) return "break";
+      _ref = _iterator[_i++];
+    } else {
+      _i = _iterator.next();
+      if (_i.done) return "break";
+      _ref = _i.value;
+    }
+
+    var loc = _ref;
+
+    if (!config) {
+      config = [BABELRC_FILENAME, BABELRC_JS_FILENAME].reduce(function (previousConfig, name) {
+        var filepath = _path().default.join(loc, name);
+
+        var config = readConfig(filepath, envName);
+
+        if (config && previousConfig) {
+          throw new Error("Multiple configuration files found. Please remove one:\n" + (" - " + _path().default.basename(previousConfig.filepath) + "\n") + (" - " + name + "\n") + ("from " + loc));
+        }
+
+        return config || previousConfig;
+      }, null);
+      var pkgConfig = packageData.pkg && packageData.pkg.dirname === loc ? packageToBabelConfig(packageData.pkg) : null;
+
+      if (pkgConfig) {
+        if (config) {
+          throw new Error("Multiple configuration files found. Please remove one:\n" + (" - " + _path().default.basename(pkgConfig.filepath) + "#babel\n") + (" - " + _path().default.basename(config.filepath) + "\n") + ("from " + loc));
+        }
+
+        config = pkgConfig;
+      }
+
+      if (config) {
+        debug("Found configuration %o from %o.", config.filepath, dirname);
+      }
+    }
+
+    if (!ignore) {
+      var ignoreLoc = _path().default.join(loc, BABELIGNORE_FILENAME);
+
+      ignore = readIgnoreConfig(ignoreLoc);
+
+      if (ignore) {
+        debug("Found ignore %o from %o.", ignore.filepath, dirname);
+      }
+    }
+  };
+
+  for (var _iterator = packageData.directories, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+    var _ref;
+
+    var _ret = _loop();
+
+    if (_ret === "break") break;
+  }
+
+  return {
+    config: config,
+    ignore: ignore
+  };
+}
+
+function findRootConfig(dirname, envName) {
+  var filepath = _path().default.resolve(dirname, BABEL_CONFIG_JS_FILENAME);
+
+  var conf = readConfig(filepath, envName);
+
+  if (conf) {
+    debug("Found root config %o in $o.", BABEL_CONFIG_JS_FILENAME, dirname);
+  }
+
+  return conf;
+}
+
+function loadConfig(name, dirname, envName) {
+  var filepath = _resolve().default.sync(name, {
+    basedir: dirname
+  });
+
+  var conf = readConfig(filepath, envName);
+
+  if (!conf) {
+    throw new Error("Config file " + filepath + " contains no configuration data");
+  }
+
+  debug("Loaded config %o from $o.", name, dirname);
+  return conf;
+}
+
+function readConfig(filepath, envName) {
+  return _path().default.extname(filepath) === ".js" ? readConfigJS(filepath, {
+    envName: envName
+  }) : readConfigJSON5(filepath);
+}
+
+var LOADING_CONFIGS = new Set();
+var readConfigJS = (0, _caching.makeStrongCache)(function (filepath, cache) {
+  if (!_fs().default.existsSync(filepath)) {
+    cache.forever();
+    return null;
+  }
+
+  if (LOADING_CONFIGS.has(filepath)) {
+    cache.never();
+    debug("Auto-ignoring usage of config %o.", filepath);
+    return {
+      filepath: filepath,
+      dirname: _path().default.dirname(filepath),
+      options: {}
+    };
+  }
+
+  var options;
+
+  try {
+    LOADING_CONFIGS.add(filepath);
+
+    var configModule = require(filepath);
+
+    options = configModule && configModule.__esModule ? configModule.default || undefined : configModule;
+  } catch (err) {
+    err.message = filepath + ": Error while loading config - " + err.message;
+    throw err;
+  } finally {
+    LOADING_CONFIGS.delete(filepath);
+  }
+
+  if (typeof options === "function") {
+    options = options((0, _configApi.default)(cache));
+    if (!cache.configured()) throwConfigError();
+  }
+
+  if (!options || typeof options !== "object" || Array.isArray(options)) {
+    throw new Error(filepath + ": Configuration should be an exported JavaScript object.");
+  }
+
+  if (typeof options.then === "function") {
+    throw new Error("You appear to be using an async configuration, " + "which your current version of Babel does not support. " + "We may add support for this in the future, " + "but if you're on the most recent version of @babel/core and still " + "seeing this error, then you'll need to synchronously return your config.");
+  }
+
+  return {
+    filepath: filepath,
+    dirname: _path().default.dirname(filepath),
+    options: options
+  };
+});
+var packageToBabelConfig = (0, _caching.makeWeakCache)(function (file) {
+  if (typeof file.options.babel === "undefined") return null;
+  var babel = file.options.babel;
+
+  if (typeof babel !== "object" || Array.isArray(babel) || babel === null) {
+    throw new Error(file.filepath + ": .babel property must be an object");
+  }
+
+  return {
+    filepath: file.filepath,
+    dirname: file.dirname,
+    options: babel
+  };
+});
+var readConfigJSON5 = (0, _utils.makeStaticFileCache)(function (filepath, content) {
+  var options;
+
+  try {
+    options = _json().default.parse(content);
+  } catch (err) {
+    err.message = filepath + ": Error while parsing config - " + err.message;
+    throw err;
+  }
+
+  if (!options) throw new Error(filepath + ": No config detected");
+
+  if (typeof options !== "object") {
+    throw new Error(filepath + ": Config returned typeof " + typeof options);
+  }
+
+  if (Array.isArray(options)) {
+    throw new Error(filepath + ": Expected config object but found array");
+  }
+
+  return {
+    filepath: filepath,
+    dirname: _path().default.dirname(filepath),
+    options: options
+  };
+});
+var readIgnoreConfig = (0, _utils.makeStaticFileCache)(function (filepath, content) {
+  var ignore = content.split("\n").map(function (line) {
+    return line.replace(/#(.*?)$/, "").trim();
+  }).filter(function (line) {
+    return !!line;
+  });
+  return {
+    filepath: filepath,
+    dirname: _path().default.dirname(filepath),
+    ignore: ignore
+  };
+});
+
+function throwConfigError() {
+  throw new Error("Caching was left unconfigured. Babel's plugins, presets, and .babelrc.js files can be configured\nfor various types of caching, using the first param of their handler functions:\n\nmodule.exports = function(api) {\n  // The API exposes the following:\n\n  // Cache the returned value forever and don't call this function again.\n  api.cache(true);\n\n  // Don't cache at all. Not recommended because it will be very slow.\n  api.cache(false);\n\n  // Cached based on the value of some function. If this function returns a value different from\n  // a previously-encountered value, the plugins will re-evaluate.\n  var env = api.cache(() => process.env.NODE_ENV);\n\n  // If testing for a specific env, we recommend specifics to avoid instantiating a plugin for\n  // any possible NODE_ENV value that might come up during plugin execution.\n  var isProd = api.cache(() => process.env.NODE_ENV === \"production\");\n\n  // .cache(fn) will perform a linear search though instances to find the matching plugin based\n  // based on previous instantiated plugins. If you want to recreate the plugin and discard the\n  // previous instance whenever something changes, you may use:\n  var isProd = api.cache.invalidate(() => process.env.NODE_ENV === \"production\");\n\n  // Note, we also expose the following more-verbose versions of the above examples:\n  api.cache.forever(); // api.cache(true)\n  api.cache.never();   // api.cache(false)\n  api.cache.using(fn); // api.cache(fn)\n\n  // Return the value that will be cached.\n  return { };\n};");
+}

node_modules/@babel/core/lib/config/files/index-browser.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findPackageData = findPackageData;
+exports.findRelativeConfig = findRelativeConfig;
+exports.findRootConfig = findRootConfig;
+exports.loadConfig = loadConfig;
+exports.resolvePlugin = resolvePlugin;
+exports.resolvePreset = resolvePreset;
+exports.loadPlugin = loadPlugin;
+exports.loadPreset = loadPreset;
+
+function findPackageData(filepath) {
+  return {
+    filepath: filepath,
+    directories: [],
+    pkg: null,
+    isPackage: false
+  };
+}
+
+function findRelativeConfig(pkgData, envName) {
+  return {
+    pkg: null,
+    config: null,
+    ignore: null
+  };
+}
+
+function findRootConfig(dirname, envName) {
+  return null;
+}
+
+function loadConfig(name, dirname, envName) {
+  throw new Error("Cannot load " + name + " relative to " + dirname + " in a browser");
+}
+
+function resolvePlugin(name, dirname) {
+  return null;
+}
+
+function resolvePreset(name, dirname) {
+  return null;
+}
+
+function loadPlugin(name, dirname) {
+  throw new Error("Cannot load plugin " + name + " relative to " + dirname + " in a browser");
+}
+
+function loadPreset(name, dirname) {
+  throw new Error("Cannot load preset " + name + " relative to " + dirname + " in a browser");
+}

node_modules/@babel/core/lib/config/files/index.js

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "findPackageData", {
+  enumerable: true,
+  get: function get() {
+    return _package.findPackageData;
+  }
+});
+Object.defineProperty(exports, "findRelativeConfig", {
+  enumerable: true,
+  get: function get() {
+    return _configuration.findRelativeConfig;
+  }
+});
+Object.defineProperty(exports, "findRootConfig", {
+  enumerable: true,
+  get: function get() {
+    return _configuration.findRootConfig;
+  }
+});
+Object.defineProperty(exports, "loadConfig", {
+  enumerable: true,
+  get: function get() {
+    return _configuration.loadConfig;
+  }
+});
+Object.defineProperty(exports, "resolvePlugin", {
+  enumerable: true,
+  get: function get() {
+    return _plugins.resolvePlugin;
+  }
+});
+Object.defineProperty(exports, "resolvePreset", {
+  enumerable: true,
+  get: function get() {
+    return _plugins.resolvePreset;
+  }
+});
+Object.defineProperty(exports, "loadPlugin", {
+  enumerable: true,
+  get: function get() {
+    return _plugins.loadPlugin;
+  }
+});
+Object.defineProperty(exports, "loadPreset", {
+  enumerable: true,
+  get: function get() {
+    return _plugins.loadPreset;
+  }
+});
+
+var _package = require("./package");
+
+var _configuration = require("./configuration");
+
+var _plugins = require("./plugins");
+
+({});

node_modules/@babel/core/lib/config/files/package.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findPackageData = findPackageData;
+
+function _path() {
+  var data = _interopRequireDefault(require("path"));
+
+  _path = function _path() {
+    return data;
+  };
+
+  return data;
+}
+
+var _utils = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var PACKAGE_FILENAME = "package.json";
+
+function findPackageData(filepath) {
+  var pkg = null;
+  var directories = [];
+  var isPackage = true;
+
+  var dirname = _path().default.dirname(filepath);
+
+  while (!pkg && _path().default.basename(dirname) !== "node_modules") {
+    directories.push(dirname);
+    pkg = readConfigPackage(_path().default.join(dirname, PACKAGE_FILENAME));
+
+    var nextLoc = _path().default.dirname(dirname);
+
+    if (dirname === nextLoc) {
+      isPackage = false;
+      break;
+    }
+
+    dirname = nextLoc;
+  }
+
+  return {
+    filepath: filepath,
+    directories: directories,
+    pkg: pkg,
+    isPackage: isPackage
+  };
+}
+
+var readConfigPackage = (0, _utils.makeStaticFileCache)(function (filepath, content) {
+  var options;
+
+  try {
+    options = JSON.parse(content);
+  } catch (err) {
+    err.message = filepath + ": Error while parsing JSON - " + err.message;
+    throw err;
+  }
+
+  if (typeof options !== "object") {
+    throw new Error(filepath + ": Config returned typeof " + typeof options);
+  }
+
+  if (Array.isArray(options)) {
+    throw new Error(filepath + ": Expected config object but found array");
+  }
+
+  return {
+    filepath: filepath,
+    dirname: _path().default.dirname(filepath),
+    options: options
+  };
+});

node_modules/@babel/core/lib/config/files/plugins.js

@@ -0,0 +1,172 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolvePlugin = resolvePlugin;
+exports.resolvePreset = resolvePreset;
+exports.loadPlugin = loadPlugin;
+exports.loadPreset = loadPreset;
+
+function _debug() {
+  var data = _interopRequireDefault(require("debug"));
+
+  _debug = function _debug() {
+    return data;
+  };
+
+  return data;
+}
+
+function _resolve() {
+  var data = _interopRequireDefault(require("resolve"));
+
+  _resolve = function _resolve() {
+    return data;
+  };
+
+  return data;
+}
+
+function _path() {
+  var data = _interopRequireDefault(require("path"));
+
+  _path = function _path() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var debug = (0, _debug().default)("babel:config:loading:files:plugins");
+var EXACT_RE = /^module:/;
+var BABEL_PLUGIN_PREFIX_RE = /^(?!@|module:|[^/]+\/|babel-plugin-)/;
+var BABEL_PRESET_PREFIX_RE = /^(?!@|module:|[^/]+\/|babel-preset-)/;
+var BABEL_PLUGIN_ORG_RE = /^(@babel\/)(?!plugin-|[^/]+\/)/;
+var BABEL_PRESET_ORG_RE = /^(@babel\/)(?!preset-|[^/]+\/)/;
+var OTHER_PLUGIN_ORG_RE = /^(@(?!babel\/)[^/]+\/)(?!babel-plugin-|[^/]+\/)/;
+var OTHER_PRESET_ORG_RE = /^(@(?!babel\/)[^/]+\/)(?!babel-preset-|[^/]+\/)/;
+
+function resolvePlugin(name, dirname) {
+  return resolveStandardizedName("plugin", name, dirname);
+}
+
+function resolvePreset(name, dirname) {
+  return resolveStandardizedName("preset", name, dirname);
+}
+
+function loadPlugin(name, dirname) {
+  var filepath = resolvePlugin(name, dirname);
+
+  if (!filepath) {
+    throw new Error("Plugin " + name + " not found relative to " + dirname);
+  }
+
+  var value = requireModule("plugin", filepath);
+  debug("Loaded plugin %o from %o.", name, dirname);
+  return {
+    filepath: filepath,
+    value: value
+  };
+}
+
+function loadPreset(name, dirname) {
+  var filepath = resolvePreset(name, dirname);
+
+  if (!filepath) {
+    throw new Error("Preset " + name + " not found relative to " + dirname);
+  }
+
+  var value = requireModule("preset", filepath);
+  debug("Loaded preset %o from %o.", name, dirname);
+  return {
+    filepath: filepath,
+    value: value
+  };
+}
+
+function standardizeName(type, name) {
+  if (_path().default.isAbsolute(name)) return name;
+  var isPreset = type === "preset";
+  return name.replace(isPreset ? BABEL_PRESET_PREFIX_RE : BABEL_PLUGIN_PREFIX_RE, "babel-" + type + "-").replace(isPreset ? BABEL_PRESET_ORG_RE : BABEL_PLUGIN_ORG_RE, "$1" + type + "-").replace(isPreset ? OTHER_PRESET_ORG_RE : OTHER_PLUGIN_ORG_RE, "$1babel-" + type + "-").replace(EXACT_RE, "");
+}
+
+function resolveStandardizedName(type, name, dirname) {
+  if (dirname === void 0) {
+    dirname = process.cwd();
+  }
+
+  var standardizedName = standardizeName(type, name);
+
+  try {
+    return _resolve().default.sync(standardizedName, {
+      basedir: dirname
+    });
+  } catch (e) {
+    if (e.code !== "MODULE_NOT_FOUND") throw e;
+
+    if (standardizedName !== name) {
+      var resolvedOriginal = false;
+
+      try {
+        _resolve().default.sync(name, {
+          basedir: dirname
+        });
+
+        resolvedOriginal = true;
+      } catch (e2) {}
+
+      if (resolvedOriginal) {
+        e.message += "\n- If you want to resolve \"" + name + "\", use \"module:" + name + "\"";
+      }
+    }
+
+    var resolvedBabel = false;
+
+    try {
+      _resolve().default.sync(standardizeName(type, "@babel/" + name), {
+        basedir: dirname
+      });
+
+      resolvedBabel = true;
+    } catch (e2) {}
+
+    if (resolvedBabel) {
+      e.message += "\n- Did you mean \"@babel/" + name + "\"?";
+    }
+
+    var resolvedOppositeType = false;
+    var oppositeType = type === "preset" ? "plugin" : "preset";
+
+    try {
+      _resolve().default.sync(standardizeName(oppositeType, name), {
+        basedir: dirname
+      });
+
+      resolvedOppositeType = true;
+    } catch (e2) {}
+
+    if (resolvedOppositeType) {
+      e.message += "\n- Did you accidentally pass a " + type + " as a " + oppositeType + "?";
+    }
+
+    throw e;
+  }
+}
+
+var LOADING_MODULES = new Set();
+
+function requireModule(type, name) {
+  if (LOADING_MODULES.has(name)) {
+    throw new Error("Reentrant " + type + " detected trying to load \"" + name + "\". This module is not ignored " + "and is trying to load itself while compiling itself, leading to a dependency cycle. " + 'We recommend adding it to your "ignore" list in your babelrc, or to a .babelignore.');
+  }
+
+  try {
+    LOADING_MODULES.add(name);
+    return require(name);
+  } finally {
+    LOADING_MODULES.delete(name);
+  }
+}

node_modules/@babel/core/lib/config/files/types.js

@@ -0,0 +1 @@
+"use strict";

node_modules/@babel/core/lib/config/files/utils.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makeStaticFileCache = makeStaticFileCache;
+
+function _fs() {
+  var data = _interopRequireDefault(require("fs"));
+
+  _fs = function _fs() {
+    return data;
+  };
+
+  return data;
+}
+
+var _caching = require("../caching");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function makeStaticFileCache(fn) {
+  return (0, _caching.makeStrongCache)(function (filepath, cache) {
+    if (cache.invalidate(function () {
+      return fileMtime(filepath);
+    }) === null) {
+      cache.forever();
+      return null;
+    }
+
+    return fn(filepath, _fs().default.readFileSync(filepath, "utf8"));
+  });
+}
+
+function fileMtime(filepath) {
+  try {
+    return +_fs().default.statSync(filepath).mtime;
+  } catch (e) {
+    if (e.code !== "ENOENT" && e.code !== "ENOTDIR") throw e;
+  }
+
+  return null;
+}

node_modules/@babel/core/lib/config/full.js

@@ -0,0 +1,281 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = loadFullConfig;
+
+var _util = require("./util");
+
+var context = _interopRequireWildcard(require("../index"));
+
+var _plugin = _interopRequireDefault(require("./plugin"));
+
+var _item = require("./item");
+
+var _configChain = require("./config-chain");
+
+function _traverse() {
+  var data = _interopRequireDefault(require("@babel/traverse"));
+
+  _traverse = function _traverse() {
+    return data;
+  };
+
+  return data;
+}
+
+var _caching = require("./caching");
+
+var _options = require("./validation/options");
+
+var _plugins = require("./validation/plugins");
+
+var _configApi = _interopRequireDefault(require("./helpers/config-api"));
+
+var _partial = _interopRequireDefault(require("./partial"));
+
+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; } }
+
+function loadFullConfig(inputOpts) {
+  var result = (0, _partial.default)(inputOpts);
+
+  if (!result) {
+    return null;
+  }
+
+  var options = result.options,
+      context = result.context;
+  var optionDefaults = {};
+  var passes = [[]];
+
+  try {
+    var plugins = options.plugins,
+        presets = options.presets;
+
+    if (!plugins || !presets) {
+      throw new Error("Assertion failure - plugins and presets exist");
+    }
+
+    var ignored = function recurseDescriptors(config, pass) {
+      var plugins = config.plugins.map(function (descriptor) {
+        return loadPluginDescriptor(descriptor, context);
+      });
+      var presets = config.presets.map(function (descriptor) {
+        return {
+          preset: loadPresetDescriptor(descriptor, context),
+          pass: descriptor.ownPass ? [] : pass
+        };
+      });
+
+      if (presets.length > 0) {
+        passes.splice.apply(passes, [1, 0].concat(presets.map(function (o) {
+          return o.pass;
+        }).filter(function (p) {
+          return p !== pass;
+        })));
+
+        for (var _iterator = presets, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+          var _ref2;
+
+          if (_isArray) {
+            if (_i >= _iterator.length) break;
+            _ref2 = _iterator[_i++];
+          } else {
+            _i = _iterator.next();
+            if (_i.done) break;
+            _ref2 = _i.value;
+          }
+
+          var _ref3 = _ref2;
+          var preset = _ref3.preset,
+              _pass = _ref3.pass;
+          if (!preset) return true;
+
+          var _ignored = recurseDescriptors({
+            plugins: preset.plugins,
+            presets: preset.presets
+          }, _pass);
+
+          if (_ignored) return true;
+          preset.options.forEach(function (opts) {
+            (0, _util.mergeOptions)(optionDefaults, opts);
+          });
+        }
+      }
+
+      if (plugins.length > 0) {
+        pass.unshift.apply(pass, plugins);
+      }
+    }({
+      plugins: plugins.map(function (item) {
+        var desc = (0, _item.getItemDescriptor)(item);
+
+        if (!desc) {
+          throw new Error("Assertion failure - must be config item");
+        }
+
+        return desc;
+      }),
+      presets: presets.map(function (item) {
+        var desc = (0, _item.getItemDescriptor)(item);
+
+        if (!desc) {
+          throw new Error("Assertion failure - must be config item");
+        }
+
+        return desc;
+      })
+    }, passes[0]);
+
+    if (ignored) return null;
+  } catch (e) {
+    if (!/^\[BABEL\]/.test(e.message)) {
+      e.message = "[BABEL] " + (context.filename || "unknown") + ": " + e.message;
+    }
+
+    throw e;
+  }
+
+  var opts = optionDefaults;
+  (0, _util.mergeOptions)(opts, options);
+  opts.plugins = passes[0];
+  opts.presets = passes.slice(1).filter(function (plugins) {
+    return plugins.length > 0;
+  }).map(function (plugins) {
+    return {
+      plugins: plugins
+    };
+  });
+  opts.passPerPreset = opts.presets.length > 0;
+  return {
+    options: opts,
+    passes: passes
+  };
+}
+
+var loadDescriptor = (0, _caching.makeWeakCache)(function (_ref4, cache) {
+  var value = _ref4.value,
+      options = _ref4.options,
+      dirname = _ref4.dirname,
+      alias = _ref4.alias;
+  if (options === false) throw new Error("Assertion failure");
+  options = options || {};
+  var item = value;
+
+  if (typeof value === "function") {
+    var api = Object.assign({}, context, (0, _configApi.default)(cache));
+
+    try {
+      item = value(api, options, dirname);
+    } catch (e) {
+      if (alias) {
+        e.message += " (While processing: " + JSON.stringify(alias) + ")";
+      }
+
+      throw e;
+    }
+  }
+
+  if (!item || typeof item !== "object") {
+    throw new Error("Plugin/Preset did not return an object.");
+  }
+
+  if (typeof item.then === "function") {
+    throw new Error("You appear to be using an async 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.");
+  }
+
+  return {
+    value: item,
+    options: options,
+    dirname: dirname,
+    alias: alias
+  };
+});
+
+function loadPluginDescriptor(descriptor, context) {
+  if (descriptor.value instanceof _plugin.default) {
+    if (descriptor.options) {
+      throw new Error("Passed options to an existing Plugin instance will not work.");
+    }
+
+    return descriptor.value;
+  }
+
+  return instantiatePlugin(loadDescriptor(descriptor, context), context);
+}
+
+var instantiatePlugin = (0, _caching.makeWeakCache)(function (_ref5, cache) {
+  var value = _ref5.value,
+      options = _ref5.options,
+      dirname = _ref5.dirname,
+      alias = _ref5.alias;
+  var pluginObj = (0, _plugins.validatePluginObject)(value);
+  var plugin = Object.assign({}, pluginObj);
+
+  if (plugin.visitor) {
+    plugin.visitor = _traverse().default.explode(Object.assign({}, plugin.visitor));
+  }
+
+  if (plugin.inherits) {
+    var inheritsDescriptor = {
+      name: undefined,
+      alias: alias + "$inherits",
+      value: plugin.inherits,
+      options: options,
+      dirname: dirname
+    };
+    var inherits = cache.invalidate(function (data) {
+      return loadPluginDescriptor(inheritsDescriptor, data);
+    });
+    plugin.pre = chain(inherits.pre, plugin.pre);
+    plugin.post = chain(inherits.post, plugin.post);
+    plugin.manipulateOptions = chain(inherits.manipulateOptions, plugin.manipulateOptions);
+    plugin.visitor = _traverse().default.visitors.merge([inherits.visitor || {}, plugin.visitor || {}]);
+  }
+
+  return new _plugin.default(plugin, options, alias);
+});
+
+var loadPresetDescriptor = function loadPresetDescriptor(descriptor, context) {
+  return (0, _configChain.buildPresetChain)(instantiatePreset(loadDescriptor(descriptor, context)), context);
+};
+
+var instantiatePreset = (0, _caching.makeWeakCache)(function (_ref6) {
+  var value = _ref6.value,
+      dirname = _ref6.dirname,
+      alias = _ref6.alias;
+  return {
+    options: (0, _options.validate)("preset", value),
+    alias: alias,
+    dirname: dirname
+  };
+});
+
+function chain(a, b) {
+  var fns = [a, b].filter(Boolean);
+  if (fns.length <= 1) return fns[0];
+  return function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    for (var _iterator2 = fns, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+      var _ref7;
+
+      if (_isArray2) {
+        if (_i2 >= _iterator2.length) break;
+        _ref7 = _iterator2[_i2++];
+      } else {
+        _i2 = _iterator2.next();
+        if (_i2.done) break;
+        _ref7 = _i2.value;
+      }
+
+      var fn = _ref7;
+      fn.apply(this, args);
+    }
+  };
+}

node_modules/@babel/core/lib/config/helpers/config-api.js

@@ -0,0 +1,80 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = makeAPI;
+
+function _semver() {
+  var data = _interopRequireDefault(require("semver"));
+
+  _semver = function _semver() {
+    return data;
+  };
+
+  return data;
+}
+
+var _ = require("../../");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function makeAPI(cache) {
+  var env = function env(value) {
+    return cache.using(function (data) {
+      if (typeof value === "undefined") return data.envName;
+      if (typeof value === "function") return value(data.envName);
+      if (!Array.isArray(value)) value = [value];
+      return value.some(function (entry) {
+        if (typeof entry !== "string") {
+          throw new Error("Unexpected non-string value");
+        }
+
+        return entry === data.envName;
+      });
+    });
+  };
+
+  return {
+    version: _.version,
+    cache: cache.simple(),
+    env: env,
+    async: function async() {
+      return false;
+    },
+    assertVersion: assertVersion
+  };
+}
+
+function assertVersion(range) {
+  if (typeof range === "number") {
+    if (!Number.isInteger(range)) {
+      throw new Error("Expected string or integer value.");
+    }
+
+    range = "^" + range + ".0.0-0";
+  }
+
+  if (typeof range !== "string") {
+    throw new Error("Expected string or integer value.");
+  }
+
+  if (_semver().default.satisfies(_.version, range)) return;
+  var limit = Error.stackTraceLimit;
+
+  if (typeof limit === "number" && limit < 25) {
+    Error.stackTraceLimit = 25;
+  }
+
+  var err = new Error("Requires Babel \"" + range + "\", but was loaded with \"" + _.version + "\". " + "If you are sure you have a compatible version of @babel/core, " + "it is likely that something in your build process is loading the " + "wrong version. Inspect the stack trace of this error to look for " + "the first entry that doesn't mention \"@babel/core\" or \"babel-core\" " + "to see what is calling Babel.");
+
+  if (typeof limit === "number") {
+    Error.stackTraceLimit = limit;
+  }
+
+  throw Object.assign(err, {
+    code: "BABEL_VERSION_UNSUPPORTED",
+    version: _.version,
+    range: range
+  });
+}

node_modules/@babel/core/lib/config/helpers/environment.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getEnv = getEnv;
+
+function getEnv(defaultValue) {
+  if (defaultValue === void 0) {
+    defaultValue = "development";
+  }
+
+  return process.env.BABEL_ENV || process.env.NODE_ENV || defaultValue;
+}

node_modules/@babel/core/lib/config/index.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadOptions = loadOptions;
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function get() {
+    return _full.default;
+  }
+});
+Object.defineProperty(exports, "loadPartialConfig", {
+  enumerable: true,
+  get: function get() {
+    return _partial.loadPartialConfig;
+  }
+});
+exports.OptionManager = void 0;
+
+var _full = _interopRequireDefault(require("./full"));
+
+var _partial = require("./partial");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function loadOptions(opts) {
+  var config = (0, _full.default)(opts);
+  return config ? config.options : null;
+}
+
+var OptionManager = function () {
+  function OptionManager() {}
+
+  var _proto = OptionManager.prototype;
+
+  _proto.init = function init(opts) {
+    return loadOptions(opts);
+  };
+
+  return OptionManager;
+}();
+
+exports.OptionManager = OptionManager;

node_modules/@babel/core/lib/config/item.js

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createItemFromDescriptor = createItemFromDescriptor;
+exports.createConfigItem = createConfigItem;
+exports.getItemDescriptor = getItemDescriptor;
+
+function _path() {
+  var data = _interopRequireDefault(require("path"));
+
+  _path = function _path() {
+    return data;
+  };
+
+  return data;
+}
+
+var _configDescriptors = require("./config-descriptors");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function createItemFromDescriptor(desc) {
+  return new ConfigItem(desc);
+}
+
+function createConfigItem(value, _temp) {
+  var _ref = _temp === void 0 ? {} : _temp,
+      _ref$dirname = _ref.dirname,
+      dirname = _ref$dirname === void 0 ? "." : _ref$dirname,
+      type = _ref.type;
+
+  var descriptor = (0, _configDescriptors.createDescriptor)(value, _path().default.resolve(dirname), {
+    type: type,
+    alias: "programmatic item"
+  });
+  return createItemFromDescriptor(descriptor);
+}
+
+function getItemDescriptor(item) {
+  if (item instanceof ConfigItem) {
+    return item._descriptor;
+  }
+
+  return undefined;
+}
+
+var ConfigItem = function ConfigItem(descriptor) {
+  this._descriptor = descriptor;
+  Object.defineProperty(this, "_descriptor", {
+    enumerable: false
+  });
+
+  if (this._descriptor.options === false) {
+    throw new Error("Assertion failure - unexpected false options");
+  }
+
+  this.value = this._descriptor.value;
+  this.options = this._descriptor.options;
+  this.dirname = this._descriptor.dirname;
+  this.name = this._descriptor.name;
+  this.file = this._descriptor.file ? {
+    request: this._descriptor.file.request,
+    resolved: this._descriptor.file.resolved
+  } : undefined;
+  Object.freeze(this);
+};
+
+Object.freeze(ConfigItem.prototype);

node_modules/@babel/core/lib/config/partial.js

@@ -0,0 +1,109 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = loadPrivatePartialConfig;
+exports.loadPartialConfig = loadPartialConfig;
+
+function _path() {
+  var data = _interopRequireDefault(require("path"));
+
+  _path = function _path() {
+    return data;
+  };
+
+  return data;
+}
+
+var _plugin = _interopRequireDefault(require("./plugin"));
+
+var _util = require("./util");
+
+var _item = require("./item");
+
+var _configChain = require("./config-chain");
+
+var _environment = require("./helpers/environment");
+
+var _options = require("./validation/options");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function loadPrivatePartialConfig(inputOpts) {
+  if (inputOpts != null && (typeof inputOpts !== "object" || Array.isArray(inputOpts))) {
+    throw new Error("Babel options must be an object, null, or undefined");
+  }
+
+  var args = inputOpts ? (0, _options.validate)("arguments", inputOpts) : {};
+  var _args$envName = args.envName,
+      envName = _args$envName === void 0 ? (0, _environment.getEnv)() : _args$envName,
+      _args$cwd = args.cwd,
+      cwd = _args$cwd === void 0 ? "." : _args$cwd;
+
+  var absoluteCwd = _path().default.resolve(cwd);
+
+  var context = {
+    filename: args.filename ? _path().default.resolve(cwd, args.filename) : null,
+    cwd: absoluteCwd,
+    envName: envName
+  };
+  var configChain = (0, _configChain.buildRootChain)(args, context);
+  if (!configChain) return null;
+  var options = {};
+  configChain.options.forEach(function (opts) {
+    (0, _util.mergeOptions)(options, opts);
+  });
+  options.babelrc = false;
+  options.envName = envName;
+  options.cwd = absoluteCwd;
+  options.passPerPreset = false;
+  options.plugins = configChain.plugins.map(function (descriptor) {
+    return (0, _item.createItemFromDescriptor)(descriptor);
+  });
+  options.presets = configChain.presets.map(function (descriptor) {
+    return (0, _item.createItemFromDescriptor)(descriptor);
+  });
+  return {
+    options: options,
+    context: context,
+    ignore: configChain.ignore,
+    babelrc: configChain.babelrc,
+    config: configChain.config
+  };
+}
+
+function loadPartialConfig(inputOpts) {
+  var result = loadPrivatePartialConfig(inputOpts);
+  if (!result) return null;
+  var options = result.options,
+      babelrc = result.babelrc,
+      ignore = result.ignore,
+      config = result.config;
+  (options.plugins || []).forEach(function (item) {
+    if (item.value instanceof _plugin.default) {
+      throw new Error("Passing cached plugin instances is not supported in " + "babel.loadPartialConfig()");
+    }
+  });
+  return new PartialConfig(options, babelrc ? babelrc.filepath : undefined, ignore ? ignore.filepath : undefined, config ? config.filepath : undefined);
+}
+
+var PartialConfig = function () {
+  function PartialConfig(options, babelrc, ignore, config) {
+    this.options = options;
+    this.babelignore = ignore;
+    this.babelrc = babelrc;
+    this.config = config;
+    Object.freeze(this);
+  }
+
+  var _proto = PartialConfig.prototype;
+
+  _proto.hasFilesystemConfig = function hasFilesystemConfig() {
+    return this.babelrc !== undefined || this.config !== undefined;
+  };
+
+  return PartialConfig;
+}();
+
+Object.freeze(PartialConfig.prototype);

node_modules/@babel/core/lib/config/plugin.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var Plugin = function Plugin(plugin, options, key) {
+  this.key = plugin.name || key;
+  this.manipulateOptions = plugin.manipulateOptions;
+  this.post = plugin.post;
+  this.pre = plugin.pre;
+  this.visitor = plugin.visitor || {};
+  this.parserOverride = plugin.parserOverride;
+  this.generatorOverride = plugin.generatorOverride;
+  this.options = options;
+};
+
+exports.default = Plugin;

node_modules/@babel/core/lib/config/util.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mergeOptions = mergeOptions;
+
+function mergeOptions(target, source) {
+  var _arr = Object.keys(source);
+
+  for (var _i = 0; _i < _arr.length; _i++) {
+    var k = _arr[_i];
+
+    if (k === "parserOpts" && source.parserOpts) {
+      var parserOpts = source.parserOpts;
+      var targetObj = target.parserOpts = target.parserOpts || {};
+      mergeDefaultFields(targetObj, parserOpts);
+    } else if (k === "generatorOpts" && source.generatorOpts) {
+      var generatorOpts = source.generatorOpts;
+
+      var _targetObj = target.generatorOpts = target.generatorOpts || {};
+
+      mergeDefaultFields(_targetObj, generatorOpts);
+    } else {
+      var val = source[k];
+      if (val !== undefined) target[k] = val;
+    }
+  }
+}
+
+function mergeDefaultFields(target, source) {
+  var _arr2 = Object.keys(source);
+
+  for (var _i2 = 0; _i2 < _arr2.length; _i2++) {
+    var k = _arr2[_i2];
+    var val = source[k];
+    if (val !== undefined) target[k] = val;
+  }
+}

node_modules/@babel/core/lib/config/validation/option-assertions.js

@@ -0,0 +1,209 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assertSourceMaps = assertSourceMaps;
+exports.assertCompact = assertCompact;
+exports.assertSourceType = assertSourceType;
+exports.assertInputSourceMap = assertInputSourceMap;
+exports.assertString = assertString;
+exports.assertFunction = assertFunction;
+exports.assertBoolean = assertBoolean;
+exports.assertObject = assertObject;
+exports.assertArray = assertArray;
+exports.assertIgnoreList = assertIgnoreList;
+exports.assertConfigApplicableTest = assertConfigApplicableTest;
+exports.assertConfigFileSearch = assertConfigFileSearch;
+exports.assertBabelrcSearch = assertBabelrcSearch;
+exports.assertPluginList = assertPluginList;
+
+function assertSourceMaps(key, value) {
+  if (value !== undefined && typeof value !== "boolean" && value !== "inline" && value !== "both") {
+    throw new Error("." + key + " must be a boolean, \"inline\", \"both\", or undefined");
+  }
+
+  return value;
+}
+
+function assertCompact(key, value) {
+  if (value !== undefined && typeof value !== "boolean" && value !== "auto") {
+    throw new Error("." + key + " must be a boolean, \"auto\", or undefined");
+  }
+
+  return value;
+}
+
+function assertSourceType(key, value) {
+  if (value !== undefined && value !== "module" && value !== "script" && value !== "unambiguous") {
+    throw new Error("." + key + " must be \"module\", \"script\", \"unambiguous\", or undefined");
+  }
+
+  return value;
+}
+
+function assertInputSourceMap(key, value) {
+  if (value !== undefined && typeof value !== "boolean" && (typeof value !== "object" || !value)) {
+    throw new Error(".inputSourceMap must be a boolean, object, or undefined");
+  }
+
+  return value;
+}
+
+function assertString(key, value) {
+  if (value !== undefined && typeof value !== "string") {
+    throw new Error("." + key + " must be a string, or undefined");
+  }
+
+  return value;
+}
+
+function assertFunction(key, value) {
+  if (value !== undefined && typeof value !== "function") {
+    throw new Error("." + key + " must be a function, or undefined");
+  }
+
+  return value;
+}
+
+function assertBoolean(key, value) {
+  if (value !== undefined && typeof value !== "boolean") {
+    throw new Error("." + key + " must be a boolean, or undefined");
+  }
+
+  return value;
+}
+
+function assertObject(key, value) {
+  if (value !== undefined && (typeof value !== "object" || Array.isArray(value) || !value)) {
+    throw new Error("." + key + " must be an object, or undefined");
+  }
+
+  return value;
+}
+
+function assertArray(key, value) {
+  if (value != null && !Array.isArray(value)) {
+    throw new Error("." + key + " must be an array, or undefined");
+  }
+
+  return value;
+}
+
+function assertIgnoreList(key, value) {
+  var arr = assertArray(key, value);
+
+  if (arr) {
+    arr.forEach(function (item, i) {
+      return assertIgnoreItem(key, i, item);
+    });
+  }
+
+  return arr;
+}
+
+function assertIgnoreItem(key, index, value) {
+  if (typeof value !== "string" && typeof value !== "function" && !(value instanceof RegExp)) {
+    throw new Error("." + key + "[" + index + "] must be an array of string/Funtion/RegExp values, or undefined");
+  }
+
+  return value;
+}
+
+function assertConfigApplicableTest(key, value) {
+  if (value === undefined) return value;
+
+  if (Array.isArray(value)) {
+    value.forEach(function (item, i) {
+      if (!checkValidTest(item)) {
+        throw new Error("." + key + "[" + i + "] must be a string/Function/RegExp.");
+      }
+    });
+  } else if (!checkValidTest(value)) {
+    throw new Error("." + key + " must be a string/Function/RegExp, or an array of those");
+  }
+
+  return value;
+}
+
+function checkValidTest(value) {
+  return typeof value === "string" || typeof value === "function" || value instanceof RegExp;
+}
+
+function assertConfigFileSearch(key, value) {
+  if (value !== undefined && typeof value !== "boolean" && typeof value !== "string") {
+    throw new Error("." + key + " must be a undefined, a boolean, a string, " + ("got " + JSON.stringify(value)));
+  }
+
+  return value;
+}
+
+function assertBabelrcSearch(key, value) {
+  if (value === undefined || typeof value === "boolean") return value;
+
+  if (Array.isArray(value)) {
+    value.forEach(function (item, i) {
+      if (typeof item !== "string") {
+        throw new Error("." + key + "[" + i + "] must be a string.");
+      }
+    });
+  } else if (typeof value !== "string") {
+    throw new Error("." + key + " must be a undefined, a boolean, a string, " + ("or an array of strings, got " + JSON.stringify(value)));
+  }
+
+  return value;
+}
+
+function assertPluginList(key, value) {
+  var arr = assertArray(key, value);
+
+  if (arr) {
+    arr.forEach(function (item, i) {
+      return assertPluginItem(key, i, item);
+    });
+  }
+
+  return arr;
+}
+
+function assertPluginItem(key, index, value) {
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      throw new Error("." + key + "[" + index + "] must include an object");
+    }
+
+    if (value.length > 3) {
+      throw new Error("." + key + "[" + index + "] may only be a two-tuple or three-tuple");
+    }
+
+    assertPluginTarget(key, index, true, value[0]);
+
+    if (value.length > 1) {
+      var opts = value[1];
+
+      if (opts !== undefined && opts !== false && (typeof opts !== "object" || Array.isArray(opts))) {
+        throw new Error("." + key + "[" + index + "][1] must be an object, false, or undefined");
+      }
+    }
+
+    if (value.length === 3) {
+      var name = value[2];
+
+      if (name !== undefined && typeof name !== "string") {
+        throw new Error("." + key + "[" + index + "][2] must be a string, or undefined");
+      }
+    }
+  } else {
+    assertPluginTarget(key, index, false, value);
+  }
+
+  return value;
+}
+
+function assertPluginTarget(key, index, inArray, value) {
+  if ((typeof value !== "object" || !value) && typeof value !== "string" && typeof value !== "function") {
+    throw new Error("." + key + "[" + index + "]" + (inArray ? "[0]" : "") + " must be a string, object, function");
+  }
+
+  return value;
+}

node_modules/@babel/core/lib/config/validation/options.js

@@ -0,0 +1,163 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validate = validate;
+
+var _plugin = _interopRequireDefault(require("../plugin"));
+
+var _removed = _interopRequireDefault(require("./removed"));
+
+var _optionAssertions = require("./option-assertions");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var ROOT_VALIDATORS = {
+  cwd: _optionAssertions.assertString,
+  root: _optionAssertions.assertString,
+  configFile: _optionAssertions.assertConfigFileSearch,
+  filename: _optionAssertions.assertString,
+  filenameRelative: _optionAssertions.assertString,
+  babelrc: _optionAssertions.assertBoolean,
+  babelrcRoots: _optionAssertions.assertBabelrcSearch,
+  code: _optionAssertions.assertBoolean,
+  ast: _optionAssertions.assertBoolean,
+  envName: _optionAssertions.assertString
+};
+var NONPRESET_VALIDATORS = {
+  extends: _optionAssertions.assertString,
+  env: assertEnvSet,
+  ignore: _optionAssertions.assertIgnoreList,
+  only: _optionAssertions.assertIgnoreList,
+  overrides: assertOverridesList,
+  test: _optionAssertions.assertConfigApplicableTest,
+  include: _optionAssertions.assertConfigApplicableTest,
+  exclude: _optionAssertions.assertConfigApplicableTest
+};
+var COMMON_VALIDATORS = {
+  inputSourceMap: _optionAssertions.assertInputSourceMap,
+  presets: _optionAssertions.assertPluginList,
+  plugins: _optionAssertions.assertPluginList,
+  passPerPreset: _optionAssertions.assertBoolean,
+  retainLines: _optionAssertions.assertBoolean,
+  comments: _optionAssertions.assertBoolean,
+  shouldPrintComment: _optionAssertions.assertFunction,
+  compact: _optionAssertions.assertCompact,
+  minified: _optionAssertions.assertBoolean,
+  auxiliaryCommentBefore: _optionAssertions.assertString,
+  auxiliaryCommentAfter: _optionAssertions.assertString,
+  sourceType: _optionAssertions.assertSourceType,
+  wrapPluginVisitorMethod: _optionAssertions.assertFunction,
+  highlightCode: _optionAssertions.assertBoolean,
+  sourceMaps: _optionAssertions.assertSourceMaps,
+  sourceMap: _optionAssertions.assertSourceMaps,
+  sourceFileName: _optionAssertions.assertString,
+  sourceRoot: _optionAssertions.assertString,
+  getModuleId: _optionAssertions.assertFunction,
+  moduleRoot: _optionAssertions.assertString,
+  moduleIds: _optionAssertions.assertBoolean,
+  moduleId: _optionAssertions.assertString,
+  parserOpts: _optionAssertions.assertObject,
+  generatorOpts: _optionAssertions.assertObject
+};
+
+function validate(type, opts) {
+  assertNoDuplicateSourcemap(opts);
+  Object.keys(opts).forEach(function (key) {
+    if (type === "preset" && NONPRESET_VALIDATORS[key]) {
+      throw new Error("." + key + " is not allowed in preset options");
+    }
+
+    if (type !== "arguments" && ROOT_VALIDATORS[key]) {
+      throw new Error("." + key + " is only allowed in root programmatic options");
+    }
+
+    if (type === "env" && key === "env") {
+      throw new Error("." + key + " is not allowed inside another env block");
+    }
+
+    if (type === "env" && key === "overrides") {
+      throw new Error("." + key + " is not allowed inside an env block");
+    }
+
+    if (type === "override" && key === "overrides") {
+      throw new Error("." + key + " is not allowed inside an overrides block");
+    }
+
+    var validator = COMMON_VALIDATORS[key] || NONPRESET_VALIDATORS[key] || ROOT_VALIDATORS[key];
+    if (validator) validator(key, opts[key]);else throw buildUnknownError(key);
+  });
+  return opts;
+}
+
+function buildUnknownError(key) {
+  if (_removed.default[key]) {
+    var _removed$key = _removed.default[key],
+        message = _removed$key.message,
+        _removed$key$version = _removed$key.version,
+        version = _removed$key$version === void 0 ? 5 : _removed$key$version;
+    throw new ReferenceError("Using removed Babel " + version + " option: ." + key + " - " + message);
+  } else {
+    var unknownOptErr = "Unknown option: ." + key + ". Check out http://babeljs.io/docs/usage/options/ for more information about options.";
+    throw new ReferenceError(unknownOptErr);
+  }
+}
+
+function has(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+function assertNoDuplicateSourcemap(opts) {
+  if (has(opts, "sourceMap") && has(opts, "sourceMaps")) {
+    throw new Error(".sourceMap is an alias for .sourceMaps, cannot use both");
+  }
+}
+
+function assertEnvSet(key, value) {
+  var obj = (0, _optionAssertions.assertObject)(key, value);
+
+  if (obj) {
+    var _arr = Object.keys(obj);
+
+    for (var _i = 0; _i < _arr.length; _i++) {
+      var _key = _arr[_i];
+
+      var _env = (0, _optionAssertions.assertObject)(_key, obj[_key]);
+
+      if (_env) validate("env", _env);
+    }
+  }
+
+  return obj;
+}
+
+function assertOverridesList(key, value) {
+  var arr = (0, _optionAssertions.assertArray)(key, value);
+
+  if (arr) {
+    for (var _iterator = arr.entries(), _isArray = Array.isArray(_iterator), _i2 = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+      var _ref;
+
+      if (_isArray) {
+        if (_i2 >= _iterator.length) break;
+        _ref = _iterator[_i2++];
+      } else {
+        _i2 = _iterator.next();
+        if (_i2.done) break;
+        _ref = _i2.value;
+      }
+
+      var _ref2 = _ref,
+          index = _ref2[0],
+          item = _ref2[1];
+
+      var _env2 = (0, _optionAssertions.assertObject)("" + index, item);
+
+      if (!_env2) throw new Error("." + key + "[" + index + "] must be an object");
+      validate("override", _env2);
+    }
+  }
+
+  return arr;
+}

node_modules/@babel/core/lib/config/validation/plugins.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validatePluginObject = validatePluginObject;
+
+var _optionAssertions = require("./option-assertions");
+
+var VALIDATORS = {
+  name: _optionAssertions.assertString,
+  manipulateOptions: _optionAssertions.assertFunction,
+  pre: _optionAssertions.assertFunction,
+  post: _optionAssertions.assertFunction,
+  inherits: _optionAssertions.assertFunction,
+  visitor: assertVisitorMap,
+  parserOverride: _optionAssertions.assertFunction,
+  generatorOverride: _optionAssertions.assertFunction
+};
+
+function assertVisitorMap(key, value) {
+  var obj = (0, _optionAssertions.assertObject)(key, value);
+
+  if (obj) {
+    Object.keys(obj).forEach(function (prop) {
+      return assertVisitorHandler(prop, obj[prop]);
+    });
+
+    if (obj.enter || obj.exit) {
+      throw new Error("." + key + " cannot contain catch-all \"enter\" or \"exit\" handlers. Please target individual nodes.");
+    }
+  }
+
+  return obj;
+}
+
+function assertVisitorHandler(key, value) {
+  if (value && typeof value === "object") {
+    Object.keys(value).forEach(function (handler) {
+      if (handler !== "enter" && handler !== "exit") {
+        throw new Error(".visitor[\"" + key + "\"] may only have .enter and/or .exit handlers.");
+      }
+    });
+  } else if (typeof value !== "function") {
+    throw new Error(".visitor[\"" + key + "\"] must be a function");
+  }
+
+  return value;
+}
+
+function validatePluginObject(obj) {
+  Object.keys(obj).forEach(function (key) {
+    var validator = VALIDATORS[key];
+    if (validator) validator(key, obj[key]);else throw new Error("." + key + " is not a valid Plugin property");
+  });
+  return obj;
+}

node_modules/@babel/core/lib/config/validation/removed.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = {
+  auxiliaryComment: {
+    message: "Use `auxiliaryCommentBefore` or `auxiliaryCommentAfter`"
+  },
+  blacklist: {
+    message: "Put the specific transforms you want in the `plugins` option"
+  },
+  breakConfig: {
+    message: "This is not a necessary option in Babel 6"
+  },
+  experimental: {
+    message: "Put the specific transforms you want in the `plugins` option"
+  },
+  externalHelpers: {
+    message: "Use the `external-helpers` plugin instead. " + "Check out http://babeljs.io/docs/plugins/external-helpers/"
+  },
+  extra: {
+    message: ""
+  },
+  jsxPragma: {
+    message: "use the `pragma` option in the `react-jsx` plugin. " + "Check out http://babeljs.io/docs/plugins/transform-react-jsx/"
+  },
+  loose: {
+    message: "Specify the `loose` option for the relevant plugin you are using " + "or use a preset that sets the option."
+  },
+  metadataUsedHelpers: {
+    message: "Not required anymore as this is enabled by default"
+  },
+  modules: {
+    message: "Use the corresponding module transform plugin in the `plugins` option. " + "Check out http://babeljs.io/docs/plugins/#modules"
+  },
+  nonStandard: {
+    message: "Use the `react-jsx` and `flow-strip-types` plugins to support JSX and Flow. " + "Also check out the react preset http://babeljs.io/docs/plugins/preset-react/"
+  },
+  optional: {
+    message: "Put the specific transforms you want in the `plugins` option"
+  },
+  sourceMapName: {
+    message: "The `sourceMapName` option has been removed because it makes more sense for the " + "tooling that calls Babel to assign `map.file` themselves."
+  },
+  stage: {
+    message: "Check out the corresponding stage-x presets http://babeljs.io/docs/plugins/#presets"
+  },
+  whitelist: {
+    message: "Put the specific transforms you want in the `plugins` option"
+  },
+  resolveModuleSource: {
+    version: 6,
+    message: "Use `babel-plugin-module-resolver@3`'s 'resolvePath' options"
+  },
+  metadata: {
+    version: 6,
+    message: "Generated plugin metadata is always included in the output result"
+  },
+  sourceMapTarget: {
+    version: 6,
+    message: "The `sourceMapTarget` option has been removed because it makes more sense for the tooling " + "that calls Babel to assign `map.file` themselves."
+  }
+};
+exports.default = _default;