update

node_modules/@babel/helper-compilation-targets/README.md

@@ -0,0 +1,19 @@
+# @babel/helper-compilation-targets
+
+> Helper functions on Babel compilation targets
+
+See our website [@babel/helper-compilation-targets](https://babeljs.io/docs/en/babel-helper-compilation-targets) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save @babel/helper-compilation-targets
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/helper-compilation-targets
+```

node_modules/@babel/helper-compilation-targets/lib/debug.js

@@ -5,14 +5,12 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.getInclusionReasons = getInclusionReasons;
 
-var _semver = _interopRequireDefault(require("semver"));
+var _semver = require("semver");
 
 var _pretty = require("./pretty");
 
 var _utils = require("./utils");
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 function getInclusionReasons(item, targetVersions, list) {
   const minVersions = list[item] || {};
   return Object.keys(targetVersions).reduce((result, env) => {
@@ -25,7 +23,7 @@ function getInclusionReasons(item, targetVersions, list) {
       const minIsUnreleased = (0, _utils.isUnreleasedVersion)(minVersion, env);
       const targetIsUnreleased = (0, _utils.isUnreleasedVersion)(targetVersion, env);
 
-      if (!targetIsUnreleased && (minIsUnreleased || _semver.default.lt(targetVersion.toString(), (0, _utils.semverify)(minVersion)))) {
+      if (!targetIsUnreleased && (minIsUnreleased || _semver.lt(targetVersion.toString(), (0, _utils.semverify)(minVersion)))) {
         result[env] = (0, _pretty.prettifyVersion)(targetVersion);
       }
     }

node_modules/@babel/helper-compilation-targets/lib/filter-items.js

@@ -3,18 +3,16 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.targetsSupported = targetsSupported;
-exports.isRequired = isRequired;
 exports.default = filterItems;
+exports.isRequired = isRequired;
+exports.targetsSupported = targetsSupported;
 
-var _semver = _interopRequireDefault(require("semver"));
+var _semver = require("semver");
 
-var _plugins = _interopRequireDefault(require("@babel/compat-data/plugins"));
+var _plugins = require("@babel/compat-data/plugins");
 
 var _utils = require("./utils");
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 function targetsSupported(target, support) {
   const targetEnvironments = Object.keys(target);
 
@@ -39,22 +37,22 @@ function targetsSupported(target, support) {
       return true;
     }
 
-    if (!_semver.default.valid(lowestTargetedVersion.toString())) {
+    if (!_semver.valid(lowestTargetedVersion.toString())) {
       throw new Error(`Invalid version passed for target "${environment}": "${lowestTargetedVersion}". ` + "Versions must be in semver format (major.minor.patch)");
     }
 
-    return _semver.default.gt((0, _utils.semverify)(lowestImplementedVersion), lowestTargetedVersion.toString());
+    return _semver.gt((0, _utils.semverify)(lowestImplementedVersion), lowestTargetedVersion.toString());
   });
   return unsupportedEnvironments.length === 0;
 }
 
 function isRequired(name, targets, {
-  compatData = _plugins.default,
+  compatData = _plugins,
   includes,
   excludes
 } = {}) {
-  if (excludes == null ? void 0 : excludes.has(name)) return false;
-  if (includes == null ? void 0 : includes.has(name)) return true;
+  if (excludes != null && excludes.has(name)) return false;
+  if (includes != null && includes.has(name)) return true;
   return !targetsSupported(targets, compatData[name]);
 }
 

node_modules/@babel/helper-compilation-targets/lib/index.js

@@ -3,18 +3,17 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.isBrowsersQueryValid = isBrowsersQueryValid;
-exports.default = getTargets;
-Object.defineProperty(exports, "unreleasedLabels", {
+Object.defineProperty(exports, "TargetNames", {
   enumerable: true,
   get: function () {
-    return _targets.unreleasedLabels;
+    return _options.TargetNames;
   }
 });
-Object.defineProperty(exports, "prettifyTargets", {
+exports.default = getTargets;
+Object.defineProperty(exports, "filterItems", {
   enumerable: true,
   get: function () {
-    return _pretty.prettifyTargets;
+    return _filterItems.default;
   }
 });
 Object.defineProperty(exports, "getInclusionReasons", {
@@ -23,26 +22,31 @@ Object.defineProperty(exports, "getInclusionReasons", {
     return _debug.getInclusionReasons;
   }
 });
-Object.defineProperty(exports, "filterItems", {
-  enumerable: true,
-  get: function () {
-    return _filterItems.default;
-  }
-});
+exports.isBrowsersQueryValid = isBrowsersQueryValid;
 Object.defineProperty(exports, "isRequired", {
   enumerable: true,
   get: function () {
     return _filterItems.isRequired;
   }
 });
+Object.defineProperty(exports, "prettifyTargets", {
+  enumerable: true,
+  get: function () {
+    return _pretty.prettifyTargets;
+  }
+});
+Object.defineProperty(exports, "unreleasedLabels", {
+  enumerable: true,
+  get: function () {
+    return _targets.unreleasedLabels;
+  }
+});
 
-var _browserslist = _interopRequireDefault(require("browserslist"));
+var _browserslist = require("browserslist");
 
-var _levenary = _interopRequireDefault(require("levenary"));
+var _helperValidatorOption = require("@babel/helper-validator-option");
 
-var _invariant = _interopRequireDefault(require("invariant"));
-
-var _nativeModules = _interopRequireDefault(require("@babel/compat-data/native-modules"));
+var _nativeModules = require("@babel/compat-data/native-modules");
 
 var _utils = require("./utils");
 
@@ -54,35 +58,18 @@ var _pretty = require("./pretty");
 
 var _debug = require("./debug");
 
-var _filterItems = _interopRequireWildcard(require("./filter-items"));
+var _filterItems = require("./filter-items");
 
-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 browserslistDefaults = _browserslist.default.defaults;
-const validBrowserslistTargets = [...Object.keys(_browserslist.default.data), ...Object.keys(_browserslist.default.aliases)];
-
-function objectToBrowserslist(object) {
-  return Object.keys(object).reduce((list, targetName) => {
-    if (validBrowserslistTargets.indexOf(targetName) >= 0) {
-      const targetVersion = object[targetName];
-      return list.concat(`${targetName} ${targetVersion}`);
-    }
-
-    return list;
-  }, []);
-}
+const ESM_SUPPORT = _nativeModules["es6.module"];
+const v = new _helperValidatorOption.OptionValidator("@babel/helper-compilation-targets");
 
 function validateTargetNames(targets) {
   const validTargets = Object.keys(_options.TargetNames);
 
-  for (const target in targets) {
-    if (!_options.TargetNames[target]) {
-      throw new Error(`Invalid Option: '${target}' is not a valid target
-        Maybe you meant to use '${(0, _levenary.default)(target, validTargets)}'?`);
+  for (const target of Object.keys(targets)) {
+    if (!(target in _options.TargetNames)) {
+      throw new Error(v.formatMessage(`'${target}' is not a valid target
+- Did you mean '${(0, _helperValidatorOption.findSuggestion)(target, validTargets)}'?`));
     }
   }
 
@@ -90,42 +77,42 @@ function validateTargetNames(targets) {
 }
 
 function isBrowsersQueryValid(browsers) {
-  return typeof browsers === "string" || Array.isArray(browsers);
+  return typeof browsers === "string" || Array.isArray(browsers) && browsers.every(b => typeof b === "string");
 }
 
 function validateBrowsers(browsers) {
-  (0, _invariant.default)(typeof browsers === "undefined" || isBrowsersQueryValid(browsers), `Invalid Option: '${String(browsers)}' is not a valid browserslist query`);
+  v.invariant(browsers === undefined || isBrowsersQueryValid(browsers), `'${String(browsers)}' is not a valid browserslist query`);
   return browsers;
 }
 
 function getLowestVersions(browsers) {
   return browsers.reduce((all, browser) => {
     const [browserName, browserVersion] = browser.split(" ");
-    const normalizedBrowserName = _targets.browserNameMap[browserName];
+    const target = _targets.browserNameMap[browserName];
 
-    if (!normalizedBrowserName) {
+    if (!target) {
       return all;
     }
 
     try {
       const splitVersion = browserVersion.split("-")[0].toLowerCase();
-      const isSplitUnreleased = (0, _utils.isUnreleasedVersion)(splitVersion, browserName);
+      const isSplitUnreleased = (0, _utils.isUnreleasedVersion)(splitVersion, target);
 
-      if (!all[normalizedBrowserName]) {
-        all[normalizedBrowserName] = isSplitUnreleased ? splitVersion : (0, _utils.semverify)(splitVersion);
+      if (!all[target]) {
+        all[target] = isSplitUnreleased ? splitVersion : (0, _utils.semverify)(splitVersion);
         return all;
       }
 
-      const version = all[normalizedBrowserName];
-      const isUnreleased = (0, _utils.isUnreleasedVersion)(version, browserName);
+      const version = all[target];
+      const isUnreleased = (0, _utils.isUnreleasedVersion)(version, target);
 
       if (isUnreleased && isSplitUnreleased) {
-        all[normalizedBrowserName] = (0, _utils.getLowestUnreleased)(version, splitVersion, browserName);
+        all[target] = (0, _utils.getLowestUnreleased)(version, splitVersion, target);
       } else if (isUnreleased) {
-        all[normalizedBrowserName] = (0, _utils.semverify)(splitVersion);
+        all[target] = (0, _utils.semverify)(splitVersion);
       } else if (!isUnreleased && !isSplitUnreleased) {
         const parsedBrowserVersion = (0, _utils.semverify)(splitVersion);
-        all[normalizedBrowserName] = (0, _utils.semverMin)(version, parsedBrowserVersion);
+        all[target] = (0, _utils.semverMin)(version, parsedBrowserVersion);
       }
     } catch (e) {}
 
@@ -134,102 +121,130 @@ function getLowestVersions(browsers) {
 }
 
 function outputDecimalWarning(decimalTargets) {
-  if (!(decimalTargets == null ? void 0 : decimalTargets.length)) {
+  if (!decimalTargets.length) {
     return;
   }
 
-  console.log("Warning, the following targets are using a decimal version:");
-  console.log("");
+  console.warn("Warning, the following targets are using a decimal version:\n");
   decimalTargets.forEach(({
     target,
     value
-  }) => console.log(`  ${target}: ${value}`));
-  console.log("");
-  console.log("We recommend using a string for minor/patch versions to avoid numbers like 6.10");
-  console.log("getting parsed as 6.1, which can lead to unexpected behavior.");
-  console.log("");
+  }) => console.warn(`  ${target}: ${value}`));
+  console.warn(`
+We recommend using a string for minor/patch versions to avoid numbers like 6.10
+getting parsed as 6.1, which can lead to unexpected behavior.
+`);
 }
 
 function semverifyTarget(target, value) {
   try {
     return (0, _utils.semverify)(value);
   } catch (error) {
-    throw new Error(`Invalid Option: '${value}' is not a valid value for 'targets.${target}'.`);
+    throw new Error(v.formatMessage(`'${value}' is not a valid value for 'targets.${target}'.`));
   }
 }
 
-const targetParserMap = {
-  __default(target, value) {
-    const version = (0, _utils.isUnreleasedVersion)(value, target) ? value.toLowerCase() : semverifyTarget(target, value);
-    return [target, version];
-  },
+function nodeTargetParser(value) {
+  const parsed = value === true || value === "current" ? process.versions.node : semverifyTarget("node", value);
+  return ["node", parsed];
+}
 
-  node(target, value) {
-    const parsed = value === true || value === "current" ? process.versions.node : semverifyTarget(target, value);
-    return [target, parsed];
-  }
+function defaultTargetParser(target, value) {
+  const version = (0, _utils.isUnreleasedVersion)(value, target) ? value.toLowerCase() : semverifyTarget(target, value);
+  return [target, version];
+}
 
-};
-
-function getTargets(inputTargets = {}, options = {}) {
-  const targetOpts = {};
-  let {
-    browsers
-  } = inputTargets;
-
-  if (inputTargets.esmodules) {
-    const supportsESModules = _nativeModules.default["es6.module"];
-    browsers = Object.keys(supportsESModules).map(browser => `${browser} ${supportsESModules[browser]}`).join(", ");
-  }
-
-  const browsersquery = validateBrowsers(browsers);
+function generateTargets(inputTargets) {
   const input = Object.assign({}, inputTargets);
   delete input.esmodules;
   delete input.browsers;
+  return input;
+}
+
+function resolveTargets(queries, env) {
+  const resolved = _browserslist(queries, {
+    mobileToDesktop: true,
+    env
+  });
+
+  return getLowestVersions(resolved);
+}
+
+function getTargets(inputTargets = {}, options = {}) {
+  var _browsers, _browsers2;
+
+  let {
+    browsers,
+    esmodules
+  } = inputTargets;
+  const {
+    configPath = "."
+  } = options;
+  validateBrowsers(browsers);
+  const input = generateTargets(inputTargets);
   let targets = validateTargetNames(input);
-  const shouldParseBrowsers = !!browsersquery;
+  const shouldParseBrowsers = !!browsers;
   const hasTargets = shouldParseBrowsers || Object.keys(targets).length > 0;
   const shouldSearchForConfig = !options.ignoreBrowserslistConfig && !hasTargets;
 
-  if (shouldParseBrowsers || shouldSearchForConfig) {
-    if (!hasTargets) {
-      _browserslist.default.defaults = objectToBrowserslist(targets);
-    }
-
-    const browsers = (0, _browserslist.default)(browsersquery, {
-      path: options.configPath,
-      mobileToDesktop: true,
+  if (!browsers && shouldSearchForConfig) {
+    browsers = _browserslist.loadConfig({
+      config: options.configFile,
+      path: configPath,
       env: options.browserslistEnv
     });
-    const queryBrowsers = getLowestVersions(browsers);
-    targets = Object.assign(queryBrowsers, targets);
-    _browserslist.default.defaults = browserslistDefaults;
+
+    if (browsers == null) {
+      {
+        browsers = [];
+      }
+    }
   }
 
-  const parsed = Object.keys(targets).sort().reduce((results, target) => {
-    var _targetParserMap$targ;
+  if (esmodules && (esmodules !== "intersect" || !((_browsers = browsers) != null && _browsers.length))) {
+    browsers = Object.keys(ESM_SUPPORT).map(browser => `${browser} >= ${ESM_SUPPORT[browser]}`).join(", ");
+    esmodules = false;
+  }
 
+  if ((_browsers2 = browsers) != null && _browsers2.length) {
+    const queryBrowsers = resolveTargets(browsers, options.browserslistEnv);
+
+    if (esmodules === "intersect") {
+      for (const browser of Object.keys(queryBrowsers)) {
+        const version = queryBrowsers[browser];
+        const esmSupportVersion = ESM_SUPPORT[browser];
+
+        if (esmSupportVersion) {
+          queryBrowsers[browser] = (0, _utils.getHighestUnreleased)(version, (0, _utils.semverify)(esmSupportVersion), browser);
+        } else {
+          delete queryBrowsers[browser];
+        }
+      }
+    }
+
+    targets = Object.assign(queryBrowsers, targets);
+  }
+
+  const result = {};
+  const decimalWarnings = [];
+
+  for (const target of Object.keys(targets).sort()) {
     const value = targets[target];
 
     if (typeof value === "number" && value % 1 !== 0) {
-      results.decimalWarnings.push({
+      decimalWarnings.push({
         target,
         value
       });
     }
 
-    const parser = (_targetParserMap$targ = targetParserMap[target]) != null ? _targetParserMap$targ : targetParserMap.__default;
-    const [parsedTarget, parsedValue] = parser(target, value);
+    const [parsedTarget, parsedValue] = target === "node" ? nodeTargetParser(value) : defaultTargetParser(target, value);
 
     if (parsedValue) {
-      results.targets[parsedTarget] = parsedValue;
+      result[parsedTarget] = parsedValue;
     }
+  }
 
-    return results;
-  }, {
-    targets: targetOpts,
-    decimalWarnings: []
-  });
-  outputDecimalWarning(parsed.decimalWarnings);
-  return parsed.targets;
+  outputDecimalWarning(decimalWarnings);
+  return result;
 }

node_modules/@babel/helper-compilation-targets/lib/options.js

@@ -15,6 +15,7 @@ const TargetNames = {
   ios: "ios",
   android: "android",
   electron: "electron",
-  samsung: "samsung"
+  samsung: "samsung",
+  rhino: "rhino"
 };
 exports.TargetNames = TargetNames;

node_modules/@babel/helper-compilation-targets/lib/pretty.js

@@ -3,25 +3,23 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.prettifyVersion = prettifyVersion;
 exports.prettifyTargets = prettifyTargets;
+exports.prettifyVersion = prettifyVersion;
 
-var _semver = _interopRequireDefault(require("semver"));
+var _semver = require("semver");
 
 var _targets = require("./targets");
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 function prettifyVersion(version) {
   if (typeof version !== "string") {
     return version;
   }
 
-  const parts = [_semver.default.major(version)];
+  const parts = [_semver.major(version)];
 
-  const minor = _semver.default.minor(version);
+  const minor = _semver.minor(version);
 
-  const patch = _semver.default.patch(version);
+  const patch = _semver.patch(version);
 
   if (minor || patch) {
     parts.push(minor);

node_modules/@babel/helper-compilation-targets/lib/targets.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.browserNameMap = exports.unreleasedLabels = void 0;
+exports.unreleasedLabels = exports.browserNameMap = void 0;
 const unreleasedLabels = {
   safari: "tp"
 };

node_modules/@babel/helper-compilation-targets/lib/utils.js

@@ -3,32 +3,32 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.getHighestUnreleased = getHighestUnreleased;
+exports.getLowestImplementedVersion = getLowestImplementedVersion;
+exports.getLowestUnreleased = getLowestUnreleased;
+exports.isUnreleasedVersion = isUnreleasedVersion;
 exports.semverMin = semverMin;
 exports.semverify = semverify;
-exports.isUnreleasedVersion = isUnreleasedVersion;
-exports.getLowestUnreleased = getLowestUnreleased;
-exports.getLowestImplementedVersion = getLowestImplementedVersion;
 
-var _invariant = _interopRequireDefault(require("invariant"));
+var _semver = require("semver");
 
-var _semver = _interopRequireDefault(require("semver"));
+var _helperValidatorOption = require("@babel/helper-validator-option");
 
 var _targets = require("./targets");
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 const versionRegExp = /^(\d+|\d+.\d+)$/;
+const v = new _helperValidatorOption.OptionValidator("@babel/helper-compilation-targets");
 
 function semverMin(first, second) {
-  return first && _semver.default.lt(first, second) ? first : second;
+  return first && _semver.lt(first, second) ? first : second;
 }
 
 function semverify(version) {
-  if (typeof version === "string" && _semver.default.valid(version)) {
+  if (typeof version === "string" && _semver.valid(version)) {
     return version;
   }
 
-  (0, _invariant.default)(typeof version === "number" || typeof version === "string" && versionRegExp.test(version), `'${version}' is not a valid version`);
+  v.invariant(typeof version === "number" || typeof version === "string" && versionRegExp.test(version), `'${version}' is not a valid version`);
   const split = version.toString().split(".");
 
   while (split.length < 3) {
@@ -45,15 +45,22 @@ function isUnreleasedVersion(version, env) {
 
 function getLowestUnreleased(a, b, env) {
   const unreleasedLabel = _targets.unreleasedLabels[env];
-  const hasUnreleased = [a, b].some(item => item === unreleasedLabel);
 
-  if (hasUnreleased) {
-    return a === hasUnreleased ? b : a || b;
+  if (a === unreleasedLabel) {
+    return b;
+  }
+
+  if (b === unreleasedLabel) {
+    return a;
   }
 
   return semverMin(a, b);
 }
 
+function getHighestUnreleased(a, b, env) {
+  return getLowestUnreleased(a, b, env) === a ? b : a;
+}
+
 function getLowestImplementedVersion(plugin, environment) {
   const result = plugin[environment];
 

node_modules/@babel/helper-compilation-targets/node_modules/.bin/semver

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

node_modules/@babel/helper-compilation-targets/node_modules/semver/CHANGELOG.md

@@ -1,5 +1,36 @@
 # 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

node_modules/@babel/helper-compilation-targets/node_modules/semver/README.md

@@ -4,7 +4,7 @@ semver(1) -- The semantic versioner for npm
 ## Install
 
 ```bash
-npm install --save semver
+npm install semver
 ````
 
 ## Usage
@@ -60,6 +60,12 @@ Options:
         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.
 
@@ -231,7 +237,7 @@ comparator.  Allows minor-level changes if not.
 
 #### Caret Ranges `^1.2.3` `^0.2.5` `^0.0.4`
 
-Allows changes that do not modify the left-most non-zero digit in the
+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`.
@@ -354,6 +360,9 @@ strings that they parse.
   `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.
@@ -396,7 +405,7 @@ range, use the `satisfies(version, range)` function.
 
 ### Coercion
 
-* `coerce(version)`: Coerces a string to semver if possible
+* `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
@@ -408,5 +417,27 @@ surrounding text is simply ignored (`v3.4 replaces v3.3.1` becomes
 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 `Number.MAX_SAFE_INTEGER || (2**53 - 1)`; higher value
+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`

node_modules/@babel/helper-compilation-targets/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'))
+}

