yeet

node_modules/@babel/preset-env/lib/available-plugins.js

@@ -0,0 +1,204 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _pluginSyntaxAsyncGenerators = _interopRequireDefault(require("@babel/plugin-syntax-async-generators"));
+
+var _pluginSyntaxClassProperties = _interopRequireDefault(require("@babel/plugin-syntax-class-properties"));
+
+var _pluginSyntaxDynamicImport = _interopRequireDefault(require("@babel/plugin-syntax-dynamic-import"));
+
+var _pluginSyntaxExportNamespaceFrom = _interopRequireDefault(require("@babel/plugin-syntax-export-namespace-from"));
+
+var _pluginSyntaxJsonStrings = _interopRequireDefault(require("@babel/plugin-syntax-json-strings"));
+
+var _pluginSyntaxLogicalAssignmentOperators = _interopRequireDefault(require("@babel/plugin-syntax-logical-assignment-operators"));
+
+var _pluginSyntaxNullishCoalescingOperator = _interopRequireDefault(require("@babel/plugin-syntax-nullish-coalescing-operator"));
+
+var _pluginSyntaxNumericSeparator = _interopRequireDefault(require("@babel/plugin-syntax-numeric-separator"));
+
+var _pluginSyntaxObjectRestSpread = _interopRequireDefault(require("@babel/plugin-syntax-object-rest-spread"));
+
+var _pluginSyntaxOptionalCatchBinding = _interopRequireDefault(require("@babel/plugin-syntax-optional-catch-binding"));
+
+var _pluginSyntaxOptionalChaining = _interopRequireDefault(require("@babel/plugin-syntax-optional-chaining"));
+
+var _pluginSyntaxTopLevelAwait = _interopRequireDefault(require("@babel/plugin-syntax-top-level-await"));
+
+var _pluginProposalAsyncGeneratorFunctions = _interopRequireDefault(require("@babel/plugin-proposal-async-generator-functions"));
+
+var _pluginProposalClassProperties = _interopRequireDefault(require("@babel/plugin-proposal-class-properties"));
+
+var _pluginProposalDynamicImport = _interopRequireDefault(require("@babel/plugin-proposal-dynamic-import"));
+
+var _pluginProposalExportNamespaceFrom = _interopRequireDefault(require("@babel/plugin-proposal-export-namespace-from"));
+
+var _pluginProposalJsonStrings = _interopRequireDefault(require("@babel/plugin-proposal-json-strings"));
+
+var _pluginProposalLogicalAssignmentOperators = _interopRequireDefault(require("@babel/plugin-proposal-logical-assignment-operators"));
+
+var _pluginProposalNullishCoalescingOperator = _interopRequireDefault(require("@babel/plugin-proposal-nullish-coalescing-operator"));
+
+var _pluginProposalNumericSeparator = _interopRequireDefault(require("@babel/plugin-proposal-numeric-separator"));
+
+var _pluginProposalObjectRestSpread = _interopRequireDefault(require("@babel/plugin-proposal-object-rest-spread"));
+
+var _pluginProposalOptionalCatchBinding = _interopRequireDefault(require("@babel/plugin-proposal-optional-catch-binding"));
+
+var _pluginProposalOptionalChaining = _interopRequireDefault(require("@babel/plugin-proposal-optional-chaining"));
+
+var _pluginProposalPrivateMethods = _interopRequireDefault(require("@babel/plugin-proposal-private-methods"));
+
+var _pluginProposalUnicodePropertyRegex = _interopRequireDefault(require("@babel/plugin-proposal-unicode-property-regex"));
+
+var _pluginTransformAsyncToGenerator = _interopRequireDefault(require("@babel/plugin-transform-async-to-generator"));
+
+var _pluginTransformArrowFunctions = _interopRequireDefault(require("@babel/plugin-transform-arrow-functions"));
+
+var _pluginTransformBlockScopedFunctions = _interopRequireDefault(require("@babel/plugin-transform-block-scoped-functions"));
+
+var _pluginTransformBlockScoping = _interopRequireDefault(require("@babel/plugin-transform-block-scoping"));
+
+var _pluginTransformClasses = _interopRequireDefault(require("@babel/plugin-transform-classes"));
+
+var _pluginTransformComputedProperties = _interopRequireDefault(require("@babel/plugin-transform-computed-properties"));
+
+var _pluginTransformDestructuring = _interopRequireDefault(require("@babel/plugin-transform-destructuring"));
+
+var _pluginTransformDotallRegex = _interopRequireDefault(require("@babel/plugin-transform-dotall-regex"));
+
+var _pluginTransformDuplicateKeys = _interopRequireDefault(require("@babel/plugin-transform-duplicate-keys"));
+
+var _pluginTransformExponentiationOperator = _interopRequireDefault(require("@babel/plugin-transform-exponentiation-operator"));
+
+var _pluginTransformForOf = _interopRequireDefault(require("@babel/plugin-transform-for-of"));
+
+var _pluginTransformFunctionName = _interopRequireDefault(require("@babel/plugin-transform-function-name"));
+
+var _pluginTransformLiterals = _interopRequireDefault(require("@babel/plugin-transform-literals"));
+
+var _pluginTransformMemberExpressionLiterals = _interopRequireDefault(require("@babel/plugin-transform-member-expression-literals"));
+
+var _pluginTransformModulesAmd = _interopRequireDefault(require("@babel/plugin-transform-modules-amd"));
+
+var _pluginTransformModulesCommonjs = _interopRequireDefault(require("@babel/plugin-transform-modules-commonjs"));
+
+var _pluginTransformModulesSystemjs = _interopRequireDefault(require("@babel/plugin-transform-modules-systemjs"));
+
+var _pluginTransformModulesUmd = _interopRequireDefault(require("@babel/plugin-transform-modules-umd"));
+
+var _pluginTransformNamedCapturingGroupsRegex = _interopRequireDefault(require("@babel/plugin-transform-named-capturing-groups-regex"));
+
+var _pluginTransformNewTarget = _interopRequireDefault(require("@babel/plugin-transform-new-target"));
+
+var _pluginTransformObjectSuper = _interopRequireDefault(require("@babel/plugin-transform-object-super"));
+
+var _pluginTransformParameters = _interopRequireDefault(require("@babel/plugin-transform-parameters"));
+
+var _pluginTransformPropertyLiterals = _interopRequireDefault(require("@babel/plugin-transform-property-literals"));
+
+var _pluginTransformRegenerator = _interopRequireDefault(require("@babel/plugin-transform-regenerator"));
+
+var _pluginTransformReservedWords = _interopRequireDefault(require("@babel/plugin-transform-reserved-words"));
+
+var _pluginTransformShorthandProperties = _interopRequireDefault(require("@babel/plugin-transform-shorthand-properties"));
+
+var _pluginTransformSpread = _interopRequireDefault(require("@babel/plugin-transform-spread"));
+
+var _pluginTransformStickyRegex = _interopRequireDefault(require("@babel/plugin-transform-sticky-regex"));
+
+var _pluginTransformTemplateLiterals = _interopRequireDefault(require("@babel/plugin-transform-template-literals"));
+
+var _pluginTransformTypeofSymbol = _interopRequireDefault(require("@babel/plugin-transform-typeof-symbol"));
+
+var _pluginTransformUnicodeEscapes = _interopRequireDefault(require("@babel/plugin-transform-unicode-escapes"));
+
+var _pluginTransformUnicodeRegex = _interopRequireDefault(require("@babel/plugin-transform-unicode-regex"));
+
+var _transformAsyncArrowsInClass = _interopRequireDefault(require("@babel/preset-modules/lib/plugins/transform-async-arrows-in-class"));
+
+var _transformEdgeDefaultParameters = _interopRequireDefault(require("@babel/preset-modules/lib/plugins/transform-edge-default-parameters"));
+
+var _transformEdgeFunctionName = _interopRequireDefault(require("@babel/preset-modules/lib/plugins/transform-edge-function-name"));
+
+var _transformTaggedTemplateCaching = _interopRequireDefault(require("@babel/preset-modules/lib/plugins/transform-tagged-template-caching"));
+
+var _transformSafariBlockShadowing = _interopRequireDefault(require("@babel/preset-modules/lib/plugins/transform-safari-block-shadowing"));
+
+var _transformSafariForShadowing = _interopRequireDefault(require("@babel/preset-modules/lib/plugins/transform-safari-for-shadowing"));
+
+var _pluginBugfixV8SpreadParametersInOptionalChaining = _interopRequireDefault(require("@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = {
+  "bugfix/transform-async-arrows-in-class": _transformAsyncArrowsInClass.default,
+  "bugfix/transform-edge-default-parameters": _transformEdgeDefaultParameters.default,
+  "bugfix/transform-edge-function-name": _transformEdgeFunctionName.default,
+  "bugfix/transform-safari-block-shadowing": _transformSafariBlockShadowing.default,
+  "bugfix/transform-safari-for-shadowing": _transformSafariForShadowing.default,
+  "bugfix/transform-tagged-template-caching": _transformTaggedTemplateCaching.default,
+  "bugfix/transform-v8-spread-parameters-in-optional-chaining": _pluginBugfixV8SpreadParametersInOptionalChaining.default,
+  "proposal-async-generator-functions": _pluginProposalAsyncGeneratorFunctions.default,
+  "proposal-class-properties": _pluginProposalClassProperties.default,
+  "proposal-dynamic-import": _pluginProposalDynamicImport.default,
+  "proposal-export-namespace-from": _pluginProposalExportNamespaceFrom.default,
+  "proposal-json-strings": _pluginProposalJsonStrings.default,
+  "proposal-logical-assignment-operators": _pluginProposalLogicalAssignmentOperators.default,
+  "proposal-nullish-coalescing-operator": _pluginProposalNullishCoalescingOperator.default,
+  "proposal-numeric-separator": _pluginProposalNumericSeparator.default,
+  "proposal-object-rest-spread": _pluginProposalObjectRestSpread.default,
+  "proposal-optional-catch-binding": _pluginProposalOptionalCatchBinding.default,
+  "proposal-optional-chaining": _pluginProposalOptionalChaining.default,
+  "proposal-private-methods": _pluginProposalPrivateMethods.default,
+  "proposal-unicode-property-regex": _pluginProposalUnicodePropertyRegex.default,
+  "syntax-async-generators": _pluginSyntaxAsyncGenerators.default,
+  "syntax-class-properties": _pluginSyntaxClassProperties.default,
+  "syntax-dynamic-import": _pluginSyntaxDynamicImport.default,
+  "syntax-export-namespace-from": _pluginSyntaxExportNamespaceFrom.default,
+  "syntax-json-strings": _pluginSyntaxJsonStrings.default,
+  "syntax-logical-assignment-operators": _pluginSyntaxLogicalAssignmentOperators.default,
+  "syntax-nullish-coalescing-operator": _pluginSyntaxNullishCoalescingOperator.default,
+  "syntax-numeric-separator": _pluginSyntaxNumericSeparator.default,
+  "syntax-object-rest-spread": _pluginSyntaxObjectRestSpread.default,
+  "syntax-optional-catch-binding": _pluginSyntaxOptionalCatchBinding.default,
+  "syntax-optional-chaining": _pluginSyntaxOptionalChaining.default,
+  "syntax-top-level-await": _pluginSyntaxTopLevelAwait.default,
+  "transform-arrow-functions": _pluginTransformArrowFunctions.default,
+  "transform-async-to-generator": _pluginTransformAsyncToGenerator.default,
+  "transform-block-scoped-functions": _pluginTransformBlockScopedFunctions.default,
+  "transform-block-scoping": _pluginTransformBlockScoping.default,
+  "transform-classes": _pluginTransformClasses.default,
+  "transform-computed-properties": _pluginTransformComputedProperties.default,
+  "transform-destructuring": _pluginTransformDestructuring.default,
+  "transform-dotall-regex": _pluginTransformDotallRegex.default,
+  "transform-duplicate-keys": _pluginTransformDuplicateKeys.default,
+  "transform-exponentiation-operator": _pluginTransformExponentiationOperator.default,
+  "transform-for-of": _pluginTransformForOf.default,
+  "transform-function-name": _pluginTransformFunctionName.default,
+  "transform-literals": _pluginTransformLiterals.default,
+  "transform-member-expression-literals": _pluginTransformMemberExpressionLiterals.default,
+  "transform-modules-amd": _pluginTransformModulesAmd.default,
+  "transform-modules-commonjs": _pluginTransformModulesCommonjs.default,
+  "transform-modules-systemjs": _pluginTransformModulesSystemjs.default,
+  "transform-modules-umd": _pluginTransformModulesUmd.default,
+  "transform-named-capturing-groups-regex": _pluginTransformNamedCapturingGroupsRegex.default,
+  "transform-new-target": _pluginTransformNewTarget.default,
+  "transform-object-super": _pluginTransformObjectSuper.default,
+  "transform-parameters": _pluginTransformParameters.default,
+  "transform-property-literals": _pluginTransformPropertyLiterals.default,
+  "transform-regenerator": _pluginTransformRegenerator.default,
+  "transform-reserved-words": _pluginTransformReservedWords.default,
+  "transform-shorthand-properties": _pluginTransformShorthandProperties.default,
+  "transform-spread": _pluginTransformSpread.default,
+  "transform-sticky-regex": _pluginTransformStickyRegex.default,
+  "transform-template-literals": _pluginTransformTemplateLiterals.default,
+  "transform-typeof-symbol": _pluginTransformTypeofSymbol.default,
+  "transform-unicode-escapes": _pluginTransformUnicodeEscapes.default,
+  "transform-unicode-regex": _pluginTransformUnicodeRegex.default
+};
+exports.default = _default;

node_modules/@babel/preset-env/lib/debug.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.logUsagePolyfills = exports.logEntryPolyfills = exports.logPluginOrPolyfill = void 0;
+
+var _helperCompilationTargets = require("@babel/helper-compilation-targets");
+
+const wordEnds = size => {
+  return size > 1 ? "s" : "";
+};
+
+const logPluginOrPolyfill = (item, targetVersions, list) => {
+  const filteredList = (0, _helperCompilationTargets.getInclusionReasons)(item, targetVersions, list);
+  const formattedTargets = JSON.stringify(filteredList).replace(/,/g, ", ").replace(/^\{"/, '{ "').replace(/"\}$/, '" }');
+  console.log(`  ${item} ${formattedTargets}`);
+};
+
+exports.logPluginOrPolyfill = logPluginOrPolyfill;
+
+const logEntryPolyfills = (polyfillName, importPolyfillIncluded, polyfills, filename, polyfillTargets, allBuiltInsList) => {
+  if (!importPolyfillIncluded) {
+    console.log(`\n[${filename}] Import of ${polyfillName} was not found.`);
+    return;
+  }
+
+  if (!polyfills.size) {
+    console.log(`\n[${filename}] Based on your targets, polyfills were not added.`);
+    return;
+  }
+
+  console.log(`\n[${filename}] Replaced ${polyfillName} entries with the following polyfill${wordEnds(polyfills.size)}:`);
+
+  for (const polyfill of polyfills) {
+    logPluginOrPolyfill(polyfill, polyfillTargets, allBuiltInsList);
+  }
+};
+
+exports.logEntryPolyfills = logEntryPolyfills;
+
+const logUsagePolyfills = (polyfills, filename, polyfillTargets, allBuiltInsList) => {
+  if (process.env.BABEL_ENV === "test") {
+    filename = filename.replace(/\\/g, "/");
+  }
+
+  if (!polyfills.size) {
+    console.log(`\n[${filename}] Based on your code and targets, core-js polyfills were not added.`);
+    return;
+  }
+
+  console.log(`\n[${filename}] Added following core-js polyfill${wordEnds(polyfills.size)}:`);
+
+  for (const polyfill of polyfills) {
+    logPluginOrPolyfill(polyfill, polyfillTargets, allBuiltInsList);
+  }
+};
+
+exports.logUsagePolyfills = logUsagePolyfills;

node_modules/@babel/preset-env/lib/filter-items.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.removeUnnecessaryItems = removeUnnecessaryItems;
+
+function removeUnnecessaryItems(items, overlapping) {
+  items.forEach(item => {
+    var _overlapping$item;
+
+    (_overlapping$item = overlapping[item]) == null ? void 0 : _overlapping$item.forEach(name => items.delete(name));
+  });
+}

node_modules/@babel/preset-env/lib/get-option-specific-excludes.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+const defaultExcludesForLooseMode = ["transform-typeof-symbol"];
+
+function _default({
+  loose
+}) {
+  return loose ? defaultExcludesForLooseMode : null;
+}

node_modules/@babel/preset-env/lib/index.js

@@ -0,0 +1,363 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isPluginRequired = isPluginRequired;
+exports.default = exports.getPolyfillPlugins = exports.getModulesPluginNames = exports.transformIncludesAndExcludes = void 0;
+
+var _semver = require("semver");
+
+var _debug = require("./debug");
+
+var _getOptionSpecificExcludes = _interopRequireDefault(require("./get-option-specific-excludes"));
+
+var _filterItems = require("./filter-items");
+
+var _moduleTransformations = _interopRequireDefault(require("./module-transformations"));
+
+var _normalizeOptions = _interopRequireDefault(require("./normalize-options"));
+
+var _shippedProposals = require("../data/shipped-proposals");
+
+var _pluginsCompatData = require("./plugins-compat-data");
+
+var _overlappingPlugins = _interopRequireDefault(require("@babel/compat-data/overlapping-plugins"));
+
+var _regenerator = _interopRequireDefault(require("./polyfills/regenerator"));
+
+var _babelPolyfill = _interopRequireDefault(require("./polyfills/babel-polyfill"));
+
+var _helperCompilationTargets = _interopRequireWildcard(require("@babel/helper-compilation-targets"));
+
+var _availablePlugins = _interopRequireDefault(require("./available-plugins"));
+
+var _helperPluginUtils = require("@babel/helper-plugin-utils");
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const _pluginCoreJS2 = require("babel-plugin-polyfill-corejs2");
+
+const _pluginCoreJS3 = require("babel-plugin-polyfill-corejs3");
+
+const _pluginRegenerator = require("babel-plugin-polyfill-regenerator");
+
+const pluginCoreJS2 = _pluginCoreJS2.default;
+const pluginCoreJS3 = _pluginCoreJS3.default;
+const pluginRegenerator = _pluginRegenerator.default;
+
+function isPluginRequired(targets, support) {
+  return (0, _helperCompilationTargets.isRequired)("fake-name", targets, {
+    compatData: {
+      "fake-name": support
+    }
+  });
+}
+
+function filterStageFromList(list, stageList) {
+  return Object.keys(list).reduce((result, item) => {
+    if (!stageList.has(item)) {
+      result[item] = list[item];
+    }
+
+    return result;
+  }, {});
+}
+
+const pluginLists = {
+  withProposals: {
+    withoutBugfixes: _pluginsCompatData.plugins,
+    withBugfixes: Object.assign({}, _pluginsCompatData.plugins, _pluginsCompatData.pluginsBugfixes)
+  },
+  withoutProposals: {
+    withoutBugfixes: filterStageFromList(_pluginsCompatData.plugins, _shippedProposals.proposalPlugins),
+    withBugfixes: filterStageFromList(Object.assign({}, _pluginsCompatData.plugins, _pluginsCompatData.pluginsBugfixes), _shippedProposals.proposalPlugins)
+  }
+};
+
+function getPluginList(proposals, bugfixes) {
+  if (proposals) {
+    if (bugfixes) return pluginLists.withProposals.withBugfixes;else return pluginLists.withProposals.withoutBugfixes;
+  } else {
+    if (bugfixes) return pluginLists.withoutProposals.withBugfixes;else return pluginLists.withoutProposals.withoutBugfixes;
+  }
+}
+
+const getPlugin = pluginName => {
+  const plugin = _availablePlugins.default[pluginName];
+
+  if (!plugin) {
+    throw new Error(`Could not find plugin "${pluginName}". Ensure there is an entry in ./available-plugins.js for it.`);
+  }
+
+  return plugin;
+};
+
+const transformIncludesAndExcludes = opts => {
+  return opts.reduce((result, opt) => {
+    const target = opt.match(/^(es|es6|es7|esnext|web)\./) ? "builtIns" : "plugins";
+    result[target].add(opt);
+    return result;
+  }, {
+    all: opts,
+    plugins: new Set(),
+    builtIns: new Set()
+  });
+};
+
+exports.transformIncludesAndExcludes = transformIncludesAndExcludes;
+
+const getModulesPluginNames = ({
+  modules,
+  transformations,
+  shouldTransformESM,
+  shouldTransformDynamicImport,
+  shouldTransformExportNamespaceFrom,
+  shouldParseTopLevelAwait
+}) => {
+  const modulesPluginNames = [];
+
+  if (modules !== false && transformations[modules]) {
+    if (shouldTransformESM) {
+      modulesPluginNames.push(transformations[modules]);
+    }
+
+    if (shouldTransformDynamicImport && shouldTransformESM && modules !== "umd") {
+      modulesPluginNames.push("proposal-dynamic-import");
+    } else {
+      if (shouldTransformDynamicImport) {
+        console.warn("Dynamic import can only be supported when transforming ES modules" + " to AMD, CommonJS or SystemJS. Only the parser plugin will be enabled.");
+      }
+
+      modulesPluginNames.push("syntax-dynamic-import");
+    }
+  } else {
+    modulesPluginNames.push("syntax-dynamic-import");
+  }
+
+  if (shouldTransformExportNamespaceFrom) {
+    modulesPluginNames.push("proposal-export-namespace-from");
+  } else {
+    modulesPluginNames.push("syntax-export-namespace-from");
+  }
+
+  if (shouldParseTopLevelAwait) {
+    modulesPluginNames.push("syntax-top-level-await");
+  }
+
+  return modulesPluginNames;
+};
+
+exports.getModulesPluginNames = getModulesPluginNames;
+
+const getPolyfillPlugins = ({
+  useBuiltIns,
+  corejs,
+  polyfillTargets,
+  include,
+  exclude,
+  proposals,
+  shippedProposals,
+  regenerator,
+  debug
+}) => {
+  const polyfillPlugins = [];
+
+  if (useBuiltIns === "usage" || useBuiltIns === "entry") {
+    const pluginOptions = {
+      method: `${useBuiltIns}-global`,
+      version: corejs ? corejs.toString() : undefined,
+      targets: polyfillTargets,
+      include,
+      exclude,
+      proposals,
+      shippedProposals,
+      debug
+    };
+
+    if (corejs) {
+      if (useBuiltIns === "usage") {
+        if (corejs.major === 2) {
+          polyfillPlugins.push([pluginCoreJS2, pluginOptions], [_babelPolyfill.default, {
+            usage: true
+          }]);
+        } else {
+          polyfillPlugins.push([pluginCoreJS3, pluginOptions], [_babelPolyfill.default, {
+            usage: true,
+            deprecated: true
+          }]);
+        }
+
+        if (regenerator) {
+          polyfillPlugins.push([pluginRegenerator, {
+            method: "usage-global",
+            debug
+          }]);
+        }
+      } else {
+        if (corejs.major === 2) {
+          polyfillPlugins.push([_babelPolyfill.default, {
+            regenerator
+          }], [pluginCoreJS2, pluginOptions]);
+        } else {
+          polyfillPlugins.push([pluginCoreJS3, pluginOptions], [_babelPolyfill.default, {
+            deprecated: true
+          }]);
+
+          if (!regenerator) {
+            polyfillPlugins.push([_regenerator.default, pluginOptions]);
+          }
+        }
+      }
+    }
+  }
+
+  return polyfillPlugins;
+};
+
+exports.getPolyfillPlugins = getPolyfillPlugins;
+
+function getLocalTargets(optionsTargets, ignoreBrowserslistConfig, configPath, browserslistEnv) {
+  if (optionsTargets != null && optionsTargets.esmodules && optionsTargets.browsers) {
+    console.warn(`
+@babel/preset-env: esmodules and browsers targets have been specified together.
+\`browsers\` target, \`${optionsTargets.browsers.toString()}\` will be ignored.
+`);
+  }
+
+  return (0, _helperCompilationTargets.default)(optionsTargets, {
+    ignoreBrowserslistConfig,
+    configPath,
+    browserslistEnv
+  });
+}
+
+function supportsStaticESM(caller) {
+  return !!(caller != null && caller.supportsStaticESM);
+}
+
+function supportsDynamicImport(caller) {
+  return !!(caller != null && caller.supportsDynamicImport);
+}
+
+function supportsExportNamespaceFrom(caller) {
+  return !!(caller != null && caller.supportsExportNamespaceFrom);
+}
+
+function supportsTopLevelAwait(caller) {
+  return !!(caller != null && caller.supportsTopLevelAwait);
+}
+
+var _default = (0, _helperPluginUtils.declare)((api, opts) => {
+  api.assertVersion(7);
+  const babelTargets = api.targets();
+  const {
+    bugfixes,
+    configPath,
+    debug,
+    exclude: optionsExclude,
+    forceAllTransforms,
+    ignoreBrowserslistConfig,
+    include: optionsInclude,
+    loose,
+    modules,
+    shippedProposals,
+    spec,
+    targets: optionsTargets,
+    useBuiltIns,
+    corejs: {
+      version: corejs,
+      proposals
+    },
+    browserslistEnv
+  } = (0, _normalizeOptions.default)(opts);
+  let targets = babelTargets;
+
+  if ((0, _semver.lt)(api.version, "7.13.0") || opts.targets || opts.configPath || opts.browserslistEnv || opts.ignoreBrowserslistConfig) {
+    {
+      var hasUglifyTarget = false;
+
+      if (optionsTargets != null && optionsTargets.uglify) {
+        hasUglifyTarget = true;
+        delete optionsTargets.uglify;
+        console.warn(`
+The uglify target has been deprecated. Set the top level
+option \`forceAllTransforms: true\` instead.
+`);
+      }
+    }
+    targets = getLocalTargets(optionsTargets, ignoreBrowserslistConfig, configPath, browserslistEnv);
+  }
+
+  const transformTargets = forceAllTransforms || hasUglifyTarget ? {} : targets;
+  const include = transformIncludesAndExcludes(optionsInclude);
+  const exclude = transformIncludesAndExcludes(optionsExclude);
+  const compatData = getPluginList(shippedProposals, bugfixes);
+  const shouldSkipExportNamespaceFrom = modules === "auto" && (api.caller == null ? void 0 : api.caller(supportsExportNamespaceFrom)) || modules === false && !(0, _helperCompilationTargets.isRequired)("proposal-export-namespace-from", transformTargets, {
+    compatData,
+    includes: include.plugins,
+    excludes: exclude.plugins
+  });
+  const modulesPluginNames = getModulesPluginNames({
+    modules,
+    transformations: _moduleTransformations.default,
+    shouldTransformESM: modules !== "auto" || !(api.caller != null && api.caller(supportsStaticESM)),
+    shouldTransformDynamicImport: modules !== "auto" || !(api.caller != null && api.caller(supportsDynamicImport)),
+    shouldTransformExportNamespaceFrom: !shouldSkipExportNamespaceFrom,
+    shouldParseTopLevelAwait: !api.caller || api.caller(supportsTopLevelAwait)
+  });
+  const pluginNames = (0, _helperCompilationTargets.filterItems)(compatData, include.plugins, exclude.plugins, transformTargets, modulesPluginNames, (0, _getOptionSpecificExcludes.default)({
+    loose
+  }), _shippedProposals.pluginSyntaxMap);
+  (0, _filterItems.removeUnnecessaryItems)(pluginNames, _overlappingPlugins.default);
+  const polyfillPlugins = getPolyfillPlugins({
+    useBuiltIns,
+    corejs,
+    polyfillTargets: targets,
+    include: include.builtIns,
+    exclude: exclude.builtIns,
+    proposals,
+    shippedProposals,
+    regenerator: pluginNames.has("transform-regenerator"),
+    debug
+  });
+  const pluginUseBuiltIns = useBuiltIns !== false;
+  const plugins = Array.from(pluginNames).map(pluginName => {
+    if (pluginName === "proposal-class-properties" || pluginName === "proposal-private-methods" || pluginName === "proposal-private-property-in-object") {
+      return [getPlugin(pluginName), {
+        loose: loose ? "#__internal__@babel/preset-env__prefer-true-but-false-is-ok-if-it-prevents-an-error" : "#__internal__@babel/preset-env__prefer-false-but-true-is-ok-if-it-prevents-an-error"
+      }];
+    }
+
+    return [getPlugin(pluginName), {
+      spec,
+      loose,
+      useBuiltIns: pluginUseBuiltIns
+    }];
+  }).concat(polyfillPlugins);
+
+  if (debug) {
+    console.log("@babel/preset-env: `DEBUG` option");
+    console.log("\nUsing targets:");
+    console.log(JSON.stringify((0, _helperCompilationTargets.prettifyTargets)(targets), null, 2));
+    console.log(`\nUsing modules transform: ${modules.toString()}`);
+    console.log("\nUsing plugins:");
+    pluginNames.forEach(pluginName => {
+      (0, _debug.logPluginOrPolyfill)(pluginName, targets, _pluginsCompatData.plugins);
+    });
+
+    if (!useBuiltIns) {
+      console.log("\nUsing polyfills: No polyfills were added, since the `useBuiltIns` option was not set.");
+    }
+  }
+
+  return {
+    plugins
+  };
+});
+
+exports.default = _default;

node_modules/@babel/preset-env/lib/module-transformations.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = {
+  auto: "transform-modules-commonjs",
+  amd: "transform-modules-amd",
+  commonjs: "transform-modules-commonjs",
+  cjs: "transform-modules-commonjs",
+  systemjs: "transform-modules-systemjs",
+  umd: "transform-modules-umd"
+};
+exports.default = _default;

node_modules/@babel/preset-env/lib/normalize-options.js

@@ -0,0 +1,149 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.normalizeCoreJSOption = normalizeCoreJSOption;
+exports.default = normalizeOptions;
+exports.validateUseBuiltInsOption = exports.validateModulesOption = exports.checkDuplicateIncludeExcludes = exports.normalizePluginName = void 0;
+
+var _semver = require("semver");
+
+var _corejs2BuiltIns = _interopRequireDefault(require("@babel/compat-data/corejs2-built-ins"));
+
+var _pluginsCompatData = require("./plugins-compat-data");
+
+var _moduleTransformations = _interopRequireDefault(require("./module-transformations"));
+
+var _options = require("./options");
+
+var _helperValidatorOption = require("@babel/helper-validator-option");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const corejs3Polyfills = require("core-js-compat/data.json");
+
+const corejs2DefaultWebIncludes = ["web.timers", "web.immediate", "web.dom.iterable"];
+const v = new _helperValidatorOption.OptionValidator("@babel/preset-env");
+const allPluginsList = Object.keys(_pluginsCompatData.plugins);
+const modulePlugins = ["proposal-dynamic-import", ...Object.keys(_moduleTransformations.default).map(m => _moduleTransformations.default[m])];
+
+const getValidIncludesAndExcludes = (type, corejs) => new Set([...allPluginsList, ...(type === "exclude" ? modulePlugins : []), ...(corejs ? corejs == 2 ? [...Object.keys(_corejs2BuiltIns.default), ...corejs2DefaultWebIncludes] : Object.keys(corejs3Polyfills) : [])]);
+
+const pluginToRegExp = plugin => {
+  if (plugin instanceof RegExp) return plugin;
+
+  try {
+    return new RegExp(`^${normalizePluginName(plugin)}$`);
+  } catch (e) {
+    return null;
+  }
+};
+
+const selectPlugins = (regexp, type, corejs) => Array.from(getValidIncludesAndExcludes(type, corejs)).filter(item => regexp instanceof RegExp && regexp.test(item));
+
+const flatten = array => [].concat(...array);
+
+const expandIncludesAndExcludes = (plugins = [], type, corejs) => {
+  if (plugins.length === 0) return [];
+  const selectedPlugins = plugins.map(plugin => selectPlugins(pluginToRegExp(plugin), type, corejs));
+  const invalidRegExpList = plugins.filter((p, i) => selectedPlugins[i].length === 0);
+  v.invariant(invalidRegExpList.length === 0, `The plugins/built-ins '${invalidRegExpList.join(", ")}' passed to the '${type}' option are not
+    valid. Please check data/[plugin-features|built-in-features].js in babel-preset-env`);
+  return flatten(selectedPlugins);
+};
+
+const normalizePluginName = plugin => plugin.replace(/^(@babel\/|babel-)(plugin-)?/, "");
+
+exports.normalizePluginName = normalizePluginName;
+
+const checkDuplicateIncludeExcludes = (include = [], exclude = []) => {
+  const duplicates = include.filter(opt => exclude.indexOf(opt) >= 0);
+  v.invariant(duplicates.length === 0, `The plugins/built-ins '${duplicates.join(", ")}' were found in both the "include" and
+    "exclude" options.`);
+};
+
+exports.checkDuplicateIncludeExcludes = checkDuplicateIncludeExcludes;
+
+const normalizeTargets = targets => {
+  if (typeof targets === "string" || Array.isArray(targets)) {
+    return {
+      browsers: targets
+    };
+  }
+
+  return Object.assign({}, targets);
+};
+
+const validateModulesOption = (modulesOpt = _options.ModulesOption.auto) => {
+  v.invariant(_options.ModulesOption[modulesOpt.toString()] || modulesOpt === _options.ModulesOption.false, `The 'modules' option must be one of \n` + ` - 'false' to indicate no module processing\n` + ` - a specific module type: 'commonjs', 'amd', 'umd', 'systemjs'` + ` - 'auto' (default) which will automatically select 'false' if the current\n` + `   process is known to support ES module syntax, or "commonjs" otherwise\n`);
+  return modulesOpt;
+};
+
+exports.validateModulesOption = validateModulesOption;
+
+const validateUseBuiltInsOption = (builtInsOpt = false) => {
+  v.invariant(_options.UseBuiltInsOption[builtInsOpt.toString()] || builtInsOpt === _options.UseBuiltInsOption.false, `The 'useBuiltIns' option must be either
+    'false' (default) to indicate no polyfill,
+    '"entry"' to indicate replacing the entry polyfill, or
+    '"usage"' to import only used polyfills per file`);
+  return builtInsOpt;
+};
+
+exports.validateUseBuiltInsOption = validateUseBuiltInsOption;
+
+function normalizeCoreJSOption(corejs, useBuiltIns) {
+  let proposals = false;
+  let rawVersion;
+
+  if (useBuiltIns && corejs === undefined) {
+    rawVersion = 2;
+    console.warn("\nWARNING (@babel/preset-env): We noticed you're using the `useBuiltIns` option without declaring a " + "core-js version. Currently, we assume version 2.x when no version " + "is passed. Since this default version will likely change in future " + "versions of Babel, we recommend explicitly setting the core-js version " + "you are using via the `corejs` option.\n" + "\nYou should also be sure that the version you pass to the `corejs` " + "option matches the version specified in your `package.json`'s " + "`dependencies` section. If it doesn't, you need to run one of the " + "following commands:\n\n" + "  npm install --save core-js@2    npm install --save core-js@3\n" + "  yarn add core-js@2              yarn add core-js@3\n\n" + "More info about useBuiltIns: https://babeljs.io/docs/en/babel-preset-env#usebuiltins\n" + "More info about core-js: https://babeljs.io/docs/en/babel-preset-env#corejs");
+  } else if (typeof corejs === "object" && corejs !== null) {
+    rawVersion = corejs.version;
+    proposals = Boolean(corejs.proposals);
+  } else {
+    rawVersion = corejs;
+  }
+
+  const version = rawVersion ? (0, _semver.coerce)(String(rawVersion)) : false;
+
+  if (!useBuiltIns && version) {
+    console.warn("\nWARNING (@babel/preset-env): The `corejs` option only has an effect when the `useBuiltIns` option is not `false`\n");
+  }
+
+  if (useBuiltIns && (!version || version.major < 2 || version.major > 3)) {
+    throw new RangeError("Invalid Option: The version passed to `corejs` is invalid. Currently, " + "only core-js@2 and core-js@3 are supported.");
+  }
+
+  return {
+    version,
+    proposals
+  };
+}
+
+function normalizeOptions(opts) {
+  v.validateTopLevelOptions(opts, _options.TopLevelOptions);
+  const useBuiltIns = validateUseBuiltInsOption(opts.useBuiltIns);
+  const corejs = normalizeCoreJSOption(opts.corejs, useBuiltIns);
+  const include = expandIncludesAndExcludes(opts.include, _options.TopLevelOptions.include, !!corejs.version && corejs.version.major);
+  const exclude = expandIncludesAndExcludes(opts.exclude, _options.TopLevelOptions.exclude, !!corejs.version && corejs.version.major);
+  checkDuplicateIncludeExcludes(include, exclude);
+  return {
+    bugfixes: v.validateBooleanOption(_options.TopLevelOptions.bugfixes, opts.bugfixes, false),
+    configPath: v.validateStringOption(_options.TopLevelOptions.configPath, opts.configPath, process.cwd()),
+    corejs,
+    debug: v.validateBooleanOption(_options.TopLevelOptions.debug, opts.debug, false),
+    include,
+    exclude,
+    forceAllTransforms: v.validateBooleanOption(_options.TopLevelOptions.forceAllTransforms, opts.forceAllTransforms, false),
+    ignoreBrowserslistConfig: v.validateBooleanOption(_options.TopLevelOptions.ignoreBrowserslistConfig, opts.ignoreBrowserslistConfig, false),
+    loose: v.validateBooleanOption(_options.TopLevelOptions.loose, opts.loose),
+    modules: validateModulesOption(opts.modules),
+    shippedProposals: v.validateBooleanOption(_options.TopLevelOptions.shippedProposals, opts.shippedProposals, false),
+    spec: v.validateBooleanOption(_options.TopLevelOptions.spec, opts.spec, false),
+    targets: normalizeTargets(opts.targets),
+    useBuiltIns: useBuiltIns,
+    browserslistEnv: v.validateStringOption(_options.TopLevelOptions.browserslistEnv, opts.browserslistEnv)
+  };
+}

node_modules/@babel/preset-env/lib/options.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UseBuiltInsOption = exports.ModulesOption = exports.TopLevelOptions = void 0;
+const TopLevelOptions = {
+  bugfixes: "bugfixes",
+  configPath: "configPath",
+  corejs: "corejs",
+  debug: "debug",
+  exclude: "exclude",
+  forceAllTransforms: "forceAllTransforms",
+  ignoreBrowserslistConfig: "ignoreBrowserslistConfig",
+  include: "include",
+  loose: "loose",
+  modules: "modules",
+  shippedProposals: "shippedProposals",
+  spec: "spec",
+  targets: "targets",
+  useBuiltIns: "useBuiltIns",
+  browserslistEnv: "browserslistEnv"
+};
+exports.TopLevelOptions = TopLevelOptions;
+const ModulesOption = {
+  false: false,
+  auto: "auto",
+  amd: "amd",
+  commonjs: "commonjs",
+  cjs: "cjs",
+  systemjs: "systemjs",
+  umd: "umd"
+};
+exports.ModulesOption = ModulesOption;
+const UseBuiltInsOption = {
+  false: false,
+  entry: "entry",
+  usage: "usage"
+};
+exports.UseBuiltInsOption = UseBuiltInsOption;

node_modules/@babel/preset-env/lib/plugins-compat-data.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pluginsBugfixes = exports.plugins = void 0;
+
+var _plugins = _interopRequireDefault(require("@babel/compat-data/plugins"));
+
+var _pluginBugfixes = _interopRequireDefault(require("@babel/compat-data/plugin-bugfixes"));
+
+var _availablePlugins = _interopRequireDefault(require("./available-plugins"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const pluginsFiltered = {};
+exports.plugins = pluginsFiltered;
+const bugfixPluginsFiltered = {};
+exports.pluginsBugfixes = bugfixPluginsFiltered;
+
+for (const plugin of Object.keys(_plugins.default)) {
+  if (Object.hasOwnProperty.call(_availablePlugins.default, plugin)) {
+    pluginsFiltered[plugin] = _plugins.default[plugin];
+  }
+}
+
+for (const plugin of Object.keys(_pluginBugfixes.default)) {
+  if (Object.hasOwnProperty.call(_availablePlugins.default, plugin)) {
+    bugfixPluginsFiltered[plugin] = _pluginBugfixes.default[plugin];
+  }
+}
+
+pluginsFiltered["proposal-class-properties"] = pluginsFiltered["proposal-private-methods"];

node_modules/@babel/preset-env/lib/polyfills/babel-polyfill.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+var _utils = require("./utils");
+
+const BABEL_POLYFILL_DEPRECATION = `
+  \`@babel/polyfill\` is deprecated. Please, use required parts of \`core-js\`
+  and \`regenerator-runtime/runtime\` separately`;
+const NO_DIRECT_POLYFILL_IMPORT = `
+  When setting \`useBuiltIns: 'usage'\`, polyfills are automatically imported when needed.
+  Please remove the direct import of \`SPECIFIER\` or use \`useBuiltIns: 'entry'\` instead.`;
+
+function _default({
+  template
+}, {
+  regenerator,
+  deprecated,
+  usage
+}) {
+  return {
+    name: "preset-env/replace-babel-polyfill",
+    visitor: {
+      ImportDeclaration(path) {
+        const src = (0, _utils.getImportSource)(path);
+
+        if (usage && (0, _utils.isPolyfillSource)(src)) {
+          console.warn(NO_DIRECT_POLYFILL_IMPORT.replace("SPECIFIER", src));
+          if (!deprecated) path.remove();
+        } else if (src === "@babel/polyfill") {
+          if (deprecated) {
+            console.warn(BABEL_POLYFILL_DEPRECATION);
+          } else if (regenerator) {
+            path.replaceWithMultiple(template.ast`
+              import "core-js";
+              import "regenerator-runtime/runtime.js";
+            `);
+          } else {
+            path.replaceWith(template.ast`
+              import "core-js";
+            `);
+          }
+        }
+      },
+
+      Program(path) {
+        path.get("body").forEach(bodyPath => {
+          const src = (0, _utils.getRequireSource)(bodyPath);
+
+          if (usage && (0, _utils.isPolyfillSource)(src)) {
+            console.warn(NO_DIRECT_POLYFILL_IMPORT.replace("SPECIFIER", src));
+            if (!deprecated) bodyPath.remove();
+          } else if (src === "@babel/polyfill") {
+            if (deprecated) {
+              console.warn(BABEL_POLYFILL_DEPRECATION);
+            } else if (regenerator) {
+              bodyPath.replaceWithMultiple(template.ast`
+                require("core-js");
+                require("regenerator-runtime/runtime.js");
+              `);
+            } else {
+              bodyPath.replaceWith(template.ast`
+                require("core-js");
+              `);
+            }
+          }
+        });
+      }
+
+    }
+  };
+}

node_modules/@babel/preset-env/lib/polyfills/regenerator.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+var _utils = require("./utils");
+
+function isRegeneratorSource(source) {
+  return source === "regenerator-runtime/runtime" || source === "regenerator-runtime/runtime.js";
+}
+
+function _default() {
+  const visitor = {
+    ImportDeclaration(path) {
+      if (isRegeneratorSource((0, _utils.getImportSource)(path))) {
+        this.regeneratorImportExcluded = true;
+        path.remove();
+      }
+    },
+
+    Program(path) {
+      path.get("body").forEach(bodyPath => {
+        if (isRegeneratorSource((0, _utils.getRequireSource)(bodyPath))) {
+          this.regeneratorImportExcluded = true;
+          bodyPath.remove();
+        }
+      });
+    }
+
+  };
+  return {
+    name: "preset-env/remove-regenerator",
+    visitor,
+
+    pre() {
+      this.regeneratorImportExcluded = false;
+    },
+
+    post() {
+      if (this.opts.debug && this.regeneratorImportExcluded) {
+        let filename = this.file.opts.filename;
+
+        if (process.env.BABEL_ENV === "test") {
+          filename = filename.replace(/\\/g, "/");
+        }
+
+        console.log(`\n[${filename}] Based on your targets, regenerator-runtime import excluded.`);
+      }
+    }
+
+  };
+}

node_modules/@babel/preset-env/lib/polyfills/utils.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getImportSource = getImportSource;
+exports.getRequireSource = getRequireSource;
+exports.isPolyfillSource = isPolyfillSource;
+
+var t = _interopRequireWildcard(require("@babel/types"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function getImportSource({
+  node
+}) {
+  if (node.specifiers.length === 0) return node.source.value;
+}
+
+function getRequireSource({
+  node
+}) {
+  if (!t.isExpressionStatement(node)) return;
+  const {
+    expression
+  } = node;
+  const isRequire = t.isCallExpression(expression) && t.isIdentifier(expression.callee) && expression.callee.name === "require" && expression.arguments.length === 1 && t.isStringLiteral(expression.arguments[0]);
+  if (isRequire) return expression.arguments[0].value;
+}
+
+function isPolyfillSource(source) {
+  return source === "@babel/polyfill" || source === "core-js";
+}

node_modules/@babel/preset-env/lib/targets-parser.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _helperCompilationTargets.default;
+  }
+});
+Object.defineProperty(exports, "isBrowsersQueryValid", {
+  enumerable: true,
+  get: function () {
+    return _helperCompilationTargets.isBrowsersQueryValid;
+  }
+});
+Object.defineProperty(exports, "semverMin", {
+  enumerable: true,
+  get: function () {
+    return _helperCompilationTargets.semverMin;
+  }
+});
+
+var _helperCompilationTargets = _interopRequireWildcard(require("@babel/helper-compilation-targets"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }