ui

app/code/node_modules/@babel/preset-env/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

app/code/node_modules/@babel/preset-env/README.md

@@ -0,0 +1,19 @@
+# @babel/preset-env
+
+> A Babel preset for each environment.
+
+See our website [@babel/preset-env](https://babeljs.io/docs/en/babel-preset-env) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20preset-env%22+is%3Aopen) associated with this package.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/preset-env
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/preset-env --dev
+```

app/code/node_modules/@babel/preset-env/data/built-in-modules.js

@@ -0,0 +1,3 @@
+// TODO: Remove in Babel 8
+
+module.exports = require("@babel/compat-data/native-modules");

app/code/node_modules/@babel/preset-env/data/built-in-modules.json.js

@@ -0,0 +1,3 @@
+// TODO: Remove in Babel 8
+
+module.exports = require("@babel/compat-data/native-modules");

app/code/node_modules/@babel/preset-env/data/built-ins.js

@@ -0,0 +1,4 @@
+// TODO: Remove in Babel 8
+// https://github.com/vuejs/vue-cli/issues/3671
+
+module.exports = require("./corejs2-built-ins.json");

app/code/node_modules/@babel/preset-env/data/built-ins.json.js

@@ -0,0 +1,4 @@
+// TODO: Remove in Babel 8
+// https://github.com/vuejs/vue-cli/issues/3671
+
+module.exports = require("./corejs2-built-ins.json");

app/code/node_modules/@babel/preset-env/data/corejs2-built-ins.js

@@ -0,0 +1,3 @@
+// TODO: Remove in Babel 8
+
+module.exports = require("@babel/compat-data/corejs2-built-ins");

app/code/node_modules/@babel/preset-env/data/corejs2-built-ins.json.js

@@ -0,0 +1,3 @@
+// TODO: Remove in Babel 8
+
+module.exports = require("@babel/compat-data/corejs2-built-ins");

app/code/node_modules/@babel/preset-env/data/plugins.js

@@ -0,0 +1,3 @@
+// TODO: Remove in Babel 8
+
+module.exports = require("@babel/compat-data/plugins");

app/code/node_modules/@babel/preset-env/data/plugins.json.js

@@ -0,0 +1,3 @@
+// TODO: Remove in Babel 8
+
+module.exports = require("@babel/compat-data/plugins");

app/code/node_modules/@babel/preset-env/data/shipped-proposals.js

@@ -0,0 +1,30 @@
+/* eslint sort-keys: "error" */
+// These mappings represent the syntax proposals that have been
+// shipped by browsers, and are enabled by the `shippedProposals` option.
+
+const proposalPlugins = new Set();
+
+// use intermediary object to enforce alphabetical key order
+const pluginSyntaxObject = {
+  "proposal-async-generator-functions": "syntax-async-generators",
+  "proposal-class-properties": "syntax-class-properties",
+  "proposal-class-static-block": "syntax-class-static-block",
+  "proposal-json-strings": "syntax-json-strings",
+  "proposal-nullish-coalescing-operator": "syntax-nullish-coalescing-operator",
+  "proposal-numeric-separator": "syntax-numeric-separator",
+  "proposal-object-rest-spread": "syntax-object-rest-spread",
+  "proposal-optional-catch-binding": "syntax-optional-catch-binding",
+  "proposal-optional-chaining": "syntax-optional-chaining",
+  // note: we don't have syntax-private-methods
+  "proposal-private-methods": "syntax-class-properties",
+  "proposal-private-property-in-object": "syntax-private-property-in-object",
+  "proposal-unicode-property-regex": null,
+};
+
+const pluginSyntaxEntries = Object.keys(pluginSyntaxObject).map(function (key) {
+  return [key, pluginSyntaxObject[key]];
+});
+
+const pluginSyntaxMap = new Map(pluginSyntaxEntries);
+
+module.exports = { pluginSyntaxMap, proposalPlugins };

app/code/node_modules/@babel/preset-env/data/unreleased-labels.js

@@ -0,0 +1,3 @@
+// TODO: Remove in Babel 8
+
+module.exports = require("@babel/helper-compilation-targets").unreleasedLabels;

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

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

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

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.logPlugin = void 0;
+
+var _helperCompilationTargets = require("@babel/helper-compilation-targets");
+
+const logPlugin = (item, targetVersions, list) => {
+  const filteredList = (0, _helperCompilationTargets.getInclusionReasons)(item, targetVersions, list);
+  const support = list[item];
+
+  if (!support) {
+    console.log(`  ${item}`);
+    return;
+  }
+
+  let formattedTargets = `{`;
+  let first = true;
+
+  for (const target of Object.keys(filteredList)) {
+    if (!first) formattedTargets += `,`;
+    first = false;
+    formattedTargets += ` ${target}`;
+    if (support[target]) formattedTargets += ` < ${support[target]}`;
+  }
+
+  formattedTargets += ` }`;
+  console.log(`  ${item} ${formattedTargets}`);
+};
+
+exports.logPlugin = logPlugin;

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

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.removeUnnecessaryItems = removeUnnecessaryItems;
+exports.removeUnsupportedItems = removeUnsupportedItems;
+
+var _semver = require("semver");
+
+var _availablePlugins = require("./available-plugins");
+
+const has = Function.call.bind(Object.hasOwnProperty);
+
+function removeUnnecessaryItems(items, overlapping) {
+  items.forEach(item => {
+    var _overlapping$item;
+
+    (_overlapping$item = overlapping[item]) == null ? void 0 : _overlapping$item.forEach(name => items.delete(name));
+  });
+}
+
+function removeUnsupportedItems(items, babelVersion) {
+  items.forEach(item => {
+    if (has(_availablePlugins.minVersions, item) && (0, _semver.lt)(babelVersion, _availablePlugins.minVersions[item])) {
+      items.delete(item);
+    }
+  });
+}

app/code/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;
+}

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

@@ -0,0 +1,359 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPolyfillPlugins = exports.getModulesPluginNames = exports.default = void 0;
+exports.isPluginRequired = isPluginRequired;
+exports.transformIncludesAndExcludes = void 0;
+
+var _semver = require("semver");
+
+var _debug = require("./debug");
+
+var _getOptionSpecificExcludes = require("./get-option-specific-excludes");
+
+var _filterItems = require("./filter-items");
+
+var _moduleTransformations = require("./module-transformations");
+
+var _normalizeOptions = require("./normalize-options");
+
+var _shippedProposals = require("../data/shipped-proposals");
+
+var _pluginsCompatData = require("./plugins-compat-data");
+
+var _overlappingPlugins = require("@babel/compat-data/overlapping-plugins");
+
+var _regenerator = require("./polyfills/regenerator");
+
+var _babelPolyfill = require("./polyfills/babel-polyfill");
+
+var _babelPluginPolyfillCorejs = require("babel-plugin-polyfill-corejs2");
+
+var _babelPluginPolyfillCorejs2 = require("babel-plugin-polyfill-corejs3");
+
+var _babelPluginPolyfillRegenerator = require("babel-plugin-polyfill-regenerator");
+
+var _helperCompilationTargets = require("@babel/helper-compilation-targets");
+
+var _availablePlugins = require("./available-plugins");
+
+var _helperPluginUtils = require("@babel/helper-plugin-utils");
+
+const pluginCoreJS2 = _babelPluginPolyfillCorejs.default || _babelPluginPolyfillCorejs;
+const pluginCoreJS3 = _babelPluginPolyfillCorejs2.default || _babelPluginPolyfillCorejs2;
+const pluginRegenerator = _babelPluginPolyfillRegenerator.default || _babelPluginPolyfillRegenerator;
+
+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);
+  (0, _filterItems.removeUnsupportedItems)(pluginNames, api.version);
+  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.logPlugin)(pluginName, targets, compatData);
+    });
+
+    if (!useBuiltIns) {
+      console.log("\nUsing polyfills: No polyfills were added, since the `useBuiltIns` option was not set.");
+    }
+  }
+
+  return {
+    plugins
+  };
+});
+
+exports.default = _default;

app/code/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;

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

@@ -0,0 +1,148 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.checkDuplicateIncludeExcludes = void 0;
+exports.default = normalizeOptions;
+exports.normalizeCoreJSOption = normalizeCoreJSOption;
+exports.validateUseBuiltInsOption = exports.validateModulesOption = exports.normalizePluginName = void 0;
+
+var _data = require("core-js-compat/data.json");
+
+var _semver = require("semver");
+
+var _corejs2BuiltIns = require("@babel/compat-data/corejs2-built-ins");
+
+var _pluginsCompatData = require("./plugins-compat-data");
+
+var _moduleTransformations = require("./module-transformations");
+
+var _options = require("./options");
+
+var _helperValidatorOption = require("@babel/helper-validator-option");
+
+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), ...corejs2DefaultWebIncludes] : Object.keys(_data) : [])]);
+
+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)
+  };
+}

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

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UseBuiltInsOption = exports.TopLevelOptions = exports.ModulesOption = 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;

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

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pluginsBugfixes = exports.plugins = void 0;
+
+var _plugins = require("@babel/compat-data/plugins");
+
+var _pluginBugfixes = require("@babel/compat-data/plugin-bugfixes");
+
+var _availablePlugins = require("./available-plugins");
+
+const pluginsFiltered = {};
+exports.plugins = pluginsFiltered;
+const bugfixPluginsFiltered = {};
+exports.pluginsBugfixes = bugfixPluginsFiltered;
+
+for (const plugin of Object.keys(_plugins)) {
+  if (Object.hasOwnProperty.call(_availablePlugins.default, plugin)) {
+    pluginsFiltered[plugin] = _plugins[plugin];
+  }
+}
+
+for (const plugin of Object.keys(_pluginBugfixes)) {
+  if (Object.hasOwnProperty.call(_availablePlugins.default, plugin)) {
+    bugfixPluginsFiltered[plugin] = _pluginBugfixes[plugin];
+  }
+}

app/code/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");
+              `);
+            }
+          }
+        });
+      }
+
+    }
+  };
+}