node_modules/@babel/helper-compilation-targets/node_modules/semver/package.json

@@ -1,41 +1,41 @@
 {
   "_args": [
     [
-      "semver@5.7.1",
-      "/mnt/Foxconn/Digitalent/Deverloper/liff-push_2series"
+      "semver@6.3.0",
+      "/home/node/nuxt"
     ]
   ],
-  "_from": "semver@5.7.1",
-  "_id": "semver@5.7.1",
+  "_from": "semver@6.3.0",
+  "_id": "semver@6.3.0",
   "_inBundle": false,
-  "_integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==",
+  "_integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==",
   "_location": "/@babel/helper-compilation-targets/semver",
   "_phantomChildren": {},
   "_requested": {
     "type": "version",
     "registry": true,
-    "raw": "semver@5.7.1",
+    "raw": "semver@6.3.0",
     "name": "semver",
     "escapedName": "semver",
-    "rawSpec": "5.7.1",
+    "rawSpec": "6.3.0",
     "saveSpec": null,
-    "fetchSpec": "5.7.1"
+    "fetchSpec": "6.3.0"
   },
   "_requiredBy": [
     "/@babel/helper-compilation-targets"
   ],
-  "_resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz",
-  "_spec": "5.7.1",
-  "_where": "/mnt/Foxconn/Digitalent/Deverloper/liff-push_2series",
+  "_resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz",
+  "_spec": "6.3.0",
+  "_where": "/home/node/nuxt",
   "bin": {
-    "semver": "bin/semver"
+    "semver": "bin/semver.js"
   },
   "bugs": {
     "url": "https://github.com/npm/node-semver/issues"
   },
   "description": "The semantic version parser used by npm.",
   "devDependencies": {
-    "tap": "^13.0.0-rc.18"
+    "tap": "^14.3.1"
   },
   "files": [
     "bin",
@@ -51,7 +51,7 @@
     "url": "git+https://github.com/npm/node-semver.git"
   },
   "scripts": {
-    "postpublish": "git push origin --all; git push origin --tags",
+    "postpublish": "git push origin --follow-tags",
     "postversion": "npm publish",
     "preversion": "npm test",
     "test": "tap"
@@ -59,5 +59,5 @@
   "tap": {
     "check-coverage": true
   },
-  "version": "5.7.1"
+  "version": "6.3.0"
 }

node_modules/@babel/helper-compilation-targets/node_modules/semver/semver.js

@@ -29,75 +29,80 @@ var MAX_SAFE_COMPONENT_LENGTH = 16
 // The actual regexps go on exports.re
 var re = exports.re = []
 var src = exports.src = []
+var t = exports.tokens = {}
 var R = 0
 
+function tok (n) {
+  t[n] = R++
+}
+
 // The following Regular Expressions can be used for tokenizing,
 // validating, and parsing SemVer version strings.
 
 // ## Numeric Identifier
 // A single `0`, or a non-zero digit followed by zero or more digits.
 
-var NUMERICIDENTIFIER = R++
-src[NUMERICIDENTIFIER] = '0|[1-9]\\d*'
-var NUMERICIDENTIFIERLOOSE = R++
-src[NUMERICIDENTIFIERLOOSE] = '[0-9]+'
+tok('NUMERICIDENTIFIER')
+src[t.NUMERICIDENTIFIER] = '0|[1-9]\\d*'
+tok('NUMERICIDENTIFIERLOOSE')
+src[t.NUMERICIDENTIFIERLOOSE] = '[0-9]+'
 
 // ## Non-numeric Identifier
 // Zero or more digits, followed by a letter or hyphen, and then zero or
 // more letters, digits, or hyphens.
 
-var NONNUMERICIDENTIFIER = R++
-src[NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-][a-zA-Z0-9-]*'
+tok('NONNUMERICIDENTIFIER')
+src[t.NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-][a-zA-Z0-9-]*'
 
 // ## Main Version
 // Three dot-separated numeric identifiers.
 
-var MAINVERSION = R++
-src[MAINVERSION] = '(' + src[NUMERICIDENTIFIER] + ')\\.' +
-                   '(' + src[NUMERICIDENTIFIER] + ')\\.' +
-                   '(' + src[NUMERICIDENTIFIER] + ')'
+tok('MAINVERSION')
+src[t.MAINVERSION] = '(' + src[t.NUMERICIDENTIFIER] + ')\\.' +
+                   '(' + src[t.NUMERICIDENTIFIER] + ')\\.' +
+                   '(' + src[t.NUMERICIDENTIFIER] + ')'
 
-var MAINVERSIONLOOSE = R++
-src[MAINVERSIONLOOSE] = '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' +
-                        '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' +
-                        '(' + src[NUMERICIDENTIFIERLOOSE] + ')'
+tok('MAINVERSIONLOOSE')
+src[t.MAINVERSIONLOOSE] = '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' +
+                        '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' +
+                        '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')'
 
 // ## Pre-release Version Identifier
 // A numeric identifier, or a non-numeric identifier.
 
