@vercel/next 4.0.1 → 4.0.3

package/dist/index.js

@@ -770,7 +770,7 @@ module.exports.get_mockS3Http = function() {
 module.exports = exports;
 
 const path = __webpack_require__(5622);
-const semver = __webpack_require__(7013);
+const semver = __webpack_require__(6377);
 const url = __webpack_require__(8835);
 const detect_libc = __webpack_require__(3200);
 const napi = __webpack_require__(7469);
@@ -15753,7 +15753,7 @@ module.exports = {
 
 const fs = __webpack_require__(1317)
 const path = __webpack_require__(5622)
-const invalidWin32Path = __webpack_require__(3126).invalidWin32Path
+const invalidWin32Path = __webpack_require__(9054).invalidWin32Path
 
 const o777 = parseInt('0777', 8)
 
@@ -15815,7 +15815,7 @@ module.exports = mkdirsSync
 
 const fs = __webpack_require__(1317)
 const path = __webpack_require__(5622)
-const invalidWin32Path = __webpack_require__(3126).invalidWin32Path
+const invalidWin32Path = __webpack_require__(9054).invalidWin32Path
 
 const o777 = parseInt('0777', 8)
 
@@ -15878,7 +15878,7 @@ module.exports = mkdirs
 
 /***/ }),
 
-/***/ 3126:
+/***/ 9054:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 "use strict";
@@ -31226,7 +31226,7 @@ SafeBuffer.allocUnsafeSlow = function (size) {
 
 /***/ }),
 
-/***/ 1039:
+/***/ 7846:
 /***/ ((module, exports) => {
 
 exports = module.exports = SemVer
@@ -31257,78 +31257,111 @@ var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||
 // Max safe segment length for coercion.
 var MAX_SAFE_COMPONENT_LENGTH = 16
 
+var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6
+
 // The actual regexps go on exports.re
 var re = exports.re = []
+var safeRe = exports.safeRe = []
 var src = exports.src = []
+var t = exports.tokens = {}
 var R = 0
 
+function tok (n) {
+  t[n] = R++
+}
+
+var LETTERDASHNUMBER = '[a-zA-Z0-9-]'
+
+// Replace some greedy regex tokens to prevent regex dos issues. These regex are
+// used internally via the safeRe object since all inputs in this library get
+// normalized first to trim and collapse all extra whitespace. The original
+// regexes are exported for userland consumption and lower level usage. A
+// future breaking change could export the safer regex only with a note that
+// all input should have extra whitespace removed.
+var safeRegexReplacements = [
+  ['\\s', 1],
+  ['\\d', MAX_LENGTH],
+  [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH],
+]
+
+function makeSafeRe (value) {
+  for (var i = 0; i < safeRegexReplacements.length; i++) {
+    var token = safeRegexReplacements[i][0]
+    var max = safeRegexReplacements[i][1]
+    value = value
+      .split(token + '*').join(token + '{0,' + max + '}')
+      .split(token + '+').join(token + '{1,' + max + '}')
+  }
+  return value
+}
+
 // 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] = '\\d+'
 
 // ## 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-]' + LETTERDASHNUMBER + '*'
 
 // ## 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] = LETTERDASHNUMBER + '+'
 
 // ## 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
@@ -31339,129 +31372,137 @@ 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|\\*'
-
-var XRANGEPLAIN = R++
-src[XRANGEPLAIN] = '[v=\\s]*(' + src[XRANGEIDENTIFIER] + ')' +
-                   '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' +
-                   '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' +
-                   '(?:' + src[PRERELEASE] + ')?' +
-                   src[BUILD] + '?' +
+tok('XRANGEIDENTIFIERLOOSE')
+src[t.XRANGEIDENTIFIERLOOSE] = src[t.NUMERICIDENTIFIERLOOSE] + '|x|X|\\*'
+tok('XRANGEIDENTIFIER')
+src[t.XRANGEIDENTIFIER] = src[t.NUMERICIDENTIFIER] + '|x|X|\\*'
+
+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')
+safeRe[t.COERCERTL] = new RegExp(makeSafeRe(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')
+safeRe[t.TILDETRIM] = new RegExp(makeSafeRe(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')
+safeRe[t.CARETTRIM] = new RegExp(makeSafeRe(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')
+safeRe[t.COMPARATORTRIM] = new RegExp(makeSafeRe(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.
@@ -31469,6 +31510,14 @@ for (var i = 0; i < R; i++) {
   debug(i, src[i])
   if (!re[i]) {
     re[i] = new RegExp(src[i])
+
+    // Replace all greedy whitespace to prevent regex dos issues. These regex are
+    // used internally via the safeRe object since all inputs in this library get
+    // normalized first to trim and collapse all extra whitespace. The original
+    // regexes are exported for userland consumption and lower level usage. A
+    // future breaking change could export the safer regex only with a note that
+    // all input should have extra whitespace removed.
+    safeRe[i] = new RegExp(makeSafeRe(src[i]))
   }
 }
 
@@ -31493,7 +31542,7 @@ function parse (version, options) {
     return null
   }
 
-  var r = options.loose ? re[LOOSE] : re[FULL]
+  var r = options.loose ? safeRe[t.LOOSE] : safeRe[t.FULL]
   if (!r.test(version)) {
     return null
   }
@@ -31548,7 +31597,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 ? safeRe[t.LOOSE] : safeRe[t.FULL])
 
   if (!m) {
     throw new TypeError('Invalid Version: ' + version)
@@ -31993,6 +32042,7 @@ function Comparator (comp, options) {
     return new Comparator(comp, options)
   }
 
+  comp = comp.trim().split(/\s+/).join(' ')
   debug('comparator', comp, options)
   this.options = options
   this.loose = !!options.loose
@@ -32009,7 +32059,7 @@ 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 ? safeRe[t.COMPARATORLOOSE] : safeRe[t.COMPARATOR]
   var m = comp.match(r)
 
   if (!m) {
@@ -32041,7 +32091,11 @@ Comparator.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
+    }
   }
 
   return cmp(version, this.operator, this.semver, this.options)
@@ -32129,9 +32183,16 @@ function Range (range, options) {
   this.loose = !!options.loose
   this.includePrerelease = !!options.includePrerelease
 
-  // First, split based on boolean or ||
+  // First reduce all whitespace as much as possible so we do not have to rely
+  // on potentially slow regexes like \s*. This is then stored and used for
+  // future error messages as well.
   this.raw = range
-  this.set = range.split(/\s*\|\|\s*/).map(function (range) {
+    .trim()
+    .split(/\s+/)
+    .join(' ')
+
+  // First, split based on boolean or ||
+  this.set = this.raw.split('||').map(function (range) {
     return this.parseRange(range.trim())
   }, this).filter(function (c) {
     // throw out any that are not relevant for whatever reason
@@ -32139,7 +32200,7 @@ function Range (range, options) {
   })
 
   if (!this.set.length) {
-    throw new TypeError('Invalid SemVer Range: ' + range)
+    throw new TypeError('Invalid SemVer Range: ' + this.raw)
   }
 
   this.format()
@@ -32158,20 +32219,19 @@ Range.prototype.toString = function () {
 
 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 ? safeRe[t.HYPHENRANGELOOSE] : safeRe[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(safeRe[t.COMPARATORTRIM], comparatorTrimReplace)
+  debug('comparator trim', range, safeRe[t.COMPARATORTRIM])
 
   // `~ 1.2.3` => `~1.2.3`
-  range = range.replace(re[TILDETRIM], tildeTrimReplace)
+  range = range.replace(safeRe[t.TILDETRIM], tildeTrimReplace)
 
   // `^ 1.2.3` => `^1.2.3`
-  range = range.replace(re[CARETTRIM], caretTrimReplace)
+  range = range.replace(safeRe[t.CARETTRIM], caretTrimReplace)
 
   // normalize spaces
   range = range.split(/\s+/).join(' ')
@@ -32179,7 +32239,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 ? safeRe[t.COMPARATORLOOSE] : safeRe[t.COMPARATOR]
   var set = range.split(' ').map(function (comp) {
     return parseComparator(comp, this.options)
   }, this).join(' ').split(/\s+/)
@@ -32279,7 +32339,7 @@ function replaceTildes (comp, options) {
 }
 
 function replaceTilde (comp, options) {
-  var r = options.loose ? re[TILDELOOSE] : re[TILDE]
+  var r = options.loose ? safeRe[t.TILDELOOSE] : safeRe[t.TILDE]
   return comp.replace(r, function (_, M, m, p, pr) {
     debug('tilde', comp, _, M, m, p, pr)
     var ret
@@ -32320,7 +32380,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 ? safeRe[t.CARETLOOSE] : safeRe[t.CARET]
   return comp.replace(r, function (_, M, m, p, pr) {
     debug('caret', comp, _, M, m, p, pr)
     var ret
@@ -32379,7 +32439,7 @@ function replaceXRanges (comp, options) {
 
 function replaceXRange (comp, options) {
   comp = comp.trim()
-  var r = options.loose ? re[XRANGELOOSE] : re[XRANGE]
+  var r = options.loose ? safeRe[t.XRANGELOOSE] : safeRe[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)
@@ -32391,10 +32451,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 = '*'
@@ -32431,11 +32495,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)
@@ -32449,10 +32514,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(safeRe[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
@@ -32492,7 +32557,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++) {
@@ -32759,25 +32828,55 @@ function coerce (version, options) {
     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(safeRe[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 = safeRe[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
+      }
+      safeRe[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length
+    }
+    // leave it in a clean state
+    safeRe[t.COERCERTL].lastIndex = -1
+  }
+
+  if (match === null) {
     return null
   }
 
-  return parse(match[1] +
-    '.' + (match[2] || '0') +
-    '.' + (match[3] || '0'), options)
+  return parse(match[2] +
+    '.' + (match[3] || '0') +
+    '.' + (match[4] || '0'), options)
 }
 
 
 /***/ }),
 
-/***/ 2816:
+/***/ 9449:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 const ANY = Symbol('SemVer ANY')
@@ -32798,6 +32897,7 @@ class Comparator {
       }
     }
 
+    comp = comp.trim().split(/\s+/).join(' ')
     debug('comparator', comp, options)
     this.options = options
     this.loose = !!options.loose
@@ -32860,13 +32960,6 @@ class Comparator {
       throw new TypeError('a Comparator is required')
     }
 
-    if (!options || typeof options !== 'object') {
-      options = {
-        loose: !!options,
-        includePrerelease: false,
-      }
-    }
-
     if (this.operator === '') {
       if (this.value === '') {
         return true
@@ -32879,48 +32972,59 @@ class Comparator {
       return new Range(this.value, options).test(comp.semver)
     }
 
-    const sameDirectionIncreasing =
-      (this.operator === '>=' || this.operator === '>') &&
-      (comp.operator === '>=' || comp.operator === '>')
-    const sameDirectionDecreasing =
-      (this.operator === '<=' || this.operator === '<') &&
-      (comp.operator === '<=' || comp.operator === '<')
-    const sameSemVer = this.semver.version === comp.semver.version
-    const differentDirectionsInclusive =
-      (this.operator === '>=' || this.operator === '<=') &&
-      (comp.operator === '>=' || comp.operator === '<=')
-    const oppositeDirectionsLessThan =
-      cmp(this.semver, '<', comp.semver, options) &&
-      (this.operator === '>=' || this.operator === '>') &&
-        (comp.operator === '<=' || comp.operator === '<')
-    const oppositeDirectionsGreaterThan =
-      cmp(this.semver, '>', comp.semver, options) &&
-      (this.operator === '<=' || this.operator === '<') &&
-        (comp.operator === '>=' || comp.operator === '>')
+    options = parseOptions(options)
 
-    return (
-      sameDirectionIncreasing ||
-      sameDirectionDecreasing ||
-      (sameSemVer && differentDirectionsInclusive) ||
-      oppositeDirectionsLessThan ||
-      oppositeDirectionsGreaterThan
-    )
+    // Special cases where nothing can possibly be lower
+    if (options.includePrerelease &&
+      (this.value === '<0.0.0-0' || comp.value === '<0.0.0-0')) {
+      return false
+    }
+    if (!options.includePrerelease &&
+      (this.value.startsWith('<0.0.0') || comp.value.startsWith('<0.0.0'))) {
+      return false
+    }
+
+    // Same direction increasing (> or >=)
+    if (this.operator.startsWith('>') && comp.operator.startsWith('>')) {
+      return true
+    }
+    // Same direction decreasing (< or <=)
+    if (this.operator.startsWith('<') && comp.operator.startsWith('<')) {
+      return true
+    }
+    // same SemVer and both sides are inclusive (<= or >=)
+    if (
+      (this.semver.version === comp.semver.version) &&
+      this.operator.includes('=') && comp.operator.includes('=')) {
+      return true
+    }
+    // opposite directions less than
+    if (cmp(this.semver, '<', comp.semver, options) &&
+      this.operator.startsWith('>') && comp.operator.startsWith('<')) {
+      return true
+    }
+    // opposite directions greater than
+    if (cmp(this.semver, '>', comp.semver, options) &&
+      this.operator.startsWith('<') && comp.operator.startsWith('>')) {
+      return true
+    }
+    return false
   }
 }
 
 module.exports = Comparator
 
-const parseOptions = __webpack_require__(3858)
-const { re, t } = __webpack_require__(1411)
-const cmp = __webpack_require__(1606)
-const debug = __webpack_require__(7202)
-const SemVer = __webpack_require__(6971)
-const Range = __webpack_require__(5872)
+const parseOptions = __webpack_require__(8166)
+const { safeRe: re, t } = __webpack_require__(2298)
+const cmp = __webpack_require__(6696)
+const debug = __webpack_require__(107)
+const SemVer = __webpack_require__(7234)
+const Range = __webpack_require__(2486)
 
 
 /***/ }),
 
-/***/ 5872:
+/***/ 2486:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 // hoisted class for cyclic dependency
@@ -32951,19 +33055,26 @@ class Range {
     this.loose = !!options.loose
     this.includePrerelease = !!options.includePrerelease
 
-    // First, split based on boolean or ||
+    // First reduce all whitespace as much as possible so we do not have to rely
+    // on potentially slow regexes like \s*. This is then stored and used for
+    // future error messages as well.
     this.raw = range
-    this.set = range
+      .trim()
+      .split(/\s+/)
+      .join(' ')
+
+    // First, split on ||
+    this.set = this.raw
       .split('||')
       // map the range to a 2d array of comparators
-      .map(r => this.parseRange(r.trim()))
+      .map(r => this.parseRange(r))
       // throw out any comparator lists that are empty
       // this generally means that it was not a valid range, which is allowed
       // in loose mode, but will still throw if the WHOLE range is invalid.
       .filter(c => c.length)
 
     if (!this.set.length) {
-      throw new TypeError(`Invalid SemVer Range: ${range}`)
+      throw new TypeError(`Invalid SemVer Range: ${this.raw}`)
     }
 
     // if we have any that are not the null set, throw out null sets.
@@ -32989,9 +33100,7 @@ class Range {
 
   format () {
     this.range = this.set
-      .map((comps) => {
-        return comps.join(' ').trim()
-      })
+      .map((comps) => comps.join(' ').trim())
       .join('||')
       .trim()
     return this.range
@@ -33002,12 +33111,12 @@ class Range {
   }
 
   parseRange (range) {
-    range = range.trim()
-
     // memoize range parsing for performance.
     // this is a very hot path, and fully deterministic.
-    const memoOpts = Object.keys(this.options).join(',')
-    const memoKey = `parseRange:${memoOpts}:${range}`
+    const memoOpts =
+      (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) |
+      (this.options.loose && FLAG_LOOSE)
+    const memoKey = memoOpts + ':' + range
     const cached = cache.get(memoKey)
     if (cached) {
       return cached
@@ -33028,9 +33137,6 @@ class Range {
     // `^ 1.2.3` => `^1.2.3`
     range = range.replace(re[t.CARETTRIM], caretTrimReplace)
 
-    // normalize spaces
-    range = range.split(/\s+/).join(' ')
-
     // At this point, the range is completely trimmed and
     // ready to be split into comparators.
 
@@ -33115,22 +33221,24 @@ class Range {
     return false
   }
 }
+
 module.exports = Range
 
 const LRU = __webpack_require__(6472)
 const cache = new LRU({ max: 1000 })
 
-const parseOptions = __webpack_require__(3858)
-const Comparator = __webpack_require__(2816)
-const debug = __webpack_require__(7202)
-const SemVer = __webpack_require__(6971)
+const parseOptions = __webpack_require__(8166)
+const Comparator = __webpack_require__(9449)
+const debug = __webpack_require__(107)
+const SemVer = __webpack_require__(7234)
 const {
-  re,
+  safeRe: re,
   t,
   comparatorTrimReplace,
   tildeTrimReplace,
   caretTrimReplace,
-} = __webpack_require__(1411)
+} = __webpack_require__(2298)
+const { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = __webpack_require__(8925)
 
 const isNullSet = c => c.value === '<0.0.0-0'
 const isAny = c => c.value === ''
@@ -33178,10 +33286,13 @@ const isX = id => !id || id.toLowerCase() === 'x' || id === '*'
 // ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0
 // ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0
 // ~0.0.1 --> >=0.0.1 <0.1.0-0
-const replaceTildes = (comp, options) =>
-  comp.trim().split(/\s+/).map((c) => {
-    return replaceTilde(c, options)
-  }).join(' ')
+const replaceTildes = (comp, options) => {
+  return comp
+    .trim()
+    .split(/\s+/)
+    .map((c) => replaceTilde(c, options))
+    .join(' ')
+}
 
 const replaceTilde = (comp, options) => {
   const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE]
@@ -33219,10 +33330,13 @@ const replaceTilde = (comp, options) => {
 // ^1.2.0 --> >=1.2.0 <2.0.0-0
 // ^0.0.1 --> >=0.0.1 <0.0.2-0
 // ^0.1.0 --> >=0.1.0 <0.2.0-0
-const replaceCarets = (comp, options) =>
-  comp.trim().split(/\s+/).map((c) => {
-    return replaceCaret(c, options)
-  }).join(' ')
+const replaceCarets = (comp, options) => {
+  return comp
+    .trim()
+    .split(/\s+/)
+    .map((c) => replaceCaret(c, options))
+    .join(' ')
+}
 
 const replaceCaret = (comp, options) => {
   debug('caret', comp, options)
@@ -33279,9 +33393,10 @@ const replaceCaret = (comp, options) => {
 
 const replaceXRanges = (comp, options) => {
   debug('replaceXRanges', comp, options)
-  return comp.split(/\s+/).map((c) => {
-    return replaceXRange(c, options)
-  }).join(' ')
+  return comp
+    .split(/\s+/)
+    .map((c) => replaceXRange(c, options))
+    .join(' ')
 }
 
 const replaceXRange = (comp, options) => {
@@ -33364,12 +33479,15 @@ const replaceXRange = (comp, options) => {
 const replaceStars = (comp, options) => {
   debug('replaceStars', comp, options)
   // Looseness is ignored here.  star is always as loose as it gets!
-  return comp.trim().replace(re[t.STAR], '')
+  return comp
+    .trim()
+    .replace(re[t.STAR], '')
 }
 
 const replaceGTE0 = (comp, options) => {
   debug('replaceGTE0', comp, options)
-  return comp.trim()
+  return comp
+    .trim()
     .replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], '')
 }
 
@@ -33407,7 +33525,7 @@ const hyphenReplace = incPr => ($0,
     to = `<=${to}`
   }
 
-  return (`${from} ${to}`).trim()
+  return `${from} ${to}`.trim()
 }
 
 const testSet = (set, version, options) => {
@@ -33449,15 +33567,15 @@ const testSet = (set, version, options) => {
 
 /***/ }),
 
-/***/ 6971:
+/***/ 7234:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const debug = __webpack_require__(7202)
-const { MAX_LENGTH, MAX_SAFE_INTEGER } = __webpack_require__(8241)
-const { re, t } = __webpack_require__(1411)
+const debug = __webpack_require__(107)
+const { MAX_LENGTH, MAX_SAFE_INTEGER } = __webpack_require__(8925)
+const { safeRe: re, t } = __webpack_require__(2298)
 
-const parseOptions = __webpack_require__(3858)
-const { compareIdentifiers } = __webpack_require__(4974)
+const parseOptions = __webpack_require__(8166)
+const { compareIdentifiers } = __webpack_require__(1680)
 class SemVer {
   constructor (version, options) {
     options = parseOptions(options)
@@ -33470,7 +33588,7 @@ class SemVer {
         version = version.version
       }
     } else if (typeof version !== 'string') {
-      throw new TypeError(`Invalid Version: ${version}`)
+      throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`)
     }
 
     if (version.length > MAX_LENGTH) {
@@ -33629,36 +33747,36 @@ class SemVer {
 
   // preminor will bump the version up to the next minor release, and immediately
   // down to pre-release. premajor and prepatch work the same way.
-  inc (release, identifier) {
+  inc (release, identifier, identifierBase) {
     switch (release) {
       case 'premajor':
         this.prerelease.length = 0
         this.patch = 0
         this.minor = 0
         this.major++
-        this.inc('pre', identifier)
+        this.inc('pre', identifier, identifierBase)
         break
       case 'preminor':
         this.prerelease.length = 0
         this.patch = 0
         this.minor++
-        this.inc('pre', identifier)
+        this.inc('pre', identifier, identifierBase)
         break
       case 'prepatch':
         // If this is already a prerelease, it will bump to the next version
         // drop any prereleases that might already exist, since they are not
         // relevant at this point.
         this.prerelease.length = 0
-        this.inc('patch', identifier)
-        this.inc('pre', identifier)
+        this.inc('patch', identifier, identifierBase)
+        this.inc('pre', identifier, identifierBase)
         break
       // If the input is a non-prerelease version, this acts the same as
       // prepatch.
       case 'prerelease':
         if (this.prerelease.length === 0) {
-          this.inc('patch', identifier)
+          this.inc('patch', identifier, identifierBase)
         }
-        this.inc('pre', identifier)
+        this.inc('pre', identifier, identifierBase)
         break
 
       case 'major':
@@ -33700,9 +33818,15 @@ class SemVer {
         break
       // This probably shouldn't be used publicly.
       // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
-      case 'pre':
+      case 'pre': {
+        const base = Number(identifierBase) ? 1 : 0
+
+        if (!identifier && identifierBase === false) {
+          throw new Error('invalid increment argument: identifier is empty')
+        }
+
         if (this.prerelease.length === 0) {
-          this.prerelease = [0]
+          this.prerelease = [base]
         } else {
           let i = this.prerelease.length
           while (--i >= 0) {
@@ -33713,27 +33837,36 @@ class SemVer {
           }
           if (i === -1) {
             // didn't increment anything
-            this.prerelease.push(0)
+            if (identifier === this.prerelease.join('.') && identifierBase === false) {
+              throw new Error('invalid increment argument: identifier already exists')
+            }
+            this.prerelease.push(base)
           }
         }
         if (identifier) {
           // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
           // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
+          let prerelease = [identifier, base]
+          if (identifierBase === false) {
+            prerelease = [identifier]
+          }
           if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
             if (isNaN(this.prerelease[1])) {
-              this.prerelease = [identifier, 0]
+              this.prerelease = prerelease
             }
           } else {
-            this.prerelease = [identifier, 0]
+            this.prerelease = prerelease
           }
         }
         break
-
+      }
       default:
         throw new Error(`invalid increment argument: ${release}`)
     }
-    this.format()
-    this.raw = this.version
+    this.raw = this.format()
+    if (this.build.length) {
+      this.raw += `+${this.build.join('.')}`
+    }
     return this
   }
 }
@@ -33743,10 +33876,10 @@ module.exports = SemVer
 
 /***/ }),
 
-/***/ 7322:
+/***/ 3996:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const parse = __webpack_require__(1133)
+const parse = __webpack_require__(8606)
 const clean = (version, options) => {
   const s = parse(version.trim().replace(/^[=v]+/, ''), options)
   return s ? s.version : null
@@ -33756,15 +33889,15 @@ module.exports = clean
 
 /***/ }),
 
-/***/ 1606:
+/***/ 6696:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const eq = __webpack_require__(1801)
-const neq = __webpack_require__(8432)
-const gt = __webpack_require__(858)
-const gte = __webpack_require__(3013)
-const lt = __webpack_require__(6286)
-const lte = __webpack_require__(1837)
+const eq = __webpack_require__(625)
+const neq = __webpack_require__(3325)
+const gt = __webpack_require__(3370)
+const gte = __webpack_require__(8622)
+const lt = __webpack_require__(6071)
+const lte = __webpack_require__(7696)
 
 const cmp = (a, op, b, loose) => {
   switch (op) {
@@ -33815,12 +33948,12 @@ module.exports = cmp
 
 /***/ }),
 
-/***/ 9106:
+/***/ 2509:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const SemVer = __webpack_require__(6971)
-const parse = __webpack_require__(1133)
-const { re, t } = __webpack_require__(1411)
+const SemVer = __webpack_require__(7234)
+const parse = __webpack_require__(8606)
+const { safeRe: re, t } = __webpack_require__(2298)
 
 const coerce = (version, options) => {
   if (version instanceof SemVer) {
@@ -33874,10 +34007,10 @@ module.exports = coerce
 
 /***/ }),
 
-/***/ 1921:
+/***/ 1058:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const SemVer = __webpack_require__(6971)
+const SemVer = __webpack_require__(7234)
 const compareBuild = (a, b, loose) => {
   const versionA = new SemVer(a, loose)
   const versionB = new SemVer(b, loose)
@@ -33888,20 +34021,20 @@ module.exports = compareBuild
 
 /***/ }),
 
-/***/ 26:
+/***/ 4271:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const compare = __webpack_require__(2533)
+const compare = __webpack_require__(9603)
 const compareLoose = (a, b) => compare(a, b, true)
 module.exports = compareLoose
 
 
 /***/ }),
 
-/***/ 2533:
+/***/ 9603:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const SemVer = __webpack_require__(6971)
+const SemVer = __webpack_require__(7234)
 const compare = (a, b, loose) =>
   new SemVer(a, loose).compare(new SemVer(b, loose))
 
@@ -33910,73 +34043,116 @@ module.exports = compare
 
 /***/ }),
 
-/***/ 9793:
+/***/ 1937:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const parse = __webpack_require__(1133)
-const eq = __webpack_require__(1801)
+const parse = __webpack_require__(8606)
 
 const diff = (version1, version2) => {
-  if (eq(version1, version2)) {
+  const v1 = parse(version1, null, true)
+  const v2 = parse(version2, null, true)
+  const comparison = v1.compare(v2)
+
+  if (comparison === 0) {
     return null
-  } else {
-    const v1 = parse(version1)
-    const v2 = parse(version2)
-    const hasPre = v1.prerelease.length || v2.prerelease.length
-    const prefix = hasPre ? 'pre' : ''
-    const defaultResult = hasPre ? 'prerelease' : ''
-    for (const key in v1) {
-      if (key === 'major' || key === 'minor' || key === 'patch') {
-        if (v1[key] !== v2[key]) {
-          return prefix + key
-        }
-      }
+  }
+
+  const v1Higher = comparison > 0
+  const highVersion = v1Higher ? v1 : v2
+  const lowVersion = v1Higher ? v2 : v1
+  const highHasPre = !!highVersion.prerelease.length
+  const lowHasPre = !!lowVersion.prerelease.length
+
+  if (lowHasPre && !highHasPre) {
+    // Going from prerelease -> no prerelease requires some special casing
+
+    // If the low version has only a major, then it will always be a major
+    // Some examples:
+    // 1.0.0-1 -> 1.0.0
+    // 1.0.0-1 -> 1.1.1
+    // 1.0.0-1 -> 2.0.0
+    if (!lowVersion.patch && !lowVersion.minor) {
+      return 'major'
     }
-    return defaultResult // may be undefined
+
+    // Otherwise it can be determined by checking the high version
+
+    if (highVersion.patch) {
+      // anything higher than a patch bump would result in the wrong version
+      return 'patch'
+    }
+
+    if (highVersion.minor) {
+      // anything higher than a minor bump would result in the wrong version
+      return 'minor'
+    }
+
+    // bumping major/minor/patch all have same result
+    return 'major'
   }
+
+  // add the `pre` prefix if we are going to a prerelease version
+  const prefix = highHasPre ? 'pre' : ''
+
+  if (v1.major !== v2.major) {
+    return prefix + 'major'
+  }
+
+  if (v1.minor !== v2.minor) {
+    return prefix + 'minor'
+  }
+
+  if (v1.patch !== v2.patch) {
+    return prefix + 'patch'
+  }
+
+  // high and low are preleases
+  return 'prerelease'
 }
+
 module.exports = diff
 
 
 /***/ }),
 
-/***/ 1801:
+/***/ 625:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const compare = __webpack_require__(2533)
+const compare = __webpack_require__(9603)
 const eq = (a, b, loose) => compare(a, b, loose) === 0
 module.exports = eq
 
 
 /***/ }),
 
-/***/ 858:
+/***/ 3370:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const compare = __webpack_require__(2533)
+const compare = __webpack_require__(9603)
 const gt = (a, b, loose) => compare(a, b, loose) > 0
 module.exports = gt
 
 
 /***/ }),
 
-/***/ 3013:
+/***/ 8622:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const compare = __webpack_require__(2533)
+const compare = __webpack_require__(9603)
 const gte = (a, b, loose) => compare(a, b, loose) >= 0
 module.exports = gte
 
 
 /***/ }),
 
-/***/ 8851:
+/***/ 6096:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const SemVer = __webpack_require__(6971)
+const SemVer = __webpack_require__(7234)
 
-const inc = (version, release, options, identifier) => {
+const inc = (version, release, options, identifier, identifierBase) => {
   if (typeof (options) === 'string') {
+    identifierBase = identifier
     identifier = options
     options = undefined
   }
@@ -33985,7 +34161,7 @@ const inc = (version, release, options, identifier) => {
     return new SemVer(
       version instanceof SemVer ? version.version : version,
       options
-    ).inc(release, identifier).version
+    ).inc(release, identifier, identifierBase).version
   } catch (er) {
     return null
   }
@@ -33995,88 +34171,71 @@ module.exports = inc
 
 /***/ }),
 
-/***/ 6286:
+/***/ 6071:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const compare = __webpack_require__(2533)
+const compare = __webpack_require__(9603)
 const lt = (a, b, loose) => compare(a, b, loose) < 0
 module.exports = lt
 
 
 /***/ }),
 
-/***/ 1837:
+/***/ 7696:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const compare = __webpack_require__(2533)
+const compare = __webpack_require__(9603)
 const lte = (a, b, loose) => compare(a, b, loose) <= 0
 module.exports = lte
 
 
 /***/ }),
 
-/***/ 1985:
+/***/ 9227:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const SemVer = __webpack_require__(6971)
+const SemVer = __webpack_require__(7234)
 const major = (a, loose) => new SemVer(a, loose).major
 module.exports = major
 
 
 /***/ }),
 
-/***/ 5153:
+/***/ 706:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const SemVer = __webpack_require__(6971)
+const SemVer = __webpack_require__(7234)
 const minor = (a, loose) => new SemVer(a, loose).minor
 module.exports = minor
 
 
 /***/ }),
 
-/***/ 8432:
+/***/ 3325:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const compare = __webpack_require__(2533)
+const compare = __webpack_require__(9603)
 const neq = (a, b, loose) => compare(a, b, loose) !== 0
 module.exports = neq
 
 
 /***/ }),
 
-/***/ 1133:
+/***/ 8606:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const { MAX_LENGTH } = __webpack_require__(8241)
-const { re, t } = __webpack_require__(1411)
-const SemVer = __webpack_require__(6971)
-
-const parseOptions = __webpack_require__(3858)
-const parse = (version, options) => {
-  options = parseOptions(options)
-
+const SemVer = __webpack_require__(7234)
+const parse = (version, options, throwErrors = false) => {
   if (version instanceof SemVer) {
     return version
   }
-
-  if (typeof version !== 'string') {
-    return null
-  }
-
-  if (version.length > MAX_LENGTH) {
-    return null
-  }
-
-  const r = options.loose ? re[t.LOOSE] : re[t.FULL]
-  if (!r.test(version)) {
-    return null
-  }
-
   try {
     return new SemVer(version, options)
   } catch (er) {
-    return null
+    if (!throwErrors) {
+      return null
+    }
+    throw er
   }
 }
 
@@ -34085,20 +34244,20 @@ module.exports = parse
 
 /***/ }),
 
-/***/ 4990:
+/***/ 9770:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const SemVer = __webpack_require__(6971)
+const SemVer = __webpack_require__(7234)
 const patch = (a, loose) => new SemVer(a, loose).patch
 module.exports = patch
 
 
 /***/ }),
 
-/***/ 9995:
+/***/ 9166:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const parse = __webpack_require__(1133)
+const parse = __webpack_require__(8606)
 const prerelease = (version, options) => {
   const parsed = parse(version, options)
   return (parsed && parsed.prerelease.length) ? parsed.prerelease : null
@@ -34108,30 +34267,30 @@ module.exports = prerelease
 
 /***/ }),
 
-/***/ 3355:
+/***/ 9773:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const compare = __webpack_require__(2533)
+const compare = __webpack_require__(9603)
 const rcompare = (a, b, loose) => compare(b, a, loose)
 module.exports = rcompare
 
 
 /***/ }),
 
-/***/ 7402:
+/***/ 158:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const compareBuild = __webpack_require__(1921)
+const compareBuild = __webpack_require__(1058)
 const rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose))
 module.exports = rsort
 
 
 /***/ }),
 
-/***/ 319:
+/***/ 3513:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const Range = __webpack_require__(5872)
+const Range = __webpack_require__(2486)
 const satisfies = (version, range, options) => {
   try {
     range = new Range(range, options)
@@ -34145,20 +34304,20 @@ module.exports = satisfies
 
 /***/ }),
 
-/***/ 5627:
+/***/ 5247:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const compareBuild = __webpack_require__(1921)
+const compareBuild = __webpack_require__(1058)
 const sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose))
 module.exports = sort
 
 
 /***/ }),
 
-/***/ 8731:
+/***/ 1294:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const parse = __webpack_require__(1133)
+const parse = __webpack_require__(8606)
 const valid = (version, options) => {
   const v = parse(version, options)
   return v ? v.version : null
@@ -34168,51 +34327,51 @@ module.exports = valid
 
 /***/ }),
 
-/***/ 7013:
+/***/ 6377:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 // just pre-load all the stuff that index.js lazily exports
-const internalRe = __webpack_require__(1411)
-const constants = __webpack_require__(8241)
-const SemVer = __webpack_require__(6971)
-const identifiers = __webpack_require__(4974)
-const parse = __webpack_require__(1133)
-const valid = __webpack_require__(8731)
-const clean = __webpack_require__(7322)
-const inc = __webpack_require__(8851)
-const diff = __webpack_require__(9793)
-const major = __webpack_require__(1985)
-const minor = __webpack_require__(5153)
-const patch = __webpack_require__(4990)
-const prerelease = __webpack_require__(9995)
-const compare = __webpack_require__(2533)
-const rcompare = __webpack_require__(3355)
-const compareLoose = __webpack_require__(26)
-const compareBuild = __webpack_require__(1921)
-const sort = __webpack_require__(5627)
-const rsort = __webpack_require__(7402)
-const gt = __webpack_require__(858)
-const lt = __webpack_require__(6286)
-const eq = __webpack_require__(1801)
-const neq = __webpack_require__(8432)
-const gte = __webpack_require__(3013)
-const lte = __webpack_require__(1837)
-const cmp = __webpack_require__(1606)
-const coerce = __webpack_require__(9106)
-const Comparator = __webpack_require__(2816)
-const Range = __webpack_require__(5872)
-const satisfies = __webpack_require__(319)
-const toComparators = __webpack_require__(2025)
-const maxSatisfying = __webpack_require__(469)
-const minSatisfying = __webpack_require__(4101)
-const minVersion = __webpack_require__(4452)
-const validRange = __webpack_require__(6747)
-const outside = __webpack_require__(9054)
-const gtr = __webpack_require__(4369)
-const ltr = __webpack_require__(5595)
-const intersects = __webpack_require__(6330)
-const simplifyRange = __webpack_require__(6849)
-const subset = __webpack_require__(5640)
+const internalRe = __webpack_require__(2298)
+const constants = __webpack_require__(8925)
+const SemVer = __webpack_require__(7234)
+const identifiers = __webpack_require__(1680)
+const parse = __webpack_require__(8606)
+const valid = __webpack_require__(1294)
+const clean = __webpack_require__(3996)
+const inc = __webpack_require__(6096)
+const diff = __webpack_require__(1937)
+const major = __webpack_require__(9227)
+const minor = __webpack_require__(706)
+const patch = __webpack_require__(9770)
+const prerelease = __webpack_require__(9166)
+const compare = __webpack_require__(9603)
+const rcompare = __webpack_require__(9773)
+const compareLoose = __webpack_require__(4271)
+const compareBuild = __webpack_require__(1058)
+const sort = __webpack_require__(5247)
+const rsort = __webpack_require__(158)
+const gt = __webpack_require__(3370)
+const lt = __webpack_require__(6071)
+const eq = __webpack_require__(625)
+const neq = __webpack_require__(3325)
+const gte = __webpack_require__(8622)
+const lte = __webpack_require__(7696)
+const cmp = __webpack_require__(6696)
+const coerce = __webpack_require__(2509)
+const Comparator = __webpack_require__(9449)
+const Range = __webpack_require__(2486)
+const satisfies = __webpack_require__(3513)
+const toComparators = __webpack_require__(1046)
+const maxSatisfying = __webpack_require__(2649)
+const minSatisfying = __webpack_require__(40)
+const minVersion = __webpack_require__(6077)
+const validRange = __webpack_require__(8218)
+const outside = __webpack_require__(4005)
+const gtr = __webpack_require__(6565)
+const ltr = __webpack_require__(38)
+const intersects = __webpack_require__(3024)
+const simplifyRange = __webpack_require__(9115)
+const subset = __webpack_require__(2544)
 module.exports = {
   parse,
   valid,
@@ -34256,6 +34415,7 @@ module.exports = {
   src: internalRe.src,
   tokens: internalRe.t,
   SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
+  RELEASE_TYPES: constants.RELEASE_TYPES,
   compareIdentifiers: identifiers.compareIdentifiers,
   rcompareIdentifiers: identifiers.rcompareIdentifiers,
 }
@@ -34263,7 +34423,7 @@ module.exports = {
 
 /***/ }),
 
-/***/ 8241:
+/***/ 8925:
 /***/ ((module) => {
 
 // Note: this is the semver.org version of the spec that it implements
@@ -34277,17 +34437,30 @@ const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||
 // Max safe segment length for coercion.
 const MAX_SAFE_COMPONENT_LENGTH = 16
 
+const RELEASE_TYPES = [
+  'major',
+  'premajor',
+  'minor',
+  'preminor',
+  'patch',
+  'prepatch',
+  'prerelease',
+]
+
 module.exports = {
-  SEMVER_SPEC_VERSION,
   MAX_LENGTH,
-  MAX_SAFE_INTEGER,
   MAX_SAFE_COMPONENT_LENGTH,
+  MAX_SAFE_INTEGER,
+  RELEASE_TYPES,
+  SEMVER_SPEC_VERSION,
+  FLAG_INCLUDE_PRERELEASE: 0b001,
+  FLAG_LOOSE: 0b010,
 }
 
 
 /***/ }),
 
-/***/ 7202:
+/***/ 107:
 /***/ ((module) => {
 
 const debug = (
@@ -34303,7 +34476,7 @@ module.exports = debug
 
 /***/ }),
 
-/***/ 4974:
+/***/ 1680:
 /***/ ((module) => {
 
 const numeric = /^[0-9]+$/
@@ -34333,43 +34506,58 @@ module.exports = {
 
 /***/ }),
 
-/***/ 3858:
+/***/ 8166:
 /***/ ((module) => {
 
-// parse out just the options we care about so we always get a consistent
-// obj with keys in a consistent order.
-const opts = ['includePrerelease', 'loose', 'rtl']
-const parseOptions = options =>
-  !options ? {}
-  : typeof options !== 'object' ? { loose: true }
-  : opts.filter(k => options[k]).reduce((o, k) => {
-    o[k] = true
-    return o
-  }, {})
+// parse out just the options we care about
+const looseOption = Object.freeze({ loose: true })
+const emptyOpts = Object.freeze({ })
+const parseOptions = options => {
+  if (!options) {
+    return emptyOpts
+  }
+
+  if (typeof options !== 'object') {
+    return looseOption
+  }
+
+  return options
+}
 module.exports = parseOptions
 
 
 /***/ }),
 
-/***/ 1411:
+/***/ 2298:
 /***/ ((module, exports, __webpack_require__) => {
 
-const { MAX_SAFE_COMPONENT_LENGTH } = __webpack_require__(8241)
-const debug = __webpack_require__(7202)
+const { MAX_SAFE_COMPONENT_LENGTH } = __webpack_require__(8925)
+const debug = __webpack_require__(107)
 exports = module.exports = {}
 
 // The actual regexps go on exports.re
 const re = exports.re = []
+const safeRe = exports.safeRe = []
 const src = exports.src = []
 const t = exports.t = {}
 let R = 0
 
 const createToken = (name, value, isGlobal) => {
+  // Replace all greedy whitespace to prevent regex dos issues. These regex are
+  // used internally via the safeRe object since all inputs in this library get
+  // normalized first to trim and collapse all extra whitespace. The original
+  // regexes are exported for userland consumption and lower level usage. A
+  // future breaking change could export the safer regex only with a note that
+  // all input should have extra whitespace removed.
+  const safe = value
+    .split('\\s*').join('\\s{0,1}')
+    .split('\\s+').join('\\s')
   const index = R++
   debug(name, index, value)
   t[name] = index
   src[index] = value
   re[index] = new RegExp(value, isGlobal ? 'g' : undefined)
+  safeRe[index] = new RegExp(safe, isGlobal ? 'g' : undefined)
 }
 
 // The following Regular Expressions can be used for tokenizing,
@@ -34540,35 +34728,35 @@ createToken('GTE0PRE', '^\\s*>=\\s*0\\.0\\.0-0\\s*$')
 
 /***/ }),
 
-/***/ 4369:
+/***/ 6565:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 // Determine if version is greater than all the versions possible in the range.
-const outside = __webpack_require__(9054)
+const outside = __webpack_require__(4005)
 const gtr = (version, range, options) => outside(version, range, '>', options)
 module.exports = gtr
 
 
 /***/ }),
 
-/***/ 6330:
+/***/ 3024:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const Range = __webpack_require__(5872)
+const Range = __webpack_require__(2486)
 const intersects = (r1, r2, options) => {
   r1 = new Range(r1, options)
   r2 = new Range(r2, options)
-  return r1.intersects(r2)
+  return r1.intersects(r2, options)
 }
 module.exports = intersects
 
 
 /***/ }),
 
-/***/ 5595:
+/***/ 38:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const outside = __webpack_require__(9054)
+const outside = __webpack_require__(4005)
 // Determine if version is less than all the versions possible in the range
 const ltr = (version, range, options) => outside(version, range, '<', options)
 module.exports = ltr
@@ -34576,11 +34764,11 @@ module.exports = ltr
 
 /***/ }),
 
-/***/ 469:
+/***/ 2649:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const SemVer = __webpack_require__(6971)
-const Range = __webpack_require__(5872)
+const SemVer = __webpack_require__(7234)
+const Range = __webpack_require__(2486)
 
 const maxSatisfying = (versions, range, options) => {
   let max = null
@@ -34608,11 +34796,11 @@ module.exports = maxSatisfying
 
 /***/ }),
 
-/***/ 4101:
+/***/ 40:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const SemVer = __webpack_require__(6971)
-const Range = __webpack_require__(5872)
+const SemVer = __webpack_require__(7234)
+const Range = __webpack_require__(2486)
 const minSatisfying = (versions, range, options) => {
   let min = null
   let minSV = null
@@ -34639,12 +34827,12 @@ module.exports = minSatisfying
 
 /***/ }),
 
-/***/ 4452:
+/***/ 6077:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const SemVer = __webpack_require__(6971)
-const Range = __webpack_require__(5872)
-const gt = __webpack_require__(858)
+const SemVer = __webpack_require__(7234)
+const Range = __webpack_require__(2486)
+const gt = __webpack_require__(3370)
 
 const minVersion = (range, loose) => {
   range = new Range(range, loose)
@@ -34707,18 +34895,18 @@ module.exports = minVersion
 
 /***/ }),
 
-/***/ 9054:
+/***/ 4005:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const SemVer = __webpack_require__(6971)
-const Comparator = __webpack_require__(2816)
+const SemVer = __webpack_require__(7234)
+const Comparator = __webpack_require__(9449)
 const { ANY } = Comparator
-const Range = __webpack_require__(5872)
-const satisfies = __webpack_require__(319)
-const gt = __webpack_require__(858)
-const lt = __webpack_require__(6286)
-const lte = __webpack_require__(1837)
-const gte = __webpack_require__(3013)
+const Range = __webpack_require__(2486)
+const satisfies = __webpack_require__(3513)
+const gt = __webpack_require__(3370)
+const lt = __webpack_require__(6071)
+const lte = __webpack_require__(7696)
+const gte = __webpack_require__(8622)
 
 const outside = (version, range, hilo, options) => {
   version = new SemVer(version, options)
@@ -34794,14 +34982,14 @@ module.exports = outside
 
 /***/ }),
 
-/***/ 6849:
+/***/ 9115:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 // given a set of versions and a range, create a "simplified" range
 // that includes the same versions that the original range does
 // If the original range is shorter than the simplified one, return that.
-const satisfies = __webpack_require__(319)
-const compare = __webpack_require__(2533)
+const satisfies = __webpack_require__(3513)
+const compare = __webpack_require__(9603)
 module.exports = (versions, range, options) => {
   const set = []
   let first = null
@@ -34848,14 +35036,14 @@ module.exports = (versions, range, options) => {
 
 /***/ }),
 
-/***/ 5640:
+/***/ 2544:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const Range = __webpack_require__(5872)
-const Comparator = __webpack_require__(2816)
+const Range = __webpack_require__(2486)
+const Comparator = __webpack_require__(9449)
 const { ANY } = Comparator
-const satisfies = __webpack_require__(319)
-const compare = __webpack_require__(2533)
+const satisfies = __webpack_require__(3513)
+const compare = __webpack_require__(9603)
 
 // Complex range `r1 || r2 || ...` is a subset of `R1 || R2 || ...` iff:
 // - Every simple range `r1, r2, ...` is a null set, OR
@@ -34921,6 +35109,9 @@ const subset = (sub, dom, options = {}) => {
   return true
 }
 
+const minimumVersionWithPreRelease = [new Comparator('>=0.0.0-0')]
+const minimumVersion = [new Comparator('>=0.0.0')]
+
 const simpleSubset = (sub, dom, options) => {
   if (sub === dom) {
     return true
@@ -34930,9 +35121,9 @@ const simpleSubset = (sub, dom, options) => {
     if (dom.length === 1 && dom[0].semver === ANY) {
       return true
     } else if (options.includePrerelease) {
-      sub = [new Comparator('>=0.0.0-0')]
+      sub = minimumVersionWithPreRelease
     } else {
-      sub = [new Comparator('>=0.0.0')]
+      sub = minimumVersion
     }
   }
 
@@ -34940,7 +35131,7 @@ const simpleSubset = (sub, dom, options) => {
     if (options.includePrerelease) {
       return true
     } else {
-      dom = [new Comparator('>=0.0.0')]
+      dom = minimumVersion
     }
   }
 
@@ -35099,10 +35290,10 @@ module.exports = subset
 
 /***/ }),
 
-/***/ 2025:
+/***/ 1046:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const Range = __webpack_require__(5872)
+const Range = __webpack_require__(2486)
 
 // Mostly just for testing and legacy API reasons
 const toComparators = (range, options) =>
@@ -35114,10 +35305,10 @@ module.exports = toComparators
 
 /***/ }),
 
-/***/ 6747:
+/***/ 8218:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const Range = __webpack_require__(5872)
+const Range = __webpack_require__(2486)
 const validRange = (range, options) => {
   try {
     // Return '*' instead of '' so that truthiness works.
@@ -40261,349 +40452,349 @@ module.exports = "var d=Object.defineProperty;var m=e=>d(e,\"__esModule\",{value
 /***/ }),
 
 /***/ 3097:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 "use strict";
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.collectHasSegments = exports.sourceToRegex = exports.convertTrailingSlash = exports.convertHeaders = exports.convertRewrites = exports.convertRedirects = exports.convertCleanUrls = exports.getCleanUrls = void 0;
-/**
- * This converts Superstatic configuration to vercel.json Routes
- * See https://github.com/firebase/superstatic#configuration
- */
-const url_1 = __webpack_require__(8835);
-const path_to_regexp_1 = __webpack_require__(4462);
-const UN_NAMED_SEGMENT = '__UN_NAMED_SEGMENT__';
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var superstatic_exports = {};
+__export(superstatic_exports, {
+  collectHasSegments: () => collectHasSegments,
+  convertCleanUrls: () => convertCleanUrls,
+  convertHeaders: () => convertHeaders,
+  convertRedirects: () => convertRedirects,
+  convertRewrites: () => convertRewrites,
+  convertTrailingSlash: () => convertTrailingSlash,
+  getCleanUrls: () => getCleanUrls,
+  sourceToRegex: () => sourceToRegex
+});
+module.exports = __toCommonJS(superstatic_exports);
+var import_url = __webpack_require__(8835);
+var import_path_to_regexp = __webpack_require__(4462);
+const UN_NAMED_SEGMENT = "__UN_NAMED_SEGMENT__";
 function getCleanUrls(filePaths) {
-    const htmlFiles = filePaths
-        .map(toRoute)
-        .filter(f => f.endsWith('.html'))
-        .map(f => ({
-        html: f,
-        clean: f.slice(0, -5),
-    }));
-    return htmlFiles;
+  const htmlFiles = filePaths.map(toRoute).filter((f) => f.endsWith(".html")).map((f) => ({
+    html: f,
+    clean: f.slice(0, -5)
+  }));
+  return htmlFiles;
 }
-exports.getCleanUrls = getCleanUrls;
 function convertCleanUrls(cleanUrls, trailingSlash, status = 308) {
-    const routes = [];
-    if (cleanUrls) {
-        const loc = trailingSlash ? '/$1/' : '/$1';
-        routes.push({
-            src: '^/(?:(.+)/)?index(?:\\.html)?/?$',
-            headers: { Location: loc },
-            status,
-        });
-        routes.push({
-            src: '^/(.*)\\.html/?$',
-            headers: { Location: loc },
-            status,
-        });
-    }
-    return routes;
+  const routes = [];
+  if (cleanUrls) {
+    const loc = trailingSlash ? "/$1/" : "/$1";
+    routes.push({
+      src: "^/(?:(.+)/)?index(?:\\.html)?/?$",
+      headers: { Location: loc },
+      status
+    });
+    routes.push({
+      src: "^/(.*)\\.html/?$",
+      headers: { Location: loc },
+      status
+    });
+  }
+  return routes;
 }
-exports.convertCleanUrls = convertCleanUrls;
 function convertRedirects(redirects, defaultStatus = 308) {
-    return redirects.map(r => {
-        const { src, segments } = sourceToRegex(r.source);
-        const hasSegments = collectHasSegments(r.has);
-        normalizeHasKeys(r.has);
-        normalizeHasKeys(r.missing);
-        try {
-            const loc = replaceSegments(segments, hasSegments, r.destination, true);
-            let status;
-            if (typeof r.permanent === 'boolean') {
-                status = r.permanent ? 308 : 307;
-            }
-            else if (r.statusCode) {
-                status = r.statusCode;
-            }
-            else {
-                status = defaultStatus;
-            }
-            const route = {
-                src,
-                headers: { Location: loc },
-                status,
-            };
-            if (r.has) {
-                route.has = r.has;
-            }
-            if (r.missing) {
-                route.missing = r.missing;
-            }
-            return route;
-        }
-        catch (e) {
-            throw new Error(`Failed to parse redirect: ${JSON.stringify(r)}`);
-        }
-    });
+  return redirects.map((r) => {
+    const { src, segments } = sourceToRegex(r.source);
+    const hasSegments = collectHasSegments(r.has);
+    normalizeHasKeys(r.has);
+    normalizeHasKeys(r.missing);
+    try {
+      const loc = replaceSegments(segments, hasSegments, r.destination, true);
+      let status;
+      if (typeof r.permanent === "boolean") {
+        status = r.permanent ? 308 : 307;
+      } else if (r.statusCode) {
+        status = r.statusCode;
+      } else {
+        status = defaultStatus;
+      }
+      const route = {
+        src,
+        headers: { Location: loc },
+        status
+      };
+      if (r.has) {
+        route.has = r.has;
+      }
+      if (r.missing) {
+        route.missing = r.missing;
+      }
+      return route;
+    } catch (e) {
+      throw new Error(`Failed to parse redirect: ${JSON.stringify(r)}`);
+    }
+  });
 }
-exports.convertRedirects = convertRedirects;
 function convertRewrites(rewrites, internalParamNames) {
-    return rewrites.map(r => {
-        const { src, segments } = sourceToRegex(r.source);
-        const hasSegments = collectHasSegments(r.has);
-        normalizeHasKeys(r.has);
-        normalizeHasKeys(r.missing);
-        try {
-            const dest = replaceSegments(segments, hasSegments, r.destination, false, internalParamNames);
-            const route = { src, dest, check: true };
-            if (r.has) {
-                route.has = r.has;
-            }
-            if (r.missing) {
-                route.missing = r.missing;
-            }
-            return route;
-        }
-        catch (e) {
-            throw new Error(`Failed to parse rewrite: ${JSON.stringify(r)}`);
-        }
-    });
+  return rewrites.map((r) => {
+    const { src, segments } = sourceToRegex(r.source);
+    const hasSegments = collectHasSegments(r.has);
+    normalizeHasKeys(r.has);
+    normalizeHasKeys(r.missing);
+    try {
+      const dest = replaceSegments(
+        segments,
+        hasSegments,
+        r.destination,
+        false,
+        internalParamNames
+      );
+      const route = { src, dest, check: true };
+      if (r.has) {
+        route.has = r.has;
+      }
+      if (r.missing) {
+        route.missing = r.missing;
+      }
+      return route;
+    } catch (e) {
+      throw new Error(`Failed to parse rewrite: ${JSON.stringify(r)}`);
+    }
+  });
 }
-exports.convertRewrites = convertRewrites;
 function convertHeaders(headers) {
-    return headers.map(h => {
-        const obj = {};
-        const { src, segments } = sourceToRegex(h.source);
-        const hasSegments = collectHasSegments(h.has);
-        normalizeHasKeys(h.has);
-        normalizeHasKeys(h.missing);
-        const namedSegments = segments.filter(name => name !== UN_NAMED_SEGMENT);
-        const indexes = {};
-        segments.forEach((name, index) => {
-            indexes[name] = toSegmentDest(index);
-        });
-        hasSegments.forEach(name => {
-            indexes[name] = '$' + name;
-        });
-        h.headers.forEach(({ key, value }) => {
-            if (namedSegments.length > 0 || hasSegments.length > 0) {
-                if (key.includes(':')) {
-                    key = safelyCompile(key, indexes);
-                }
-                if (value.includes(':')) {
-                    value = safelyCompile(value, indexes);
-                }
-            }
-            obj[key] = value;
-        });
-        const route = {
-            src,
-            headers: obj,
-            continue: true,
-        };
-        if (h.has) {
-            route.has = h.has;
+  return headers.map((h) => {
+    const obj = {};
+    const { src, segments } = sourceToRegex(h.source);
+    const hasSegments = collectHasSegments(h.has);
+    normalizeHasKeys(h.has);
+    normalizeHasKeys(h.missing);
+    const namedSegments = segments.filter((name) => name !== UN_NAMED_SEGMENT);
+    const indexes = {};
+    segments.forEach((name, index) => {
+      indexes[name] = toSegmentDest(index);
+    });
+    hasSegments.forEach((name) => {
+      indexes[name] = "$" + name;
+    });
+    h.headers.forEach(({ key, value }) => {
+      if (namedSegments.length > 0 || hasSegments.length > 0) {
+        if (key.includes(":")) {
+          key = safelyCompile(key, indexes);
         }
-        if (h.missing) {
-            route.missing = h.missing;
+        if (value.includes(":")) {
+          value = safelyCompile(value, indexes);
         }
-        return route;
+      }
+      obj[key] = value;
     });
-}
-exports.convertHeaders = convertHeaders;
-function convertTrailingSlash(enable, status = 308) {
-    const routes = [];
-    if (enable) {
-        routes.push({
-            src: '^/\\.well-known(?:/.*)?$',
-        });
-        routes.push({
-            src: '^/((?:[^/]+/)*[^/\\.]+)$',
-            headers: { Location: '/$1/' },
-            status,
-        });
-        routes.push({
-            src: '^/((?:[^/]+/)*[^/]+\\.\\w+)/$',
-            headers: { Location: '/$1' },
-            status,
-        });
+    const route = {
+      src,
+      headers: obj,
+      continue: true
+    };
+    if (h.has) {
+      route.has = h.has;
     }
-    else {
-        routes.push({
-            src: '^/(.*)\\/$',
-            headers: { Location: '/$1' },
-            status,
-        });
+    if (h.missing) {
+      route.missing = h.missing;
     }
-    return routes;
+    return route;
+  });
 }
-exports.convertTrailingSlash = convertTrailingSlash;
-function sourceToRegex(source) {
-    const keys = [];
-    const r = (0, path_to_regexp_1.pathToRegexp)(source, keys, {
-        strict: true,
-        sensitive: true,
-        delimiter: '/',
+function convertTrailingSlash(enable, status = 308) {
+  const routes = [];
+  if (enable) {
+    routes.push({
+      src: "^/\\.well-known(?:/.*)?$"
     });
-    const segments = keys
-        .map(k => k.name)
-        .map(name => {
-        if (typeof name !== 'string') {
-            return UN_NAMED_SEGMENT;
-        }
-        return name;
+    routes.push({
+      src: "^/((?:[^/]+/)*[^/\\.]+)$",
+      headers: { Location: "/$1/" },
+      status
+    });
+    routes.push({
+      src: "^/((?:[^/]+/)*[^/]+\\.\\w+)/$",
+      headers: { Location: "/$1" },
+      status
+    });
+  } else {
+    routes.push({
+      src: "^/(.*)\\/$",
+      headers: { Location: "/$1" },
+      status
     });
-    return { src: r.source, segments };
+  }
+  return routes;
+}
+function sourceToRegex(source) {
+  const keys = [];
+  const r = (0, import_path_to_regexp.pathToRegexp)(source, keys, {
+    strict: true,
+    sensitive: true,
+    delimiter: "/"
+  });
+  const segments = keys.map((k) => k.name).map((name) => {
+    if (typeof name !== "string") {
+      return UN_NAMED_SEGMENT;
+    }
+    return name;
+  });
+  return { src: r.source, segments };
 }
-exports.sourceToRegex = sourceToRegex;
 const namedGroupsRegex = /\(\?<([a-zA-Z][a-zA-Z0-9]*)>/g;
 const normalizeHasKeys = (hasItems = []) => {
-    for (const hasItem of hasItems) {
-        if ('key' in hasItem && hasItem.type === 'header') {
-            hasItem.key = hasItem.key.toLowerCase();
-        }
+  for (const hasItem of hasItems) {
+    if ("key" in hasItem && hasItem.type === "header") {
+      hasItem.key = hasItem.key.toLowerCase();
     }
-    return hasItems;
+  }
+  return hasItems;
 };
 function collectHasSegments(has) {
-    const hasSegments = new Set();
-    for (const hasItem of has || []) {
-        if (!hasItem.value && 'key' in hasItem) {
-            hasSegments.add(hasItem.key);
-        }
-        if (hasItem.value) {
-            for (const match of hasItem.value.matchAll(namedGroupsRegex)) {
-                if (match[1]) {
-                    hasSegments.add(match[1]);
-                }
-            }
-            if (hasItem.type === 'host') {
-                hasSegments.add('host');
-            }
+  const hasSegments = /* @__PURE__ */ new Set();
+  for (const hasItem of has || []) {
+    if (!hasItem.value && "key" in hasItem) {
+      hasSegments.add(hasItem.key);
+    }
+    if (hasItem.value) {
+      for (const match of hasItem.value.matchAll(namedGroupsRegex)) {
+        if (match[1]) {
+          hasSegments.add(match[1]);
         }
+      }
+      if (hasItem.type === "host") {
+        hasSegments.add("host");
+      }
     }
-    return [...hasSegments];
+  }
+  return [...hasSegments];
 }
-exports.collectHasSegments = collectHasSegments;
-const escapeSegment = (str, segmentName) => str.replace(new RegExp(`:${segmentName}`, 'g'), `__ESC_COLON_${segmentName}`);
-const unescapeSegments = (str) => str.replace(/__ESC_COLON_/gi, ':');
+const escapeSegment = (str, segmentName) => str.replace(new RegExp(`:${segmentName}`, "g"), `__ESC_COLON_${segmentName}`);
+const unescapeSegments = (str) => str.replace(/__ESC_COLON_/gi, ":");
 function replaceSegments(segments, hasItemSegments, destination, isRedirect, internalParamNames) {
-    const namedSegments = segments.filter(name => name !== UN_NAMED_SEGMENT);
-    const canNeedReplacing = (destination.includes(':') && namedSegments.length > 0) ||
-        hasItemSegments.length > 0 ||
-        !isRedirect;
-    if (!canNeedReplacing) {
-        return destination;
-    }
-    let escapedDestination = destination;
-    const indexes = {};
-    segments.forEach((name, index) => {
-        indexes[name] = toSegmentDest(index);
-        escapedDestination = escapeSegment(escapedDestination, name);
-    });
-    // 'has' matches override 'source' matches
-    hasItemSegments.forEach(name => {
-        indexes[name] = '$' + name;
-        escapedDestination = escapeSegment(escapedDestination, name);
-    });
-    const parsedDestination = (0, url_1.parse)(escapedDestination, true);
-    delete parsedDestination.href;
-    delete parsedDestination.path;
-    delete parsedDestination.search;
-    delete parsedDestination.host;
-    // eslint-disable-next-line prefer-const
-    let { pathname, hash, query, hostname, ...rest } = parsedDestination;
-    pathname = unescapeSegments(pathname || '');
-    hash = unescapeSegments(hash || '');
-    hostname = unescapeSegments(hostname || '');
-    let destParams = new Set();
-    const pathnameKeys = [];
-    const hashKeys = [];
-    const hostnameKeys = [];
-    try {
-        (0, path_to_regexp_1.pathToRegexp)(pathname, pathnameKeys);
-        (0, path_to_regexp_1.pathToRegexp)(hash || '', hashKeys);
-        (0, path_to_regexp_1.pathToRegexp)(hostname || '', hostnameKeys);
-    }
-    catch (_) {
-        // this is not fatal so don't error when failing to parse the
-        // params from the destination
-    }
-    destParams = new Set([...pathnameKeys, ...hashKeys, ...hostnameKeys]
-        .map(key => key.name)
-        .filter(val => typeof val === 'string'));
-    pathname = safelyCompile(pathname, indexes, true);
-    hash = hash ? safelyCompile(hash, indexes, true) : null;
-    hostname = hostname ? safelyCompile(hostname, indexes, true) : null;
-    for (const [key, strOrArray] of Object.entries(query)) {
-        if (Array.isArray(strOrArray)) {
-            query[key] = strOrArray.map(str => safelyCompile(unescapeSegments(str), indexes, true));
-        }
-        else {
-            // TODO: handle strOrArray is undefined
-            query[key] = safelyCompile(unescapeSegments(strOrArray), indexes, true);
-        }
+  const namedSegments = segments.filter((name) => name !== UN_NAMED_SEGMENT);
+  const canNeedReplacing = destination.includes(":") && namedSegments.length > 0 || hasItemSegments.length > 0 || !isRedirect;
+  if (!canNeedReplacing) {
+    return destination;
+  }
+  let escapedDestination = destination;
+  const indexes = {};
+  segments.forEach((name, index) => {
+    indexes[name] = toSegmentDest(index);
+    escapedDestination = escapeSegment(escapedDestination, name);
+  });
+  hasItemSegments.forEach((name) => {
+    indexes[name] = "$" + name;
+    escapedDestination = escapeSegment(escapedDestination, name);
+  });
+  const parsedDestination = (0, import_url.parse)(escapedDestination, true);
+  delete parsedDestination.href;
+  delete parsedDestination.path;
+  delete parsedDestination.search;
+  delete parsedDestination.host;
+  let { pathname, hash, query, hostname, ...rest } = parsedDestination;
+  pathname = unescapeSegments(pathname || "");
+  hash = unescapeSegments(hash || "");
+  hostname = unescapeSegments(hostname || "");
+  let destParams = /* @__PURE__ */ new Set();
+  const pathnameKeys = [];
+  const hashKeys = [];
+  const hostnameKeys = [];
+  try {
+    (0, import_path_to_regexp.pathToRegexp)(pathname, pathnameKeys);
+    (0, import_path_to_regexp.pathToRegexp)(hash || "", hashKeys);
+    (0, import_path_to_regexp.pathToRegexp)(hostname || "", hostnameKeys);
+  } catch (_) {
+  }
+  destParams = new Set(
+    [...pathnameKeys, ...hashKeys, ...hostnameKeys].map((key) => key.name).filter((val) => typeof val === "string")
+  );
+  pathname = safelyCompile(pathname, indexes, true);
+  hash = hash ? safelyCompile(hash, indexes, true) : null;
+  hostname = hostname ? safelyCompile(hostname, indexes, true) : null;
+  for (const [key, strOrArray] of Object.entries(query)) {
+    if (Array.isArray(strOrArray)) {
+      query[key] = strOrArray.map(
+        (str) => safelyCompile(unescapeSegments(str), indexes, true)
+      );
+    } else {
+      query[key] = safelyCompile(
+        unescapeSegments(strOrArray),
+        indexes,
+        true
+      );
     }
-    // We only add path segments to redirect queries if manually
-    // specified and only automatically add them for rewrites if one
-    // or more params aren't already used in the destination's path
-    const paramKeys = Object.keys(indexes);
-    const needsQueryUpdating = 
+  }
+  const paramKeys = Object.keys(indexes);
+  const needsQueryUpdating = (
     // we do not consider an internal param since it is added automatically
-    !isRedirect &&
-        !paramKeys.some(param => !(internalParamNames && internalParamNames.includes(param)) &&
-            destParams.has(param));
-    if (needsQueryUpdating) {
-        for (const param of paramKeys) {
-            if (!(param in query) && param !== UN_NAMED_SEGMENT) {
-                query[param] = indexes[param];
-            }
-        }
+    !isRedirect && !paramKeys.some(
+      (param) => !(internalParamNames && internalParamNames.includes(param)) && destParams.has(param)
+    )
+  );
+  if (needsQueryUpdating) {
+    for (const param of paramKeys) {
+      if (!(param in query) && param !== UN_NAMED_SEGMENT) {
+        query[param] = indexes[param];
+      }
     }
-    destination = (0, url_1.format)({
-        ...rest,
-        hostname,
-        pathname,
-        query,
-        hash,
-    });
-    // url.format() escapes the dollar sign but it must be preserved for now-proxy
-    return destination.replace(/%24/g, '$');
+  }
+  destination = (0, import_url.format)({
+    ...rest,
+    hostname,
+    pathname,
+    query,
+    hash
+  });
+  return destination.replace(/%24/g, "$");
 }
 function safelyCompile(value, indexes, attemptDirectCompile) {
-    if (!value) {
-        return value;
-    }
-    if (attemptDirectCompile) {
-        try {
-            // Attempt compiling normally with path-to-regexp first and fall back
-            // to safely compiling to handle edge cases if path-to-regexp compile
-            // fails
-            return (0, path_to_regexp_1.compile)(value, { validate: false })(indexes);
-        }
-        catch (e) {
-            // non-fatal, we continue to safely compile
-        }
+  if (!value) {
+    return value;
+  }
+  if (attemptDirectCompile) {
+    try {
+      return (0, import_path_to_regexp.compile)(value, { validate: false })(indexes);
+    } catch (e) {
     }
-    for (const key of Object.keys(indexes)) {
-        if (value.includes(`:${key}`)) {
-            value = value
-                .replace(new RegExp(`:${key}\\*`, 'g'), `:${key}--ESCAPED_PARAM_ASTERISK`)
-                .replace(new RegExp(`:${key}\\?`, 'g'), `:${key}--ESCAPED_PARAM_QUESTION`)
-                .replace(new RegExp(`:${key}\\+`, 'g'), `:${key}--ESCAPED_PARAM_PLUS`)
-                .replace(new RegExp(`:${key}(?!\\w)`, 'g'), `--ESCAPED_PARAM_COLON${key}`);
-        }
+  }
+  for (const key of Object.keys(indexes)) {
+    if (value.includes(`:${key}`)) {
+      value = value.replace(
+        new RegExp(`:${key}\\*`, "g"),
+        `:${key}--ESCAPED_PARAM_ASTERISK`
+      ).replace(
+        new RegExp(`:${key}\\?`, "g"),
+        `:${key}--ESCAPED_PARAM_QUESTION`
+      ).replace(new RegExp(`:${key}\\+`, "g"), `:${key}--ESCAPED_PARAM_PLUS`).replace(
+        new RegExp(`:${key}(?!\\w)`, "g"),
+        `--ESCAPED_PARAM_COLON${key}`
+      );
     }
-    value = value
-        .replace(/(:|\*|\?|\+|\(|\)|\{|\})/g, '\\$1')
-        .replace(/--ESCAPED_PARAM_PLUS/g, '+')
-        .replace(/--ESCAPED_PARAM_COLON/g, ':')
-        .replace(/--ESCAPED_PARAM_QUESTION/g, '?')
-        .replace(/--ESCAPED_PARAM_ASTERISK/g, '*');
-    // the value needs to start with a forward-slash to be compiled
-    // correctly
-    return (0, path_to_regexp_1.compile)(`/${value}`, { validate: false })(indexes).slice(1);
+  }
+  value = value.replace(/(:|\*|\?|\+|\(|\)|\{|\})/g, "\\$1").replace(/--ESCAPED_PARAM_PLUS/g, "+").replace(/--ESCAPED_PARAM_COLON/g, ":").replace(/--ESCAPED_PARAM_QUESTION/g, "?").replace(/--ESCAPED_PARAM_ASTERISK/g, "*");
+  return (0, import_path_to_regexp.compile)(`/${value}`, { validate: false })(indexes).slice(1);
 }
 function toSegmentDest(index) {
-    const i = index + 1; // js is base 0, regex is base 1
-    return '$' + i.toString();
+  const i = index + 1;
+  return "$" + i.toString();
 }
 function toRoute(filePath) {
-    return filePath.startsWith('/') ? filePath : '/' + filePath;
+  return filePath.startsWith("/") ? filePath : "/" + filePath;
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (0);
 
 
 /***/ }),
@@ -40619,7 +40810,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 const fs_extra_1 = __importDefault(__webpack_require__(2650));
 const path_1 = __importDefault(__webpack_require__(5622));
-const semver_1 = __importDefault(__webpack_require__(1039));
+const semver_1 = __importDefault(__webpack_require__(7846));
 const utils_1 = __webpack_require__(6136);
 function getCustomData(importName, target) {
     return `
@@ -40829,7 +41020,7 @@ const find_up_1 = __importDefault(__webpack_require__(7130));
 const fs_extra_1 = __webpack_require__(2650);
 const path_1 = __importDefault(__webpack_require__(5622));
 const resolve_from_1 = __importDefault(__webpack_require__(7472));
-const semver_1 = __importDefault(__webpack_require__(1039));
+const semver_1 = __importDefault(__webpack_require__(7846));
 const url_1 = __importDefault(__webpack_require__(8835));
 const create_serverless_config_1 = __importDefault(__webpack_require__(8333));
 const legacy_versions_1 = __importDefault(__webpack_require__(3537));
@@ -41710,7 +41901,7 @@ const build = async ({ files, workPath, repoRootPath, entrypoint, config = {}, m
                 throw new Error(`A routes-manifest could not be located, please check your outputDirectory and try again.`);
             }
             const localePrefixed404 = !!(routesManifest.i18n &&
-                originalStaticPages[path_1.default.posix.join(entryDirectory, routesManifest.i18n.defaultLocale, '404.html')]);
+                originalStaticPages[path_1.default.posix.join('.', routesManifest.i18n.defaultLocale, '404.html')]);
             return (0, server_build_1.serverBuild)({
                 config,
                 functionsConfigManifest,
@@ -42725,7 +42916,10 @@ async function getServerlessPages(params) {
     }
     // Edge Functions do not consider as Serverless Functions
     for (const edgeFunctionFile of Object.keys(middlewareManifest?.functions ?? {})) {
-        const edgePath = (edgeFunctionFile.slice(1) || 'index') + '.js';
+        let edgePath = middlewareManifest?.functions?.[edgeFunctionFile].name ||
+            edgeFunctionFile;
+        edgePath = (0, utils_1.normalizeEdgeFunctionPath)(edgePath, params.appPathRoutesManifest || {});
+        edgePath = (edgePath || 'index') + '.js';
         delete normalizedAppPaths[edgePath];
         delete pages[edgePath];
     }
@@ -43092,7 +43286,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.serverBuild = void 0;
 const path_1 = __importDefault(__webpack_require__(5622));
-const semver_1 = __importDefault(__webpack_require__(1039));
+const semver_1 = __importDefault(__webpack_require__(7846));
 const async_sema_1 = __webpack_require__(7905);
 const build_utils_1 = __webpack_require__(3445);
 const _1 = __webpack_require__(9037);
@@ -43126,14 +43320,21 @@ async function serverBuild({ dynamicPages, pagesDir, config = {}, functionsConfi
             inversedAppPathManifest[appPathRoutesManifest[ogRoute]] = ogRoute;
         }
     }
-    const APP_PREFETCH_SUFFIX = '.prefetch.rsc';
     let appRscPrefetches = {};
     let appBuildTraces = {};
     let appDir = null;
     if (appPathRoutesManifest) {
         appDir = path_1.default.join(pagesDir, '../app');
         appBuildTraces = await (0, build_utils_1.glob)('**/*.js.nft.json', appDir);
-        appRscPrefetches = await (0, build_utils_1.glob)(`**/*${APP_PREFETCH_SUFFIX}`, appDir);
+        appRscPrefetches = await (0, build_utils_1.glob)(`**/*${utils_1.RSC_PREFETCH_SUFFIX}`, appDir);
+        const rscContentTypeHeader = routesManifest?.rsc?.contentTypeHeader || utils_1.RSC_CONTENT_TYPE;
+        // ensure all appRscPrefetches have a contentType since this is used by Next.js
+        // to determine if it's a valid response
+        for (const value of Object.values(appRscPrefetches)) {
+            if (!value.contentType) {
+                value.contentType = rscContentTypeHeader;
+            }
+        }
     }
     const isCorrectNotFoundRoutes = semver_1.default.gte(nextVersion, CORRECT_NOT_FOUND_ROUTES_VERSION);
     const isCorrectMiddlewareOrder = semver_1.default.gte(nextVersion, CORRECT_MIDDLEWARE_ORDER_VERSION);
@@ -43293,10 +43494,17 @@ async function serverBuild({ dynamicPages, pagesDir, config = {}, functionsConfi
             // for notFound GS(S)P support
             if (i18n) {
                 for (const locale of i18n.locales) {
-                    const static404File = staticPages[path_1.default.posix.join(entryDirectory, locale, '/404')] ||
-                        new build_utils_1.FileFsRef({
+                    let static404File = staticPages[path_1.default.posix.join(entryDirectory, locale, '/404')];
+                    if (!static404File) {
+                        static404File = new build_utils_1.FileFsRef({
                             fsPath: path_1.default.join(pagesDir, locale, '/404.html'),
                         });
+                        if (!fs_extra_1.default.existsSync(static404File.fsPath)) {
+                            static404File = new build_utils_1.FileFsRef({
+                                fsPath: path_1.default.join(pagesDir, '/404.html'),
+                            });
+                        }
+                    }
                     requiredFiles[path_1.default.relative(baseDir, static404File.fsPath)] =
                         static404File;
                 }
@@ -43709,7 +43917,25 @@ async function serverBuild({ dynamicPages, pagesDir, config = {}, functionsConfi
     });
     const isNextDataServerResolving = middleware.staticRoutes.length > 0 &&
         semver_1.default.gte(nextVersion, NEXT_DATA_MIDDLEWARE_RESOLVING_VERSION);
-    const dynamicRoutes = await (0, utils_1.getDynamicRoutes)(entryPath, entryDirectory, dynamicPages, false, routesManifest, omittedPrerenderRoutes, canUsePreviewMode, prerenderManifest.bypassToken || '', true, middleware.dynamicRouteMap, inversedAppPathManifest).then(arr => (0, utils_1.localizeDynamicRoutes)(arr, dynamicPrefix, entryDirectory, staticPages, prerenderManifest, routesManifest, true, isCorrectLocaleAPIRoutes, inversedAppPathManifest));
+    const dynamicRoutes = await (0, utils_1.getDynamicRoutes)(entryPath, entryDirectory, dynamicPages, false, routesManifest, omittedPrerenderRoutes, canUsePreviewMode, prerenderManifest.bypassToken || '', true, middleware.dynamicRouteMap).then(arr => (0, utils_1.localizeDynamicRoutes)(arr, dynamicPrefix, entryDirectory, staticPages, prerenderManifest, routesManifest, true, isCorrectLocaleAPIRoutes, inversedAppPathManifest));
+    const pagesPlaceholderRscEntries = {};
+    if (appDir) {
+        // since we attempt to rewrite all paths to an .rsc variant,
+        // we need to create dummy rsc outputs for all pages entries
+        // this is so that an RSC request to a `pages` entry will match
+        // rather than falling back to a catchall `app` entry
+        // on the nextjs side, invalid RSC response payloads will correctly trigger an mpa navigation
+        const pagesManifest = path_1.default.join(entryPath, outputDirectory, `server/pages-manifest.json`);
+        const pagesData = await fs_extra_1.default.readJSON(pagesManifest);
+        const pagesEntries = Object.keys(pagesData);
+        for (const page of pagesEntries) {
+            const pathName = page.startsWith('/') ? page.slice(1) : page;
+            pagesPlaceholderRscEntries[`${pathName}.rsc`] = new build_utils_1.FileBlob({
+                data: '{}',
+                contentType: 'application/json',
+            });
+        }
+    }
     const { staticFiles, publicDirectoryFiles, staticDirectoryFiles } = await (0, utils_1.getStaticFiles)(entryPath, entryDirectory, outputDirectory);
     const normalizeNextDataRoute = (isOverride = false) => {
         return isNextDataServerResolving
@@ -43795,7 +44021,7 @@ async function serverBuild({ dynamicPages, pagesDir, config = {}, functionsConfi
             if (ogRoute.endsWith('/route')) {
                 continue;
             }
-            route = path_1.default.posix.join('./', entryDirectory, route === '/' ? '/index' : route);
+            route = (0, utils_1.normalizeIndexOutput)(path_1.default.posix.join('./', entryDirectory, route === '/' ? '/index' : route), true);
             if (lambdas[route]) {
                 lambdas[`${route}.rsc`] = lambdas[route];
             }
@@ -43816,6 +44042,7 @@ async function serverBuild({ dynamicPages, pagesDir, config = {}, functionsConfi
             ...publicDirectoryFiles,
             ...lambdas,
             ...appRscPrefetches,
+            ...pagesPlaceholderRscEntries,
             // Prerenders may override Lambdas -- this is an intentional behavior.
             ...prerenders,
             ...staticPages,
@@ -44007,7 +44234,7 @@ async function serverBuild({ dynamicPages, pagesDir, config = {}, functionsConfi
                                         key: rscPrefetchHeader,
                                     },
                                 ],
-                                dest: path_1.default.posix.join('/', entryDirectory, '/index.prefetch.rsc'),
+                                dest: path_1.default.posix.join('/', entryDirectory, `/index${utils_1.RSC_PREFETCH_SUFFIX}`),
                                 headers: { vary: rscVaryHeader },
                                 continue: true,
                                 override: true,
@@ -44020,7 +44247,7 @@ async function serverBuild({ dynamicPages, pagesDir, config = {}, functionsConfi
                                         key: rscPrefetchHeader,
                                     },
                                 ],
-                                dest: path_1.default.posix.join('/', entryDirectory, `/$1${APP_PREFETCH_SUFFIX}`),
+                                dest: path_1.default.posix.join('/', entryDirectory, `/$1${utils_1.RSC_PREFETCH_SUFFIX}`),
                                 headers: { vary: rscVaryHeader },
                                 continue: true,
                                 override: true,
@@ -44085,7 +44312,7 @@ async function serverBuild({ dynamicPages, pagesDir, config = {}, functionsConfi
             ...(rscPrefetchHeader
                 ? [
                     {
-                        src: path_1.default.posix.join('/', entryDirectory, `/index${APP_PREFETCH_SUFFIX}`),
+                        src: path_1.default.posix.join('/', entryDirectory, `/index${utils_1.RSC_PREFETCH_SUFFIX}`),
                         dest: path_1.default.posix.join('/', entryDirectory, '/index.rsc'),
                         has: [
                             {
@@ -44097,7 +44324,7 @@ async function serverBuild({ dynamicPages, pagesDir, config = {}, functionsConfi
                         override: true,
                     },
                     {
-                        src: `^${path_1.default.posix.join('/', entryDirectory, `/(.+?)${APP_PREFETCH_SUFFIX}(?:/)?$`)}`,
+                        src: `^${path_1.default.posix.join('/', entryDirectory, `/(.+?)${utils_1.RSC_PREFETCH_SUFFIX}(?:/)?$`)}`,
                         dest: path_1.default.posix.join('/', entryDirectory, '/$1.rsc'),
                         has: [
                             {
@@ -44110,62 +44337,17 @@ async function serverBuild({ dynamicPages, pagesDir, config = {}, functionsConfi
                     },
                 ]
                 : []),
-            ...(appDir
-                ? [
-                    // check routes that end in `.rsc` to see if a page with the resulting name (sans-.rsc) exists in the filesystem
-                    // if so, we want to match that page instead. (This matters when prefetching a pages route while on an appdir route)
-                    {
-                        src: `^${path_1.default.posix.join('/', entryDirectory, '/(.*)\\.rsc$')}`,
-                        dest: path_1.default.posix.join('/', entryDirectory, '/$1'),
-                        has: [
-                            {
-                                type: 'header',
-                                key: rscHeader,
-                            },
-                        ],
-                        ...(rscPrefetchHeader
-                            ? {
-                                missing: [
-                                    {
-                                        type: 'header',
-                                        key: rscPrefetchHeader,
-                                    },
-                                ],
-                            }
-                            : {}),
-                        check: true,
-                    },
-                ]
-                : []),
             // These need to come before handle: miss or else they are grouped
             // with that routing section
             ...afterFilesRewrites,
-            ...(appDir
-                ? [
-                    // rewrite route back to `.rsc`, but skip checking fs
-                    {
-                        src: `^${path_1.default.posix.join('/', entryDirectory, '/((?!.+\\.rsc).+?)(?:/)?$')}`,
-                        has: [
-                            {
-                                type: 'header',
-                                key: rscHeader,
-                            },
-                        ],
-                        dest: path_1.default.posix.join('/', entryDirectory, '/$1.rsc'),
-                        headers: { vary: rscVaryHeader },
-                        continue: true,
-                        override: true,
-                    },
-                ]
-                : []),
-            // make sure 404 page is used when a directory is matched without
-            // an index page
             { handle: 'resource' },
             ...fallbackRewrites,
+            // make sure 404 page is used when a directory is matched without
+            // an index page
             { src: path_1.default.posix.join('/', entryDirectory, '.*'), status: 404 },
+            { handle: 'miss' },
             // We need to make sure to 404 for /_next after handle: miss since
             // handle: miss is called before rewrites and to prevent rewriting /_next
-            { handle: 'miss' },
             {
                 src: path_1.default.posix.join('/', entryDirectory, '_next/static/(?:[^/]+/pages|pages|chunks|runtime|css|image|media)/.+'),
                 status: 404,
@@ -44539,14 +44721,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.isApiPage = exports.getOperationType = exports.upgradeMiddlewareManifest = exports.getMiddlewareManifest = exports.getFunctionsConfigManifest = exports.getMiddlewareBundle = exports.getSourceFilePathFromPage = exports.isDynamicRoute = exports.normalizePage = exports.getImagesConfig = exports.getNextConfig = exports.normalizePackageJson = exports.validateEntrypoint = exports.excludeFiles = exports.getPrivateOutputs = exports.updateRouteSrc = exports.getNextServerPath = exports.normalizeIndexOutput = exports.getStaticFiles = exports.onPrerenderRoute = exports.onPrerenderRouteInitial = exports.detectLambdaLimitExceeding = exports.outputFunctionFileSizeInfo = exports.getPageLambdaGroups = exports.MAX_UNCOMPRESSED_LAMBDA_SIZE = exports.addLocaleOrDefault = exports.normalizeLocalePath = exports.getPrerenderManifest = exports.getRequiredServerFilesManifest = exports.getExportStatus = exports.getExportIntent = exports.createLambdaFromPseudoLayers = exports.createPseudoLayer = exports.ExperimentalTraceVersion = exports.collectTracedFiles = exports.getFilesMapFromReasons = exports.filterStaticPages = exports.getImagesManifest = exports.localizeDynamicRoutes = exports.getDynamicRoutes = exports.getRoutesManifest = exports.prettyBytes = exports.MIB = exports.KIB = void 0;
+exports.isApiPage = exports.getOperationType = exports.upgradeMiddlewareManifest = exports.getMiddlewareManifest = exports.getFunctionsConfigManifest = exports.getMiddlewareBundle = exports.normalizeEdgeFunctionPath = exports.getSourceFilePathFromPage = exports.isDynamicRoute = exports.normalizePage = exports.getImagesConfig = exports.getNextConfig = exports.normalizePackageJson = exports.validateEntrypoint = exports.excludeFiles = exports.getPrivateOutputs = exports.updateRouteSrc = exports.getNextServerPath = exports.normalizeIndexOutput = exports.getStaticFiles = exports.onPrerenderRoute = exports.onPrerenderRouteInitial = exports.detectLambdaLimitExceeding = exports.outputFunctionFileSizeInfo = exports.getPageLambdaGroups = exports.MAX_UNCOMPRESSED_LAMBDA_SIZE = exports.addLocaleOrDefault = exports.normalizeLocalePath = exports.getPrerenderManifest = exports.getRequiredServerFilesManifest = exports.getExportStatus = exports.getExportIntent = exports.createLambdaFromPseudoLayers = exports.createPseudoLayer = exports.ExperimentalTraceVersion = exports.collectTracedFiles = exports.getFilesMapFromReasons = exports.filterStaticPages = exports.getImagesManifest = exports.localizeDynamicRoutes = exports.getDynamicRoutes = exports.getRoutesManifest = exports.RSC_PREFETCH_SUFFIX = exports.RSC_CONTENT_TYPE = exports.prettyBytes = exports.MIB = exports.KIB = void 0;
 const build_utils_1 = __webpack_require__(3445);
 const async_sema_1 = __webpack_require__(7905);
 const buffer_crc32_1 = __importDefault(__webpack_require__(2227));
 const fs_extra_1 = __importStar(__webpack_require__(2650));
 const path_1 = __importDefault(__webpack_require__(5622));
 const resolve_from_1 = __importDefault(__webpack_require__(7472));
-const semver_1 = __importDefault(__webpack_require__(1039));
+const semver_1 = __importDefault(__webpack_require__(7846));
 const zlib_1 = __importDefault(__webpack_require__(8761));
 const url_1 = __importDefault(__webpack_require__(8835));
 const escape_string_regexp_1 = __importDefault(__webpack_require__(3133));
@@ -44559,6 +44741,8 @@ exports.KIB = 1024;
 exports.MIB = 1024 * exports.KIB;
 const prettyBytes = (n) => (0, bytes_1.default)(n, { unitSeparator: ' ' });
 exports.prettyBytes = prettyBytes;
+exports.RSC_CONTENT_TYPE = 'x-component';
+exports.RSC_PREFETCH_SUFFIX = '.prefetch.rsc';
 // Identify /[param]/ in route string
 // eslint-disable-next-line no-useless-escape
 const TEST_DYNAMIC_ROUTE = /\/\[[^\/]+?\](?=\/|$)/;
@@ -44707,7 +44891,7 @@ async function getRoutesManifest(entryPath, outputDirectory, nextVersion) {
     return routesManifest;
 }
 exports.getRoutesManifest = getRoutesManifest;
-async function getDynamicRoutes(entryPath, entryDirectory, dynamicPages, isDev, routesManifest, omittedRoutes, canUsePreviewMode, bypassToken, isServerMode, dynamicMiddlewareRouteMap, appPathRoutesManifest) {
+async function getDynamicRoutes(entryPath, entryDirectory, dynamicPages, isDev, routesManifest, omittedRoutes, canUsePreviewMode, bypassToken, isServerMode, dynamicMiddlewareRouteMap) {
     if (routesManifest) {
         switch (routesManifest.version) {
             case 1:
@@ -44766,13 +44950,11 @@ async function getDynamicRoutes(entryPath, entryDirectory, dynamicPages, isDev,
                             },
                         ];
                     }
-                    if (appPathRoutesManifest?.[page]) {
-                        routes.push({
-                            ...route,
-                            src: route.src.replace(new RegExp((0, escape_string_regexp_1.default)('(?:/)?$')), '(?:\\.rsc)(?:/)?$'),
-                            dest: route.dest?.replace(/($|\?)/, '.rsc$1'),
-                        });
-                    }
+                    routes.push({
+                        ...route,
+                        src: route.src.replace(new RegExp((0, escape_string_regexp_1.default)('(?:/)?$')), '(?:\\.rsc)(?:/)?$'),
+                        dest: route.dest?.replace(/($|\?)/, '.rsc$1'),
+                    });
                     routes.push(route);
                     continue;
                 }
@@ -45876,7 +46058,7 @@ const onPrerenderRoute = (prerenderRouteArgs) => (routeKey, { isBlocking, isFall
         const rscEnabled = !!routesManifest?.rsc;
         const rscVaryHeader = routesManifest?.rsc?.varyHeader ||
             'RSC, Next-Router-State-Tree, Next-Router-Prefetch';
-        const rscContentTypeHeader = routesManifest?.rsc?.contentTypeHeader || 'text/x-component';
+        const rscContentTypeHeader = routesManifest?.rsc?.contentTypeHeader || exports.RSC_CONTENT_TYPE;
         let sourcePath;
         if (`/${outputPathPage}` !== srcRoute && srcRoute) {
             sourcePath = srcRoute;
@@ -46016,7 +46198,7 @@ async function getStaticFiles(entryPath, entryDirectory, outputDirectory) {
 }
 exports.getStaticFiles = getStaticFiles;
 function normalizeIndexOutput(outputName, isServerMode) {
-    if (outputName !== '/index' && isServerMode) {
+    if (outputName !== 'index' && outputName !== '/index' && isServerMode) {
         return outputName.replace(/\/index$/, '');
     }
     return outputName;
@@ -46110,6 +46292,21 @@ function normalizeRegions(regions) {
     }
     return newRegions;
 }
+function normalizeEdgeFunctionPath(shortPath, appPathRoutesManifest) {
+    if (shortPath.startsWith('app/') &&
+        (shortPath.endsWith('/page') ||
+            shortPath.endsWith('/route') ||
+            shortPath === 'app/_not-found')) {
+        const ogRoute = shortPath.replace(/^app\//, '/');
+        shortPath = (appPathRoutesManifest[ogRoute] ||
+            shortPath.replace(/(^|\/)(page|route)$/, '')).replace(/^\//, '');
+        if (!shortPath || shortPath === '/') {
+            shortPath = 'index';
+        }
+    }
+    return shortPath;
+}
+exports.normalizeEdgeFunctionPath = normalizeEdgeFunctionPath;
 async function getMiddlewareBundle({ entryPath, outputDirectory, routesManifest, isCorrectMiddlewareOrder, prerenderBypassToken, nextVersion, appPathRoutesManifest, }) {
     const middlewareManifest = await getMiddlewareManifest(entryPath, outputDirectory);
     const sortedFunctions = [
@@ -46226,21 +46423,11 @@ async function getMiddlewareBundle({ entryPath, outputDirectory, routesManifest,
             if (shortPath.startsWith('pages/')) {
                 shortPath = shortPath.replace(/^pages\//, '');
             }
-            else if (shortPath.startsWith('app/') &&
-                (shortPath.endsWith('/page') ||
-                    shortPath.endsWith('/route') ||
-                    shortPath === 'app/_not-found')) {
-                const ogRoute = shortPath.replace(/^app\//, '/');
-                shortPath = (appPathRoutesManifest[ogRoute] ||
-                    shortPath.replace(/(^|\/)(page|route)$/, '')).replace(/^\//, '');
-                if (!shortPath || shortPath === '/') {
-                    shortPath = 'index';
-                }
+            else {
+                shortPath = normalizeEdgeFunctionPath(shortPath, appPathRoutesManifest);
             }
             if (routesManifest?.basePath) {
-                shortPath = path_1.default.posix
-                    .join(routesManifest.basePath, shortPath)
-                    .replace(/^\//, '');
+                shortPath = normalizeIndexOutput(path_1.default.posix.join('./', routesManifest?.basePath, shortPath.replace(/^\//, '')), true);
             }
             worker.edgeFunction.name = shortPath;
             source.edgeFunctions[shortPath] = worker.edgeFunction;