app/code/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.`);
+      }
+    }
+
+  };
+}

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

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getImportSource = getImportSource;
+exports.getRequireSource = getRequireSource;
+exports.isPolyfillSource = isPolyfillSource;
+
+var _t = require("@babel/types");
+
+const {
+  isCallExpression,
+  isExpressionStatement,
+  isIdentifier,
+  isStringLiteral
+} = _t;
+
+function getImportSource({
+  node
+}) {
+  if (node.specifiers.length === 0) return node.source.value;
+}
+
+function getRequireSource({
+  node
+}) {
+  if (!isExpressionStatement(node)) return;
+  const {
+    expression
+  } = node;
+
+  if (isCallExpression(expression) && isIdentifier(expression.callee) && expression.callee.name === "require" && expression.arguments.length === 1 && isStringLiteral(expression.arguments[0])) {
+    return expression.arguments[0].value;
+  }
+}
+
+function isPolyfillSource(source) {
+  return source === "@babel/polyfill" || source === "core-js";
+}

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

@@ -0,0 +1,19 @@
+"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;
+  }
+});
+
+var _helperCompilationTargets = require("@babel/helper-compilation-targets");

app/code/node_modules/@babel/preset-env/node_modules/.bin/semver

@@ -0,0 +1 @@
+../semver/bin/semver.js

app/code/node_modules/@babel/preset-env/node_modules/semver/CHANGELOG.md

@@ -0,0 +1,70 @@
+# changes log
+
+## 6.2.0
+
+* Coerce numbers to strings when passed to semver.coerce()
+* Add `rtl` option to coerce from right to left
+
+## 6.1.3
+
+* Handle X-ranges properly in includePrerelease mode
+
+## 6.1.2
+
+* Do not throw when testing invalid version strings
+
+## 6.1.1
+
+* Add options support for semver.coerce()
+* Handle undefined version passed to Range.test
+
+## 6.1.0
+
+* Add semver.compareBuild function
+* Support `*` in semver.intersects
+
+## 6.0
+
+* Fix `intersects` logic.
+
+    This is technically a bug fix, but since it is also a change to behavior
+    that may require users updating their code, it is marked as a major
+    version increment.
+
+## 5.7
+
+* Add `minVersion` method
+
+## 5.6
+
+* Move boolean `loose` param to an options object, with
+  backwards-compatibility protection.
+* Add ability to opt out of special prerelease version handling with
+  the `includePrerelease` option flag.
+
+## 5.5
+
+* Add version coercion capabilities
+
+## 5.4
+
+* Add intersection checking
+
+## 5.3
+
+* Add `minSatisfying` method
+
+## 5.2
+
+* Add `prerelease(v)` that returns prerelease components
+
+## 5.1
+
+* Add Backus-Naur for ranges
+* Remove excessively cute inspection methods
+
+## 5.0
+
+* Remove AMD/Browserified build artifacts
+* Fix ltr and gtr when using the `*` range
+* Fix for range `*` with a prerelease identifier

app/code/node_modules/@babel/preset-env/node_modules/semver/LICENSE

@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

app/code/node_modules/@babel/preset-env/node_modules/semver/README.md

@@ -0,0 +1,443 @@
+semver(1) -- The semantic versioner for npm
+===========================================
+
+## Install
+
+```bash
+npm install semver
+````
+
+## Usage
+
+As a node module:
+
+```js
+const semver = require('semver')
+
+semver.valid('1.2.3') // '1.2.3'
+semver.valid('a.b.c') // null
+semver.clean('  =v1.2.3   ') // '1.2.3'
+semver.satisfies('1.2.3', '1.x || >=2.5.0 || 5.0.0 - 7.2.3') // true
+semver.gt('1.2.3', '9.8.7') // false
+semver.lt('1.2.3', '9.8.7') // true
+semver.minVersion('>=1.0.0') // '1.0.0'
+semver.valid(semver.coerce('v2')) // '2.0.0'
+semver.valid(semver.coerce('42.6.7.9.3-alpha')) // '42.6.7'
+```
+
+As a command-line utility:
+
+```
+$ semver -h
+
+A JavaScript implementation of the https://semver.org/ specification
+Copyright Isaac Z. Schlueter
+
+Usage: semver [options] <version> [<version> [...]]
+Prints valid versions sorted by SemVer precedence
+
+Options:
+-r --range <range>
+        Print versions that match the specified range.
+
+-i --increment [<level>]
+        Increment a version by the specified level.  Level can
+        be one of: major, minor, patch, premajor, preminor,
+        prepatch, or prerelease.  Default level is 'patch'.
+        Only one version may be specified.
+
+--preid <identifier>
+        Identifier to be used to prefix premajor, preminor,
+        prepatch or prerelease version increments.
+
+-l --loose
+        Interpret versions and ranges loosely
+
+-p --include-prerelease
+        Always include prerelease versions in range matching
+
+-c --coerce
+        Coerce a string into SemVer if possible
+        (does not imply --loose)
+
+--rtl
+        Coerce version strings right to left
+
+--ltr
+        Coerce version strings left to right (default)
+
+Program exits successfully if any valid version satisfies
+all supplied ranges, and prints all satisfying versions.
+
+If no satisfying versions are found, then exits failure.
+
+Versions are printed in ascending order, so supplying
+multiple versions to the utility will just sort them.
+```
+
+## Versions
+
+A "version" is described by the `v2.0.0` specification found at
+<https://semver.org/>.
+
+A leading `"="` or `"v"` character is stripped off and ignored.
+
+## Ranges
+
+A `version range` is a set of `comparators` which specify versions
+that satisfy the range.
+
+A `comparator` is composed of an `operator` and a `version`.  The set
+of primitive `operators` is:
+
+* `<` Less than
+* `<=` Less than or equal to
+* `>` Greater than
+* `>=` Greater than or equal to
+* `=` Equal.  If no operator is specified, then equality is assumed,
+  so this operator is optional, but MAY be included.
+
+For example, the comparator `>=1.2.7` would match the versions
+`1.2.7`, `1.2.8`, `2.5.3`, and `1.3.9`, but not the versions `1.2.6`
+or `1.1.0`.
+
+Comparators can be joined by whitespace to form a `comparator set`,
+which is satisfied by the **intersection** of all of the comparators
+it includes.
+
+A range is composed of one or more comparator sets, joined by `||`.  A
+version matches a range if and only if every comparator in at least
+one of the `||`-separated comparator sets is satisfied by the version.
+
+For example, the range `>=1.2.7 <1.3.0` would match the versions
+`1.2.7`, `1.2.8`, and `1.2.99`, but not the versions `1.2.6`, `1.3.0`,
+or `1.1.0`.
+
+The range `1.2.7 || >=1.2.9 <2.0.0` would match the versions `1.2.7`,
+`1.2.9`, and `1.4.6`, but not the versions `1.2.8` or `2.0.0`.
+
+### Prerelease Tags
+
+If a version has a prerelease tag (for example, `1.2.3-alpha.3`) then
+it will only be allowed to satisfy comparator sets if at least one
+comparator with the same `[major, minor, patch]` tuple also has a
+prerelease tag.
+
+For example, the range `>1.2.3-alpha.3` would be allowed to match the
+version `1.2.3-alpha.7`, but it would *not* be satisfied by
+`3.4.5-alpha.9`, even though `3.4.5-alpha.9` is technically "greater
+than" `1.2.3-alpha.3` according to the SemVer sort rules.  The version
+range only accepts prerelease tags on the `1.2.3` version.  The
+version `3.4.5` *would* satisfy the range, because it does not have a
+prerelease flag, and `3.4.5` is greater than `1.2.3-alpha.7`.
+
+The purpose for this behavior is twofold.  First, prerelease versions
+frequently are updated very quickly, and contain many breaking changes
+that are (by the author's design) not yet fit for public consumption.
+Therefore, by default, they are excluded from range matching
+semantics.
+
+Second, a user who has opted into using a prerelease version has
+clearly indicated the intent to use *that specific* set of
+alpha/beta/rc versions.  By including a prerelease tag in the range,
+the user is indicating that they are aware of the risk.  However, it
+is still not appropriate to assume that they have opted into taking a
+similar risk on the *next* set of prerelease versions.
+
+Note that this behavior can be suppressed (treating all prerelease
+versions as if they were normal versions, for the purpose of range
+matching) by setting the `includePrerelease` flag on the options
+object to any
+[functions](https://github.com/npm/node-semver#functions) that do
+range matching.
+
+#### Prerelease Identifiers
+
+The method `.inc` takes an additional `identifier` string argument that
+will append the value of the string as a prerelease identifier:
+
+```javascript
+semver.inc('1.2.3', 'prerelease', 'beta')
+// '1.2.4-beta.0'
+```
+
+command-line example:
+
+```bash
+$ semver 1.2.3 -i prerelease --preid beta
+1.2.4-beta.0
+```
+
+Which then can be used to increment further:
+
+```bash
+$ semver 1.2.4-beta.0 -i prerelease
+1.2.4-beta.1
+```
+
+### Advanced Range Syntax
+
+Advanced range syntax desugars to primitive comparators in
+deterministic ways.
+
+Advanced ranges may be combined in the same way as primitive
+comparators using white space or `||`.
+
+#### Hyphen Ranges `X.Y.Z - A.B.C`
+
+Specifies an inclusive set.
+
+* `1.2.3 - 2.3.4` := `>=1.2.3 <=2.3.4`
+
+If a partial version is provided as the first version in the inclusive
+range, then the missing pieces are replaced with zeroes.
+
+* `1.2 - 2.3.4` := `>=1.2.0 <=2.3.4`
+
+If a partial version is provided as the second version in the
+inclusive range, then all versions that start with the supplied parts
+of the tuple are accepted, but nothing that would be greater than the
+provided tuple parts.
+
+* `1.2.3 - 2.3` := `>=1.2.3 <2.4.0`
+* `1.2.3 - 2` := `>=1.2.3 <3.0.0`
+
+#### X-Ranges `1.2.x` `1.X` `1.2.*` `*`
+
+Any of `X`, `x`, or `*` may be used to "stand in" for one of the
+numeric values in the `[major, minor, patch]` tuple.
+
+* `*` := `>=0.0.0` (Any version satisfies)
+* `1.x` := `>=1.0.0 <2.0.0` (Matching major version)
+* `1.2.x` := `>=1.2.0 <1.3.0` (Matching major and minor versions)
+
+A partial version range is treated as an X-Range, so the special
+character is in fact optional.
+
+* `""` (empty string) := `*` := `>=0.0.0`
+* `1` := `1.x.x` := `>=1.0.0 <2.0.0`
+* `1.2` := `1.2.x` := `>=1.2.0 <1.3.0`
+
+#### Tilde Ranges `~1.2.3` `~1.2` `~1`
+
+Allows patch-level changes if a minor version is specified on the
+comparator.  Allows minor-level changes if not.
+
+* `~1.2.3` := `>=1.2.3 <1.(2+1).0` := `>=1.2.3 <1.3.0`
+* `~1.2` := `>=1.2.0 <1.(2+1).0` := `>=1.2.0 <1.3.0` (Same as `1.2.x`)
+* `~1` := `>=1.0.0 <(1+1).0.0` := `>=1.0.0 <2.0.0` (Same as `1.x`)
+* `~0.2.3` := `>=0.2.3 <0.(2+1).0` := `>=0.2.3 <0.3.0`
+* `~0.2` := `>=0.2.0 <0.(2+1).0` := `>=0.2.0 <0.3.0` (Same as `0.2.x`)
+* `~0` := `>=0.0.0 <(0+1).0.0` := `>=0.0.0 <1.0.0` (Same as `0.x`)
+* `~1.2.3-beta.2` := `>=1.2.3-beta.2 <1.3.0` Note that prereleases in
+  the `1.2.3` version will be allowed, if they are greater than or
+  equal to `beta.2`.  So, `1.2.3-beta.4` would be allowed, but
+  `1.2.4-beta.2` would not, because it is a prerelease of a
+  different `[major, minor, patch]` tuple.
+
+#### Caret Ranges `^1.2.3` `^0.2.5` `^0.0.4`
+
+Allows changes that do not modify the left-most non-zero element in the
+`[major, minor, patch]` tuple.  In other words, this allows patch and
+minor updates for versions `1.0.0` and above, patch updates for
+versions `0.X >=0.1.0`, and *no* updates for versions `0.0.X`.
+
+Many authors treat a `0.x` version as if the `x` were the major
+"breaking-change" indicator.
+
+Caret ranges are ideal when an author may make breaking changes
+between `0.2.4` and `0.3.0` releases, which is a common practice.
+However, it presumes that there will *not* be breaking changes between
+`0.2.4` and `0.2.5`.  It allows for changes that are presumed to be
+additive (but non-breaking), according to commonly observed practices.
+
+* `^1.2.3` := `>=1.2.3 <2.0.0`
+* `^0.2.3` := `>=0.2.3 <0.3.0`
+* `^0.0.3` := `>=0.0.3 <0.0.4`
+* `^1.2.3-beta.2` := `>=1.2.3-beta.2 <2.0.0` Note that prereleases in
+  the `1.2.3` version will be allowed, if they are greater than or
+  equal to `beta.2`.  So, `1.2.3-beta.4` would be allowed, but
+  `1.2.4-beta.2` would not, because it is a prerelease of a
+  different `[major, minor, patch]` tuple.
+* `^0.0.3-beta` := `>=0.0.3-beta <0.0.4`  Note that prereleases in the
+  `0.0.3` version *only* will be allowed, if they are greater than or
+  equal to `beta`.  So, `0.0.3-pr.2` would be allowed.
+
+When parsing caret ranges, a missing `patch` value desugars to the
+number `0`, but will allow flexibility within that value, even if the
+major and minor versions are both `0`.
+
+* `^1.2.x` := `>=1.2.0 <2.0.0`
+* `^0.0.x` := `>=0.0.0 <0.1.0`
+* `^0.0` := `>=0.0.0 <0.1.0`
+
+A missing `minor` and `patch` values will desugar to zero, but also
+allow flexibility within those values, even if the major version is
+zero.
+
+* `^1.x` := `>=1.0.0 <2.0.0`
+* `^0.x` := `>=0.0.0 <1.0.0`
+
+### Range Grammar
+
+Putting all this together, here is a Backus-Naur grammar for ranges,
+for the benefit of parser authors:
+
+```bnf
+range-set  ::= range ( logical-or range ) *
+logical-or ::= ( ' ' ) * '||' ( ' ' ) *
+range      ::= hyphen | simple ( ' ' simple ) * | ''
+hyphen     ::= partial ' - ' partial
+simple     ::= primitive | partial | tilde | caret
+primitive  ::= ( '<' | '>' | '>=' | '<=' | '=' ) partial
+partial    ::= xr ( '.' xr ( '.' xr qualifier ? )? )?
+xr         ::= 'x' | 'X' | '*' | nr
+nr         ::= '0' | ['1'-'9'] ( ['0'-'9'] ) *
+tilde      ::= '~' partial
+caret      ::= '^' partial
+qualifier  ::= ( '-' pre )? ( '+' build )?
+pre        ::= parts
+build      ::= parts
+parts      ::= part ( '.' part ) *
+part       ::= nr | [-0-9A-Za-z]+
+```
+
+## Functions
+
+All methods and classes take a final `options` object argument.  All
+options in this object are `false` by default.  The options supported
+are:
+
+- `loose`  Be more forgiving about not-quite-valid semver strings.
+  (Any resulting output will always be 100% strict compliant, of
+  course.)  For backwards compatibility reasons, if the `options`
+  argument is a boolean value instead of an object, it is interpreted
+  to be the `loose` param.
+- `includePrerelease`  Set to suppress the [default
+  behavior](https://github.com/npm/node-semver#prerelease-tags) of
+  excluding prerelease tagged versions from ranges unless they are
+  explicitly opted into.
+
+Strict-mode Comparators and Ranges will be strict about the SemVer
+strings that they parse.
+
+* `valid(v)`: Return the parsed version, or null if it's not valid.
+* `inc(v, release)`: Return the version incremented by the release
+  type (`major`,   `premajor`, `minor`, `preminor`, `patch`,
+  `prepatch`, or `prerelease`), or null if it's not valid
+  * `premajor` in one call will bump the version up to the next major
+    version and down to a prerelease of that major version.
+    `preminor`, and `prepatch` work the same way.
+  * If called from a non-prerelease version, the `prerelease` will work the
+    same as `prepatch`. It increments the patch version, then makes a
+    prerelease. If the input version is already a prerelease it simply
+    increments it.
+* `prerelease(v)`: Returns an array of prerelease components, or null
+  if none exist. Example: `prerelease('1.2.3-alpha.1') -> ['alpha', 1]`
+* `major(v)`: Return the major version number.
+* `minor(v)`: Return the minor version number.
+* `patch(v)`: Return the patch version number.
+* `intersects(r1, r2, loose)`: Return true if the two supplied ranges
+  or comparators intersect.
+* `parse(v)`: Attempt to parse a string as a semantic version, returning either
+  a `SemVer` object or `null`.
+
+### Comparison
+
+* `gt(v1, v2)`: `v1 > v2`
+* `gte(v1, v2)`: `v1 >= v2`
+* `lt(v1, v2)`: `v1 < v2`
+* `lte(v1, v2)`: `v1 <= v2`
+* `eq(v1, v2)`: `v1 == v2` This is true if they're logically equivalent,
+  even if they're not the exact same string.  You already know how to
+  compare strings.
+* `neq(v1, v2)`: `v1 != v2` The opposite of `eq`.
+* `cmp(v1, comparator, v2)`: Pass in a comparison string, and it'll call
+  the corresponding function above.  `"==="` and `"!=="` do simple
+  string comparison, but are included for completeness.  Throws if an
+  invalid comparison string is provided.
+* `compare(v1, v2)`: Return `0` if `v1 == v2`, or `1` if `v1` is greater, or `-1` if
+  `v2` is greater.  Sorts in ascending order if passed to `Array.sort()`.
+* `rcompare(v1, v2)`: The reverse of compare.  Sorts an array of versions
+  in descending order when passed to `Array.sort()`.
+* `compareBuild(v1, v2)`: The same as `compare` but considers `build` when two versions
+  are equal.  Sorts in ascending order if passed to `Array.sort()`.
+  `v2` is greater.  Sorts in ascending order if passed to `Array.sort()`.
+* `diff(v1, v2)`: Returns difference between two versions by the release type
+  (`major`, `premajor`, `minor`, `preminor`, `patch`, `prepatch`, or `prerelease`),
+  or null if the versions are the same.
+
+### Comparators
+
+* `intersects(comparator)`: Return true if the comparators intersect
+
+### Ranges
+
+* `validRange(range)`: Return the valid range or null if it's not valid
+* `satisfies(version, range)`: Return true if the version satisfies the
+  range.
+* `maxSatisfying(versions, range)`: Return the highest version in the list
+  that satisfies the range, or `null` if none of them do.
+* `minSatisfying(versions, range)`: Return the lowest version in the list
+  that satisfies the range, or `null` if none of them do.
+* `minVersion(range)`: Return the lowest version that can possibly match
+  the given range.
+* `gtr(version, range)`: Return `true` if version is greater than all the
+  versions possible in the range.
+* `ltr(version, range)`: Return `true` if version is less than all the
+  versions possible in the range.
+* `outside(version, range, hilo)`: Return true if the version is outside
+  the bounds of the range in either the high or low direction.  The
+  `hilo` argument must be either the string `'>'` or `'<'`.  (This is
+  the function called by `gtr` and `ltr`.)
+* `intersects(range)`: Return true if any of the ranges comparators intersect
+
+Note that, since ranges may be non-contiguous, a version might not be
+greater than a range, less than a range, *or* satisfy a range!  For
+example, the range `1.2 <1.2.9 || >2.0.0` would have a hole from `1.2.9`
+until `2.0.0`, so the version `1.2.10` would not be greater than the
+range (because `2.0.1` satisfies, which is higher), nor less than the
+range (since `1.2.8` satisfies, which is lower), and it also does not
+satisfy the range.
+
+If you want to know if a version satisfies or does not satisfy a
+range, use the `satisfies(version, range)` function.
+
+### Coercion
+
+* `coerce(version, options)`: Coerces a string to semver if possible
+
+This aims to provide a very forgiving translation of a non-semver string to
+semver. It looks for the first digit in a string, and consumes all
+remaining characters which satisfy at least a partial semver (e.g., `1`,
+`1.2`, `1.2.3`) up to the max permitted length (256 characters).  Longer
+versions are simply truncated (`4.6.3.9.2-alpha2` becomes `4.6.3`).  All
+surrounding text is simply ignored (`v3.4 replaces v3.3.1` becomes
+`3.4.0`).  Only text which lacks digits will fail coercion (`version one`
+is not valid).  The maximum  length for any semver component considered for
+coercion is 16 characters; longer components will be ignored
+(`10000000000000000.4.7.4` becomes `4.7.4`).  The maximum value for any
+semver component is `Integer.MAX_SAFE_INTEGER || (2**53 - 1)`; higher value
+components are invalid (`9999999999999999.4.7.4` is likely invalid).
+
+If the `options.rtl` flag is set, then `coerce` will return the right-most
+coercible tuple that does not share an ending index with a longer coercible
+tuple.  For example, `1.2.3.4` will return `2.3.4` in rtl mode, not
+`4.0.0`.  `1.2.3/4` will return `4.0.0`, because the `4` is not a part of
+any other overlapping SemVer tuple.
+
+### Clean
+
+* `clean(version)`: Clean a string to be a valid semver if possible
+
+This will return a cleaned and trimmed semver version. If the provided version is not valid a null will be returned. This does not work for ranges. 
+
+ex.
+* `s.clean(' = v 2.1.5foo')`: `null`
+* `s.clean(' = v 2.1.5foo', { loose: true })`: `'2.1.5-foo'`
+* `s.clean(' = v 2.1.5-foo')`: `null`
+* `s.clean(' = v 2.1.5-foo', { loose: true })`: `'2.1.5-foo'`
+* `s.clean('=v2.1.5')`: `'2.1.5'`
+* `s.clean('  =v2.1.5')`: `2.1.5`
+* `s.clean('      2.1.5   ')`: `'2.1.5'`
+* `s.clean('~1.0.0')`: `null`

app/code/node_modules/@babel/preset-env/node_modules/semver/bin/semver.js

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+// Standalone semver comparison program.
+// Exits successfully and prints matching version(s) if
+// any supplied version is valid and passes all tests.
+
+var argv = process.argv.slice(2)
+
+var versions = []
+
+var range = []
+
+var inc = null
+
+var version = require('../package.json').version
+
+var loose = false
+
+var includePrerelease = false
+
+var coerce = false
+
+var rtl = false
+
+var identifier
+
+var semver = require('../semver')
+
+var reverse = false
+
+var options = {}
+
+main()
+
+function main () {
+  if (!argv.length) return help()
+  while (argv.length) {
+    var a = argv.shift()
+    var indexOfEqualSign = a.indexOf('=')
+    if (indexOfEqualSign !== -1) {
+      a = a.slice(0, indexOfEqualSign)
+      argv.unshift(a.slice(indexOfEqualSign + 1))
+    }
+    switch (a) {
+      case '-rv': case '-rev': case '--rev': case '--reverse':
+        reverse = true
+        break
+      case '-l': case '--loose':
+        loose = true
+        break
+      case '-p': case '--include-prerelease':
+        includePrerelease = true
+        break
+      case '-v': case '--version':
+        versions.push(argv.shift())
+        break
+      case '-i': case '--inc': case '--increment':
+        switch (argv[0]) {
+          case 'major': case 'minor': case 'patch': case 'prerelease':
+          case 'premajor': case 'preminor': case 'prepatch':
+            inc = argv.shift()
+            break
+          default:
+            inc = 'patch'
+            break
+        }
+        break
+      case '--preid':
+        identifier = argv.shift()
+        break
+      case '-r': case '--range':
+        range.push(argv.shift())
+        break
+      case '-c': case '--coerce':
+        coerce = true
+        break
+      case '--rtl':
+        rtl = true
+        break
+      case '--ltr':
+        rtl = false
+        break
+      case '-h': case '--help': case '-?':
+        return help()
+      default:
+        versions.push(a)
+        break
+    }
+  }
+
+  var options = { loose: loose, includePrerelease: includePrerelease, rtl: rtl }
+
+  versions = versions.map(function (v) {
+    return coerce ? (semver.coerce(v, options) || { version: v }).version : v
+  }).filter(function (v) {
+    return semver.valid(v)
+  })
+  if (!versions.length) return fail()
+  if (inc && (versions.length !== 1 || range.length)) { return failInc() }
+
+  for (var i = 0, l = range.length; i < l; i++) {
+    versions = versions.filter(function (v) {
+      return semver.satisfies(v, range[i], options)
+    })
+    if (!versions.length) return fail()
+  }
+  return success(versions)
+}
+
+function failInc () {
+  console.error('--inc can only be used on a single version with no range')
+  fail()
+}
+
+function fail () { process.exit(1) }
+
+function success () {
+  var compare = reverse ? 'rcompare' : 'compare'
+  versions.sort(function (a, b) {
+    return semver[compare](a, b, options)
+  }).map(function (v) {
+    return semver.clean(v, options)
+  }).map(function (v) {
+    return inc ? semver.inc(v, inc, options, identifier) : v
+  }).forEach(function (v, i, _) { console.log(v) })
+}
+
+function help () {
+  console.log(['SemVer ' + version,
+    '',
+    'A JavaScript implementation of the https://semver.org/ specification',
+    'Copyright Isaac Z. Schlueter',
+    '',
+    'Usage: semver [options] <version> [<version> [...]]',
+    'Prints valid versions sorted by SemVer precedence',
+    '',
+    'Options:',
+    '-r --range <range>',
+    '        Print versions that match the specified range.',
+    '',
+    '-i --increment [<level>]',
+    '        Increment a version by the specified level.  Level can',
+    '        be one of: major, minor, patch, premajor, preminor,',
+    "        prepatch, or prerelease.  Default level is 'patch'.",
+    '        Only one version may be specified.',
+    '',
+    '--preid <identifier>',
+    '        Identifier to be used to prefix premajor, preminor,',
+    '        prepatch or prerelease version increments.',
+    '',
+    '-l --loose',
+    '        Interpret versions and ranges loosely',
+    '',
+    '-p --include-prerelease',
+    '        Always include prerelease versions in range matching',
+    '',
+    '-c --coerce',
+    '        Coerce a string into SemVer if possible',
+    '        (does not imply --loose)',
+    '',
+    '--rtl',
+    '        Coerce version strings right to left',
+    '',
+    '--ltr',
+    '        Coerce version strings left to right (default)',
+    '',
+    'Program exits successfully if any valid version satisfies',
+    'all supplied ranges, and prints all satisfying versions.',
+    '',
+    'If no satisfying versions are found, then exits failure.',
+    '',
+    'Versions are printed in ascending order, so supplying',
+    'multiple versions to the utility will just sort them.'
+  ].join('\n'))
+}

app/code/node_modules/@babel/preset-env/node_modules/semver/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "semver",
+  "version": "6.3.0",
+  "description": "The semantic version parser used by npm.",
+  "main": "semver.js",
+  "scripts": {
+    "test": "tap",
+    "preversion": "npm test",
+    "postversion": "npm publish",
+    "postpublish": "git push origin --follow-tags"
+  },
+  "devDependencies": {
+    "tap": "^14.3.1"
+  },
+  "license": "ISC",
+  "repository": "https://github.com/npm/node-semver",
+  "bin": {
+    "semver": "./bin/semver.js"
+  },
+  "files": [
+    "bin",
+    "range.bnf",
+    "semver.js"
+  ],
+  "tap": {
+    "check-coverage": true
+  }
+}

app/code/node_modules/@babel/preset-env/node_modules/semver/range.bnf

@@ -0,0 +1,16 @@
+range-set  ::= range ( logical-or range ) *
+logical-or ::= ( ' ' ) * '||' ( ' ' ) *
+range      ::= hyphen | simple ( ' ' simple ) * | ''
+hyphen     ::= partial ' - ' partial
+simple     ::= primitive | partial | tilde | caret
+primitive  ::= ( '<' | '>' | '>=' | '<=' | '=' ) partial
+partial    ::= xr ( '.' xr ( '.' xr qualifier ? )? )?
+xr         ::= 'x' | 'X' | '*' | nr
+nr         ::= '0' | [1-9] ( [0-9] ) *
+tilde      ::= '~' partial
+caret      ::= '^' partial
+qualifier  ::= ( '-' pre )? ( '+' build )?
+pre        ::= parts
+build      ::= parts
+parts      ::= part ( '.' part ) *
+part       ::= nr | [-0-9A-Za-z]+

app/code/node_modules/@babel/preset-env/package.json

@@ -0,0 +1,106 @@
+{
+  "name": "@babel/preset-env",
+  "version": "7.16.11",
+  "description": "A Babel preset for each environment.",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "homepage": "https://babel.dev/docs/en/next/babel-preset-env",
+  "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20preset-env%22+is%3Aopen",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-preset-env"
+  },
+  "main": "./lib/index.js",
+  "dependencies": {
+    "@babel/compat-data": "^7.16.8",
+    "@babel/helper-compilation-targets": "^7.16.7",
+    "@babel/helper-plugin-utils": "^7.16.7",
+    "@babel/helper-validator-option": "^7.16.7",
+    "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": "^7.16.7",
+    "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": "^7.16.7",
+    "@babel/plugin-proposal-async-generator-functions": "^7.16.8",
+    "@babel/plugin-proposal-class-properties": "^7.16.7",
+    "@babel/plugin-proposal-class-static-block": "^7.16.7",
+    "@babel/plugin-proposal-dynamic-import": "^7.16.7",
+    "@babel/plugin-proposal-export-namespace-from": "^7.16.7",
+    "@babel/plugin-proposal-json-strings": "^7.16.7",
+    "@babel/plugin-proposal-logical-assignment-operators": "^7.16.7",
+    "@babel/plugin-proposal-nullish-coalescing-operator": "^7.16.7",
+    "@babel/plugin-proposal-numeric-separator": "^7.16.7",
+    "@babel/plugin-proposal-object-rest-spread": "^7.16.7",
+    "@babel/plugin-proposal-optional-catch-binding": "^7.16.7",
+    "@babel/plugin-proposal-optional-chaining": "^7.16.7",
+    "@babel/plugin-proposal-private-methods": "^7.16.11",
+    "@babel/plugin-proposal-private-property-in-object": "^7.16.7",
+    "@babel/plugin-proposal-unicode-property-regex": "^7.16.7",
+    "@babel/plugin-syntax-async-generators": "^7.8.4",
+    "@babel/plugin-syntax-class-properties": "^7.12.13",
+    "@babel/plugin-syntax-class-static-block": "^7.14.5",
+    "@babel/plugin-syntax-dynamic-import": "^7.8.3",
+    "@babel/plugin-syntax-export-namespace-from": "^7.8.3",
+    "@babel/plugin-syntax-json-strings": "^7.8.3",
+    "@babel/plugin-syntax-logical-assignment-operators": "^7.10.4",
+    "@babel/plugin-syntax-nullish-coalescing-operator": "^7.8.3",
+    "@babel/plugin-syntax-numeric-separator": "^7.10.4",
+    "@babel/plugin-syntax-object-rest-spread": "^7.8.3",
+    "@babel/plugin-syntax-optional-catch-binding": "^7.8.3",
+    "@babel/plugin-syntax-optional-chaining": "^7.8.3",
+    "@babel/plugin-syntax-private-property-in-object": "^7.14.5",
+    "@babel/plugin-syntax-top-level-await": "^7.14.5",
+    "@babel/plugin-transform-arrow-functions": "^7.16.7",
+    "@babel/plugin-transform-async-to-generator": "^7.16.8",
+    "@babel/plugin-transform-block-scoped-functions": "^7.16.7",
+    "@babel/plugin-transform-block-scoping": "^7.16.7",
+    "@babel/plugin-transform-classes": "^7.16.7",
+    "@babel/plugin-transform-computed-properties": "^7.16.7",
+    "@babel/plugin-transform-destructuring": "^7.16.7",
+    "@babel/plugin-transform-dotall-regex": "^7.16.7",
+    "@babel/plugin-transform-duplicate-keys": "^7.16.7",
+    "@babel/plugin-transform-exponentiation-operator": "^7.16.7",
+    "@babel/plugin-transform-for-of": "^7.16.7",
+    "@babel/plugin-transform-function-name": "^7.16.7",
+    "@babel/plugin-transform-literals": "^7.16.7",
+    "@babel/plugin-transform-member-expression-literals": "^7.16.7",
+    "@babel/plugin-transform-modules-amd": "^7.16.7",
+    "@babel/plugin-transform-modules-commonjs": "^7.16.8",
+    "@babel/plugin-transform-modules-systemjs": "^7.16.7",
+    "@babel/plugin-transform-modules-umd": "^7.16.7",
+    "@babel/plugin-transform-named-capturing-groups-regex": "^7.16.8",
+    "@babel/plugin-transform-new-target": "^7.16.7",
+    "@babel/plugin-transform-object-super": "^7.16.7",
+    "@babel/plugin-transform-parameters": "^7.16.7",
+    "@babel/plugin-transform-property-literals": "^7.16.7",
+    "@babel/plugin-transform-regenerator": "^7.16.7",
+    "@babel/plugin-transform-reserved-words": "^7.16.7",
+    "@babel/plugin-transform-shorthand-properties": "^7.16.7",
+    "@babel/plugin-transform-spread": "^7.16.7",
+    "@babel/plugin-transform-sticky-regex": "^7.16.7",
+    "@babel/plugin-transform-template-literals": "^7.16.7",
+    "@babel/plugin-transform-typeof-symbol": "^7.16.7",
+    "@babel/plugin-transform-unicode-escapes": "^7.16.7",
+    "@babel/plugin-transform-unicode-regex": "^7.16.7",
+    "@babel/preset-modules": "^0.1.5",
+    "@babel/types": "^7.16.8",
+    "babel-plugin-polyfill-corejs2": "^0.3.0",
+    "babel-plugin-polyfill-corejs3": "^0.5.0",
+    "babel-plugin-polyfill-regenerator": "^0.3.0",
+    "core-js-compat": "^3.20.2",
+    "semver": "^6.3.0"
+  },
+  "peerDependencies": {
+    "@babel/core": "^7.0.0-0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.16.10",
+    "@babel/core-7.12": "npm:@babel/core@7.12.9",
+    "@babel/helper-plugin-test-runner": "^7.16.7",
+    "@babel/traverse": "^7.16.10"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  }
+}