-var PRERELEASEIDENTIFIER = R++
-src[PRERELEASEIDENTIFIER] = '(?:' + src[NUMERICIDENTIFIER] +
-                            '|' + src[NONNUMERICIDENTIFIER] + ')'
+tok('PRERELEASEIDENTIFIER')
+src[t.PRERELEASEIDENTIFIER] = '(?:' + src[t.NUMERICIDENTIFIER] +
+                            '|' + src[t.NONNUMERICIDENTIFIER] + ')'
 
-var PRERELEASEIDENTIFIERLOOSE = R++
-src[PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[NUMERICIDENTIFIERLOOSE] +
-                                 '|' + src[NONNUMERICIDENTIFIER] + ')'
+tok('PRERELEASEIDENTIFIERLOOSE')
+src[t.PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[t.NUMERICIDENTIFIERLOOSE] +
+                                 '|' + src[t.NONNUMERICIDENTIFIER] + ')'
 
 // ## Pre-release Version
 // Hyphen, followed by one or more dot-separated pre-release version
 // identifiers.
 
-var PRERELEASE = R++
-src[PRERELEASE] = '(?:-(' + src[PRERELEASEIDENTIFIER] +
-                  '(?:\\.' + src[PRERELEASEIDENTIFIER] + ')*))'
+tok('PRERELEASE')
+src[t.PRERELEASE] = '(?:-(' + src[t.PRERELEASEIDENTIFIER] +
+                  '(?:\\.' + src[t.PRERELEASEIDENTIFIER] + ')*))'
 
-var PRERELEASELOOSE = R++
-src[PRERELEASELOOSE] = '(?:-?(' + src[PRERELEASEIDENTIFIERLOOSE] +
-                       '(?:\\.' + src[PRERELEASEIDENTIFIERLOOSE] + ')*))'
+tok('PRERELEASELOOSE')
+src[t.PRERELEASELOOSE] = '(?:-?(' + src[t.PRERELEASEIDENTIFIERLOOSE] +
+                       '(?:\\.' + src[t.PRERELEASEIDENTIFIERLOOSE] + ')*))'
 
 // ## Build Metadata Identifier
 // Any combination of digits, letters, or hyphens.
 
-var BUILDIDENTIFIER = R++
-src[BUILDIDENTIFIER] = '[0-9A-Za-z-]+'
+tok('BUILDIDENTIFIER')
+src[t.BUILDIDENTIFIER] = '[0-9A-Za-z-]+'
 
 // ## Build Metadata
 // Plus sign, followed by one or more period-separated build metadata
 // identifiers.
 
-var BUILD = R++
-src[BUILD] = '(?:\\+(' + src[BUILDIDENTIFIER] +
-             '(?:\\.' + src[BUILDIDENTIFIER] + ')*))'
+tok('BUILD')
+src[t.BUILD] = '(?:\\+(' + src[t.BUILDIDENTIFIER] +
+             '(?:\\.' + src[t.BUILDIDENTIFIER] + ')*))'
 
 // ## Full Version String
 // A main version, followed optionally by a pre-release version and
@@ -108,129 +113,133 @@ src[BUILD] = '(?:\\+(' + src[BUILDIDENTIFIER] +
 // capturing group, because it should not ever be used in version
 // comparison.
 
-var FULL = R++
-var FULLPLAIN = 'v?' + src[MAINVERSION] +
-                src[PRERELEASE] + '?' +
-                src[BUILD] + '?'
+tok('FULL')
+tok('FULLPLAIN')
+src[t.FULLPLAIN] = 'v?' + src[t.MAINVERSION] +
+                  src[t.PRERELEASE] + '?' +
+                  src[t.BUILD] + '?'
 
-src[FULL] = '^' + FULLPLAIN + '$'
+src[t.FULL] = '^' + src[t.FULLPLAIN] + '$'
 
 // like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
 // also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
 // common in the npm registry.
-var LOOSEPLAIN = '[v=\\s]*' + src[MAINVERSIONLOOSE] +
-                 src[PRERELEASELOOSE] + '?' +
-                 src[BUILD] + '?'
+tok('LOOSEPLAIN')
+src[t.LOOSEPLAIN] = '[v=\\s]*' + src[t.MAINVERSIONLOOSE] +
+                  src[t.PRERELEASELOOSE] + '?' +
+                  src[t.BUILD] + '?'
 
-var LOOSE = R++
-src[LOOSE] = '^' + LOOSEPLAIN + '$'
+tok('LOOSE')
+src[t.LOOSE] = '^' + src[t.LOOSEPLAIN] + '$'
 
-var GTLT = R++
-src[GTLT] = '((?:<|>)?=?)'
+tok('GTLT')
+src[t.GTLT] = '((?:<|>)?=?)'
 
 // Something like "2.*" or "1.2.x".
 // Note that "x.x" is a valid xRange identifer, meaning "any version"
 // Only the first item is strictly required.
-var XRANGEIDENTIFIERLOOSE = R++
-src[XRANGEIDENTIFIERLOOSE] = src[NUMERICIDENTIFIERLOOSE] + '|x|X|\\*'
-var XRANGEIDENTIFIER = R++
-src[XRANGEIDENTIFIER] = src[NUMERICIDENTIFIER] + '|x|X|\\*'
+tok('XRANGEIDENTIFIERLOOSE')
+src[t.XRANGEIDENTIFIERLOOSE] = src[t.NUMERICIDENTIFIERLOOSE] + '|x|X|\\*'
+tok('XRANGEIDENTIFIER')
+src[t.XRANGEIDENTIFIER] = src[t.NUMERICIDENTIFIER] + '|x|X|\\*'
 
-var XRANGEPLAIN = R++
-src[XRANGEPLAIN] = '[v=\\s]*(' + src[XRANGEIDENTIFIER] + ')' +
-                   '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' +
-                   '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' +
-                   '(?:' + src[PRERELEASE] + ')?' +
-                   src[BUILD] + '?' +
+tok('XRANGEPLAIN')
+src[t.XRANGEPLAIN] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIER] + ')' +
+                   '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' +
+                   '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' +
+                   '(?:' + src[t.PRERELEASE] + ')?' +
+                   src[t.BUILD] + '?' +
                    ')?)?'
 
-var XRANGEPLAINLOOSE = R++
-src[XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
-                        '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
-                        '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
-                        '(?:' + src[PRERELEASELOOSE] + ')?' +
-                        src[BUILD] + '?' +
+tok('XRANGEPLAINLOOSE')
+src[t.XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' +
+                        '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' +
+                        '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' +
+                        '(?:' + src[t.PRERELEASELOOSE] + ')?' +
+                        src[t.BUILD] + '?' +
                         ')?)?'
 
-var XRANGE = R++
-src[XRANGE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAIN] + '$'
-var XRANGELOOSE = R++
-src[XRANGELOOSE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAINLOOSE] + '$'
+tok('XRANGE')
+src[t.XRANGE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAIN] + '$'
+tok('XRANGELOOSE')
+src[t.XRANGELOOSE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAINLOOSE] + '$'
 
 // Coercion.
 // Extract anything that could conceivably be a part of a valid semver
-var COERCE = R++
-src[COERCE] = '(?:^|[^\\d])' +
+tok('COERCE')
+src[t.COERCE] = '(^|[^\\d])' +
               '(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' +
               '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +
               '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +
               '(?:$|[^\\d])'
+tok('COERCERTL')
+re[t.COERCERTL] = new RegExp(src[t.COERCE], 'g')
 
 // Tilde ranges.
 // Meaning is "reasonably at or greater than"
-var LONETILDE = R++
-src[LONETILDE] = '(?:~>?)'
+tok('LONETILDE')
+src[t.LONETILDE] = '(?:~>?)'
 
-var TILDETRIM = R++
-src[TILDETRIM] = '(\\s*)' + src[LONETILDE] + '\\s+'
-re[TILDETRIM] = new RegExp(src[TILDETRIM], 'g')
+tok('TILDETRIM')
+src[t.TILDETRIM] = '(\\s*)' + src[t.LONETILDE] + '\\s+'
+re[t.TILDETRIM] = new RegExp(src[t.TILDETRIM], 'g')
 var tildeTrimReplace = '$1~'
 
-var TILDE = R++
-src[TILDE] = '^' + src[LONETILDE] + src[XRANGEPLAIN] + '$'
-var TILDELOOSE = R++
-src[TILDELOOSE] = '^' + src[LONETILDE] + src[XRANGEPLAINLOOSE] + '$'
+tok('TILDE')
+src[t.TILDE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAIN] + '$'
+tok('TILDELOOSE')
+src[t.TILDELOOSE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAINLOOSE] + '$'
 
 // Caret ranges.
 // Meaning is "at least and backwards compatible with"
-var LONECARET = R++
-src[LONECARET] = '(?:\\^)'
+tok('LONECARET')
+src[t.LONECARET] = '(?:\\^)'
 
-var CARETTRIM = R++
-src[CARETTRIM] = '(\\s*)' + src[LONECARET] + '\\s+'
-re[CARETTRIM] = new RegExp(src[CARETTRIM], 'g')
+tok('CARETTRIM')
+src[t.CARETTRIM] = '(\\s*)' + src[t.LONECARET] + '\\s+'
+re[t.CARETTRIM] = new RegExp(src[t.CARETTRIM], 'g')
 var caretTrimReplace = '$1^'
 
-var CARET = R++
-src[CARET] = '^' + src[LONECARET] + src[XRANGEPLAIN] + '$'
-var CARETLOOSE = R++
-src[CARETLOOSE] = '^' + src[LONECARET] + src[XRANGEPLAINLOOSE] + '$'
+tok('CARET')
+src[t.CARET] = '^' + src[t.LONECARET] + src[t.XRANGEPLAIN] + '$'
+tok('CARETLOOSE')
+src[t.CARETLOOSE] = '^' + src[t.LONECARET] + src[t.XRANGEPLAINLOOSE] + '$'
 
 // A simple gt/lt/eq thing, or just "" to indicate "any version"
-var COMPARATORLOOSE = R++
-src[COMPARATORLOOSE] = '^' + src[GTLT] + '\\s*(' + LOOSEPLAIN + ')$|^$'
-var COMPARATOR = R++
-src[COMPARATOR] = '^' + src[GTLT] + '\\s*(' + FULLPLAIN + ')$|^$'
+tok('COMPARATORLOOSE')
+src[t.COMPARATORLOOSE] = '^' + src[t.GTLT] + '\\s*(' + src[t.LOOSEPLAIN] + ')$|^$'
+tok('COMPARATOR')
+src[t.COMPARATOR] = '^' + src[t.GTLT] + '\\s*(' + src[t.FULLPLAIN] + ')$|^$'
 
 // An expression to strip any whitespace between the gtlt and the thing
 // it modifies, so that `> 1.2.3` ==> `>1.2.3`
-var COMPARATORTRIM = R++
-src[COMPARATORTRIM] = '(\\s*)' + src[GTLT] +
-                      '\\s*(' + LOOSEPLAIN + '|' + src[XRANGEPLAIN] + ')'
+tok('COMPARATORTRIM')
+src[t.COMPARATORTRIM] = '(\\s*)' + src[t.GTLT] +
+                      '\\s*(' + src[t.LOOSEPLAIN] + '|' + src[t.XRANGEPLAIN] + ')'
 
 // this one has to use the /g flag
-re[COMPARATORTRIM] = new RegExp(src[COMPARATORTRIM], 'g')
+re[t.COMPARATORTRIM] = new RegExp(src[t.COMPARATORTRIM], 'g')
 var comparatorTrimReplace = '$1$2$3'
 
 // Something like `1.2.3 - 1.2.4`
 // Note that these all use the loose form, because they'll be
 // checked against either the strict or loose comparator form
 // later.
-var HYPHENRANGE = R++
-src[HYPHENRANGE] = '^\\s*(' + src[XRANGEPLAIN] + ')' +
+tok('HYPHENRANGE')
+src[t.HYPHENRANGE] = '^\\s*(' + src[t.XRANGEPLAIN] + ')' +
                    '\\s+-\\s+' +
-                   '(' + src[XRANGEPLAIN] + ')' +
+                   '(' + src[t.XRANGEPLAIN] + ')' +
                    '\\s*$'
 
-var HYPHENRANGELOOSE = R++
-src[HYPHENRANGELOOSE] = '^\\s*(' + src[XRANGEPLAINLOOSE] + ')' +
+tok('HYPHENRANGELOOSE')
+src[t.HYPHENRANGELOOSE] = '^\\s*(' + src[t.XRANGEPLAINLOOSE] + ')' +
                         '\\s+-\\s+' +
-                        '(' + src[XRANGEPLAINLOOSE] + ')' +
+                        '(' + src[t.XRANGEPLAINLOOSE] + ')' +
                         '\\s*$'
 
 // Star ranges basically just allow anything at all.
-var STAR = R++
-src[STAR] = '(<|>)?=?\\s*\\*'
+tok('STAR')
+src[t.STAR] = '(<|>)?=?\\s*\\*'
 
 // Compile to actual regexp objects.
 // All are flag-free, unless they were created above with a flag.
@@ -262,7 +271,7 @@ function parse (version, options) {
     return null
   }
 
-  var r = options.loose ? re[LOOSE] : re[FULL]
+  var r = options.loose ? re[t.LOOSE] : re[t.FULL]
   if (!r.test(version)) {
     return null
   }
@@ -317,7 +326,7 @@ function SemVer (version, options) {
   this.options = options
   this.loose = !!options.loose
 
-  var m = version.trim().match(options.loose ? re[LOOSE] : re[FULL])
+  var m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL])
 
   if (!m) {
     throw new TypeError('Invalid Version: ' + version)
@@ -425,6 +434,30 @@ SemVer.prototype.comparePre = function (other) {
   } while (++i)
 }
 
+SemVer.prototype.compareBuild = function (other) {
+  if (!(other instanceof SemVer)) {
+    other = new SemVer(other, this.options)
+  }
+
+  var i = 0
+  do {
+    var a = this.build[i]
+    var b = other.build[i]
+    debug('prerelease compare', i, a, b)
+    if (a === undefined && b === undefined) {
+      return 0
+    } else if (b === undefined) {
+      return 1
+    } else if (a === undefined) {
+      return -1
+    } else if (a === b) {
+      continue
+    } else {
+      return compareIdentifiers(a, b)
+    }
+  } while (++i)
+}
+
 // preminor will bump the version up to the next minor release, and immediately
 // down to pre-release. premajor and prepatch work the same way.
 SemVer.prototype.inc = function (release, identifier) {
@@ -619,6 +652,13 @@ function compareLoose (a, b) {
   return compare(a, b, true)
 }
 
+exports.compareBuild = compareBuild
+function compareBuild (a, b, loose) {
+  var versionA = new SemVer(a, loose)
+  var versionB = new SemVer(b, loose)
+  return versionA.compare(versionB) || versionA.compareBuild(versionB)
+}
+
 exports.rcompare = rcompare
 function rcompare (a, b, loose) {
   return compare(b, a, loose)
@@ -627,14 +667,14 @@ function rcompare (a, b, loose) {
 exports.sort = sort
 function sort (list, loose) {
   return list.sort(function (a, b) {
-    return exports.compare(a, b, loose)
+    return exports.compareBuild(a, b, loose)
   })
 }
 
 exports.rsort = rsort
 function rsort (list, loose) {
   return list.sort(function (a, b) {
-    return exports.rcompare(a, b, loose)
+    return exports.compareBuild(b, a, loose)
   })
 }
 
@@ -747,14 +787,14 @@ function Comparator (comp, options) {
 
 var ANY = {}
 Comparator.prototype.parse = function (comp) {
-  var r = this.options.loose ? re[COMPARATORLOOSE] : re[COMPARATOR]
+  var r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]
   var m = comp.match(r)
 
   if (!m) {
     throw new TypeError('Invalid comparator: ' + comp)
   }
 
-  this.operator = m[1]
+  this.operator = m[1] !== undefined ? m[1] : ''
   if (this.operator === '=') {
     this.operator = ''
   }
@@ -774,12 +814,16 @@ Comparator.prototype.toString = function () {
 Comparator.prototype.test = function (version) {
   debug('Comparator.test', version, this.options.loose)
 
-  if (this.semver === ANY) {
+  if (this.semver === ANY || version === ANY) {
     return true
   }
 
   if (typeof version === 'string') {
-    version = new SemVer(version, this.options)
+    try {
+      version = new SemVer(version, this.options)
+    } catch (er) {
+      return false
+    }
   }
 
   return cmp(version, this.operator, this.semver, this.options)
@@ -800,9 +844,15 @@ Comparator.prototype.intersects = function (comp, options) {
   var rangeTmp
 
   if (this.operator === '') {
+    if (this.value === '') {
+      return true
+    }
     rangeTmp = new Range(comp.value, options)
     return satisfies(this.value, rangeTmp, options)
   } else if (comp.operator === '') {
+    if (comp.value === '') {
+      return true
+    }
     rangeTmp = new Range(this.value, options)
     return satisfies(comp.semver, rangeTmp, options)
   }
@@ -892,18 +942,18 @@ Range.prototype.parseRange = function (range) {
   var loose = this.options.loose
   range = range.trim()
   // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
-  var hr = loose ? re[HYPHENRANGELOOSE] : re[HYPHENRANGE]
+  var hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE]
   range = range.replace(hr, hyphenReplace)
   debug('hyphen replace', range)
   // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
-  range = range.replace(re[COMPARATORTRIM], comparatorTrimReplace)
-  debug('comparator trim', range, re[COMPARATORTRIM])
+  range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace)
+  debug('comparator trim', range, re[t.COMPARATORTRIM])
 
   // `~ 1.2.3` => `~1.2.3`
-  range = range.replace(re[TILDETRIM], tildeTrimReplace)
+  range = range.replace(re[t.TILDETRIM], tildeTrimReplace)
 
   // `^ 1.2.3` => `^1.2.3`
-  range = range.replace(re[CARETTRIM], caretTrimReplace)
+  range = range.replace(re[t.CARETTRIM], caretTrimReplace)
 
   // normalize spaces
   range = range.split(/\s+/).join(' ')
@@ -911,7 +961,7 @@ Range.prototype.parseRange = function (range) {
   // At this point, the range is completely trimmed and
   // ready to be split into comparators.
 
-  var compRe = loose ? re[COMPARATORLOOSE] : re[COMPARATOR]
+  var compRe = loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]
   var set = range.split(' ').map(function (comp) {
     return parseComparator(comp, this.options)
   }, this).join(' ').split(/\s+/)
@@ -934,16 +984,40 @@ Range.prototype.intersects = function (range, options) {
   }
 
   return this.set.some(function (thisComparators) {
-    return thisComparators.every(function (thisComparator) {
-      return range.set.some(function (rangeComparators) {
-        return rangeComparators.every(function (rangeComparator) {
-          return thisComparator.intersects(rangeComparator, options)
-        })
+    return (
+      isSatisfiable(thisComparators, options) &&
+      range.set.some(function (rangeComparators) {
+        return (
+          isSatisfiable(rangeComparators, options) &&
+          thisComparators.every(function (thisComparator) {
+            return rangeComparators.every(function (rangeComparator) {
+              return thisComparator.intersects(rangeComparator, options)
+            })
+          })
+        )
       })
-    })
+    )
   })
 }
 
+// take a set of comparators and determine whether there
+// exists a version which can satisfy it
+function isSatisfiable (comparators, options) {
+  var result = true
+  var remainingComparators = comparators.slice()
+  var testComparator = remainingComparators.pop()
+
+  while (result && remainingComparators.length) {
+    result = remainingComparators.every(function (otherComparator) {
+      return testComparator.intersects(otherComparator, options)
+    })
+
+    testComparator = remainingComparators.pop()
+  }
+
+  return result
+}
+
 // Mostly just for testing and legacy API reasons
 exports.toComparators = toComparators
 function toComparators (range, options) {
@@ -987,7 +1061,7 @@ function replaceTildes (comp, options) {
 }
 
 function replaceTilde (comp, options) {
-  var r = options.loose ? re[TILDELOOSE] : re[TILDE]
+  var r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE]
   return comp.replace(r, function (_, M, m, p, pr) {
     debug('tilde', comp, _, M, m, p, pr)
     var ret
@@ -1028,7 +1102,7 @@ function replaceCarets (comp, options) {
 
 function replaceCaret (comp, options) {
   debug('caret', comp, options)
-  var r = options.loose ? re[CARETLOOSE] : re[CARET]
+  var r = options.loose ? re[t.CARETLOOSE] : re[t.CARET]
   return comp.replace(r, function (_, M, m, p, pr) {
     debug('caret', comp, _, M, m, p, pr)
     var ret
@@ -1087,7 +1161,7 @@ function replaceXRanges (comp, options) {
 
 function replaceXRange (comp, options) {
   comp = comp.trim()
-  var r = options.loose ? re[XRANGELOOSE] : re[XRANGE]
+  var r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE]
   return comp.replace(r, function (ret, gtlt, M, m, p, pr) {
     debug('xRange', comp, ret, gtlt, M, m, p, pr)
     var xM = isX(M)
@@ -1099,10 +1173,14 @@ function replaceXRange (comp, options) {
       gtlt = ''
     }
 
+    // if we're including prereleases in the match, then we need
+    // to fix this to -0, the lowest possible prerelease value
+    pr = options.includePrerelease ? '-0' : ''
+
     if (xM) {
       if (gtlt === '>' || gtlt === '<') {
         // nothing is allowed
-        ret = '<0.0.0'
+        ret = '<0.0.0-0'
       } else {
         // nothing is forbidden
         ret = '*'
@@ -1139,11 +1217,12 @@ function replaceXRange (comp, options) {
         }
       }
 
-      ret = gtlt + M + '.' + m + '.' + p
+      ret = gtlt + M + '.' + m + '.' + p + pr
     } else if (xm) {
-      ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'
+      ret = '>=' + M + '.0.0' + pr + ' <' + (+M + 1) + '.0.0' + pr
     } else if (xp) {
-      ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'
+      ret = '>=' + M + '.' + m + '.0' + pr +
+        ' <' + M + '.' + (+m + 1) + '.0' + pr
     }
 
     debug('xRange return', ret)
@@ -1157,10 +1236,10 @@ function replaceXRange (comp, options) {
 function replaceStars (comp, options) {
   debug('replaceStars', comp, options)
   // Looseness is ignored here.  star is always as loose as it gets!
-  return comp.trim().replace(re[STAR], '')
+  return comp.trim().replace(re[t.STAR], '')
 }
 
-// This function is passed to string.replace(re[HYPHENRANGE])
+// This function is passed to string.replace(re[t.HYPHENRANGE])
 // M, m, patch, prerelease, build
 // 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
 // 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do
@@ -1200,7 +1279,11 @@ Range.prototype.test = function (version) {
   }
 
   if (typeof version === 'string') {
-    version = new SemVer(version, this.options)
+    try {
+      version = new SemVer(version, this.options)
+    } catch (er) {
+      return false
+    }
   }
 
   for (var i = 0; i < this.set.length; i++) {
@@ -1462,22 +1545,52 @@ function intersects (r1, r2, options) {
 }
 
 exports.coerce = coerce
-function coerce (version) {
+function coerce (version, options) {
   if (version instanceof SemVer) {
     return version
   }
 
+  if (typeof version === 'number') {
+    version = String(version)
+  }
+
   if (typeof version !== 'string') {
     return null
   }
 
-  var match = version.match(re[COERCE])
+  options = options || {}
 
-  if (match == null) {
+  var match = null
+  if (!options.rtl) {
+    match = version.match(re[t.COERCE])
+  } else {
+    // Find the right-most coercible string that does not share
+    // a terminus with a more left-ward coercible string.
+    // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'
+    //
+    // Walk through the string checking with a /g regexp
+    // Manually set the index so as to pick up overlapping matches.
+    // Stop when we get a match that ends at the string end, since no
+    // coercible string can be more right-ward without the same terminus.
+    var next
+    while ((next = re[t.COERCERTL].exec(version)) &&
+      (!match || match.index + match[0].length !== version.length)
+    ) {
+      if (!match ||
+          next.index + next[0].length !== match.index + match[0].length) {
+        match = next
+      }
+      re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length
+    }
+    // leave it in a clean state
+    re[t.COERCERTL].lastIndex = -1
+  }
+
+  if (match === null) {
     return null
   }
 
-  return parse(match[1] +
-    '.' + (match[2] || '0') +
-    '.' + (match[3] || '0'))
+  return parse(match[2] +
+    '.' + (match[3] || '0') +
+    '.' + (match[4] || '0'), options)
 }

node_modules/@babel/helper-compilation-targets/package.json

@@ -1,64 +1,71 @@
 {
   "_args": [
     [
-      "@babel/helper-compilation-targets@7.10.4",
-      "/mnt/Foxconn/Digitalent/Deverloper/liff-push_2series"
+      "@babel/helper-compilation-targets@7.18.6",
+      "/home/node/nuxt"
     ]
   ],
-  "_from": "@babel/helper-compilation-targets@7.10.4",
-  "_id": "@babel/helper-compilation-targets@7.10.4",
+  "_from": "@babel/helper-compilation-targets@7.18.6",
+  "_id": "@babel/helper-compilation-targets@7.18.6",
   "_inBundle": false,
-  "_integrity": "sha512-a3rYhlsGV0UHNDvrtOXBg8/OpfV0OKTkxKPzIplS1zpx7CygDcWWxckxZeDd3gzPzC4kUT0A4nVFDK0wGMh4MQ==",
+  "_integrity": "sha512-vFjbfhNCzqdeAtZflUFrG5YIFqGTqsctrtkZ1D/NB0mDW9TwW3GmmUepYY4G9wCET5rY5ugz4OGTcLd614IzQg==",
   "_location": "/@babel/helper-compilation-targets",
   "_phantomChildren": {},
   "_requested": {
     "type": "version",
     "registry": true,
-    "raw": "@babel/helper-compilation-targets@7.10.4",
+    "raw": "@babel/helper-compilation-targets@7.18.6",
     "name": "@babel/helper-compilation-targets",
     "escapedName": "@babel%2fhelper-compilation-targets",
     "scope": "@babel",
-    "rawSpec": "7.10.4",
+    "rawSpec": "7.18.6",
     "saveSpec": null,
-    "fetchSpec": "7.10.4"
+    "fetchSpec": "7.18.6"
   },
   "_requiredBy": [
+    "/@babel/core",
+    "/@babel/helper-define-polyfill-provider",
+    "/@babel/plugin-proposal-object-rest-spread",
+    "/@babel/plugin-transform-function-name",
     "/@babel/preset-env",
     "/@nuxt/babel-preset-app"
   ],
-  "_resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.10.4.tgz",
-  "_spec": "7.10.4",
-  "_where": "/mnt/Foxconn/Digitalent/Deverloper/liff-push_2series",
+  "_resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.18.6.tgz",
+  "_spec": "7.18.6",
+  "_where": "/home/node/nuxt",
   "author": {
     "name": "The Babel Team",
-    "url": "https://babeljs.io/team"
+    "url": "https://babel.dev/team"
   },
   "bugs": {
     "url": "https://github.com/babel/babel/issues"
   },
   "dependencies": {
-    "@babel/compat-data": "^7.10.4",
-    "browserslist": "^4.12.0",
-    "invariant": "^2.2.4",
-    "levenary": "^1.1.1",
-    "semver": "^5.5.0"
+    "@babel/compat-data": "^7.18.6",
+    "@babel/helper-validator-option": "^7.18.6",
+    "browserslist": "^4.20.2",
+    "semver": "^6.3.0"
   },
-  "description": "Engine compat data used in @babel/preset-env",
+  "description": "Helper functions on Babel compilation targets",
   "devDependencies": {
-    "@babel/core": "^7.10.4",
-    "@babel/helper-plugin-test-runner": "^7.10.4"
+    "@babel/core": "^7.18.6",
+    "@babel/helper-plugin-test-runner": "^7.18.6",
+    "@types/semver": "^5.5.0"
+  },
+  "engines": {
+    "node": ">=6.9.0"
   },
   "exports": {
-    ".": "./lib/index.js"
+    ".": "./lib/index.js",
+    "./package.json": "./package.json"
   },
-  "gitHead": "7fd40d86a0d03ff0e9c3ea16b29689945433d4df",
   "homepage": "https://github.com/babel/babel#readme",
   "keywords": [
     "babel",
     "babel-plugin"
   ],
   "license": "MIT",
-  "main": "lib/index.js",
+  "main": "./lib/index.js",
   "name": "@babel/helper-compilation-targets",
   "peerDependencies": {
     "@babel/core": "^7.0.0"
@@ -71,5 +78,6 @@
     "url": "git+https://github.com/babel/babel.git",
     "directory": "packages/babel-helper-compilation-targets"
   },
-  "version": "7.10.4"
+  "type": "commonjs",
+  "version": "7.18.6"
 }