@vercel/next 12.0.3 → 13.0.0

package/dist/index.js

@@ -8391,7 +8391,7 @@ var require_util = __commonJS({
       return path6;
     });
     exports.normalize = normalize;
-    function join2(aRoot, aPath) {
+    function join3(aRoot, aPath) {
       if (aRoot === "") {
         aRoot = ".";
       }
@@ -8423,7 +8423,7 @@ var require_util = __commonJS({
       }
       return joined;
     }
-    exports.join = join2;
+    exports.join = join3;
     exports.isAbsolute = function(aPath) {
       return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
     };
@@ -8596,7 +8596,7 @@ var require_util = __commonJS({
             parsed.path = parsed.path.substring(0, index + 1);
           }
         }
-        sourceURL = join2(urlGenerate(parsed), sourceURL);
+        sourceURL = join3(urlGenerate(parsed), sourceURL);
       }
       return normalize(sourceURL);
     }
@@ -10912,25 +10912,843 @@ var require_pretty_bytes = __commonJS({
   }
 });
 
+// ../../node_modules/.pnpm/concat-map@0.0.1/node_modules/concat-map/index.js
+var require_concat_map = __commonJS({
+  "../../node_modules/.pnpm/concat-map@0.0.1/node_modules/concat-map/index.js"(exports, module2) {
+    module2.exports = function(xs, fn) {
+      var res = [];
+      for (var i = 0; i < xs.length; i++) {
+        var x = fn(xs[i], i);
+        if (isArray(x))
+          res.push.apply(res, x);
+        else
+          res.push(x);
+      }
+      return res;
+    };
+    var isArray = Array.isArray || function(xs) {
+      return Object.prototype.toString.call(xs) === "[object Array]";
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/index.js
+var require_balanced_match = __commonJS({
+  "../../node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/index.js"(exports, module2) {
+    "use strict";
+    module2.exports = balanced;
+    function balanced(a, b, str) {
+      if (a instanceof RegExp)
+        a = maybeMatch(a, str);
+      if (b instanceof RegExp)
+        b = maybeMatch(b, str);
+      var r = range(a, b, str);
+      return r && {
+        start: r[0],
+        end: r[1],
+        pre: str.slice(0, r[0]),
+        body: str.slice(r[0] + a.length, r[1]),
+        post: str.slice(r[1] + b.length)
+      };
+    }
+    function maybeMatch(reg, str) {
+      var m = str.match(reg);
+      return m ? m[0] : null;
+    }
+    balanced.range = range;
+    function range(a, b, str) {
+      var begs, beg, left, right, result;
+      var ai = str.indexOf(a);
+      var bi = str.indexOf(b, ai + 1);
+      var i = ai;
+      if (ai >= 0 && bi > 0) {
+        if (a === b) {
+          return [ai, bi];
+        }
+        begs = [];
+        left = str.length;
+        while (i >= 0 && !result) {
+          if (i == ai) {
+            begs.push(i);
+            ai = str.indexOf(a, i + 1);
+          } else if (begs.length == 1) {
+            result = [begs.pop(), bi];
+          } else {
+            beg = begs.pop();
+            if (beg < left) {
+              left = beg;
+              right = bi;
+            }
+            bi = str.indexOf(b, i + 1);
+          }
+          i = ai < bi && ai >= 0 ? ai : bi;
+        }
+        if (begs.length) {
+          result = [left, right];
+        }
+      }
+      return result;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/brace-expansion@1.1.15/node_modules/brace-expansion/index.js
+var require_brace_expansion = __commonJS({
+  "../../node_modules/.pnpm/brace-expansion@1.1.15/node_modules/brace-expansion/index.js"(exports, module2) {
+    var concatMap = require_concat_map();
+    var balanced = require_balanced_match();
+    module2.exports = expandTop;
+    var escSlash = "\0SLASH" + Math.random() + "\0";
+    var escOpen = "\0OPEN" + Math.random() + "\0";
+    var escClose = "\0CLOSE" + Math.random() + "\0";
+    var escComma = "\0COMMA" + Math.random() + "\0";
+    var escPeriod = "\0PERIOD" + Math.random() + "\0";
+    function numeric(str) {
+      return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
+    }
+    function escapeBraces(str) {
+      return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
+    }
+    function unescapeBraces(str) {
+      return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
+    }
+    function parseCommaParts(str) {
+      if (!str)
+        return [""];
+      var parts = [];
+      var m = balanced("{", "}", str);
+      if (!m)
+        return str.split(",");
+      var pre = m.pre;
+      var body = m.body;
+      var post = m.post;
+      var p = pre.split(",");
+      p[p.length - 1] += "{" + body + "}";
+      var postParts = parseCommaParts(post);
+      if (post.length) {
+        p[p.length - 1] += postParts.shift();
+        p.push.apply(p, postParts);
+      }
+      parts.push.apply(parts, p);
+      return parts;
+    }
+    function expandTop(str, options) {
+      if (!str)
+        return [];
+      options = options || {};
+      var max = options.max == null ? Infinity : options.max;
+      if (str.substr(0, 2) === "{}") {
+        str = "\\{\\}" + str.substr(2);
+      }
+      return expand(escapeBraces(str), max, true).map(unescapeBraces);
+    }
+    function embrace(str) {
+      return "{" + str + "}";
+    }
+    function isPadded(el) {
+      return /^-?0\d/.test(el);
+    }
+    function lte(i, y) {
+      return i <= y;
+    }
+    function gte(i, y) {
+      return i >= y;
+    }
+    function expand(str, max, isTop) {
+      var expansions = [];
+      var m = balanced("{", "}", str);
+      if (!m || /\$$/.test(m.pre))
+        return [str];
+      var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+      var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+      var isSequence = isNumericSequence || isAlphaSequence;
+      var isOptions = m.body.indexOf(",") >= 0;
+      if (!isSequence && !isOptions) {
+        if (m.post.match(/,(?!,).*\}/)) {
+          str = m.pre + "{" + m.body + escClose + m.post;
+          return expand(str, max, true);
+        }
+        return [str];
+      }
+      var n;
+      if (isSequence) {
+        n = m.body.split(/\.\./);
+      } else {
+        n = parseCommaParts(m.body);
+        if (n.length === 1) {
+          n = expand(n[0], max, false).map(embrace);
+          if (n.length === 1) {
+            var post = m.post.length ? expand(m.post, max, false) : [""];
+            return post.map(function(p) {
+              return m.pre + n[0] + p;
+            });
+          }
+        }
+      }
+      var pre = m.pre;
+      var post = m.post.length ? expand(m.post, max, false) : [""];
+      var N;
+      if (isSequence) {
+        var x = numeric(n[0]);
+        var y = numeric(n[1]);
+        var width = Math.max(n[0].length, n[1].length);
+        var incr = n.length == 3 ? Math.max(Math.abs(numeric(n[2])), 1) : 1;
+        var test = lte;
+        var reverse = y < x;
+        if (reverse) {
+          incr *= -1;
+          test = gte;
+        }
+        var pad = n.some(isPadded);
+        N = [];
+        for (var i = x; test(i, y) && N.length < max; i += incr) {
+          var c;
+          if (isAlphaSequence) {
+            c = String.fromCharCode(i);
+            if (c === "\\")
+              c = "";
+          } else {
+            c = String(i);
+            if (pad) {
+              var need = width - c.length;
+              if (need > 0) {
+                var z = new Array(need + 1).join("0");
+                if (i < 0)
+                  c = "-" + z + c.slice(1);
+                else
+                  c = z + c;
+              }
+            }
+          }
+          N.push(c);
+        }
+      } else {
+        N = concatMap(n, function(el) {
+          return expand(el, max, false);
+        });
+      }
+      for (var j = 0; j < N.length; j++) {
+        for (var k = 0; k < post.length && expansions.length < max; k++) {
+          var expansion = pre + N[j] + post[k];
+          if (!isTop || isSequence || expansion)
+            expansions.push(expansion);
+        }
+      }
+      return expansions;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/minimatch@3.1.2/node_modules/minimatch/minimatch.js
+var require_minimatch = __commonJS({
+  "../../node_modules/.pnpm/minimatch@3.1.2/node_modules/minimatch/minimatch.js"(exports, module2) {
+    module2.exports = minimatch2;
+    minimatch2.Minimatch = Minimatch;
+    var path6 = function() {
+      try {
+        return require("path");
+      } catch (e) {
+      }
+    }() || {
+      sep: "/"
+    };
+    minimatch2.sep = path6.sep;
+    var GLOBSTAR = minimatch2.GLOBSTAR = Minimatch.GLOBSTAR = {};
+    var expand = require_brace_expansion();
+    var plTypes = {
+      "!": { open: "(?:(?!(?:", close: "))[^/]*?)" },
+      "?": { open: "(?:", close: ")?" },
+      "+": { open: "(?:", close: ")+" },
+      "*": { open: "(?:", close: ")*" },
+      "@": { open: "(?:", close: ")" }
+    };
+    var qmark = "[^/]";
+    var star = qmark + "*?";
+    var twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
+    var twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
+    var reSpecials = charSet("().*{}+?[]^$\\!");
+    function charSet(s) {
+      return s.split("").reduce(function(set, c) {
+        set[c] = true;
+        return set;
+      }, {});
+    }
+    var slashSplit = /\/+/;
+    minimatch2.filter = filter;
+    function filter(pattern, options) {
+      options = options || {};
+      return function(p, i, list) {
+        return minimatch2(p, pattern, options);
+      };
+    }
+    function ext(a, b) {
+      b = b || {};
+      var t = {};
+      Object.keys(a).forEach(function(k) {
+        t[k] = a[k];
+      });
+      Object.keys(b).forEach(function(k) {
+        t[k] = b[k];
+      });
+      return t;
+    }
+    minimatch2.defaults = function(def) {
+      if (!def || typeof def !== "object" || !Object.keys(def).length) {
+        return minimatch2;
+      }
+      var orig = minimatch2;
+      var m = function minimatch3(p, pattern, options) {
+        return orig(p, pattern, ext(def, options));
+      };
+      m.Minimatch = function Minimatch2(pattern, options) {
+        return new orig.Minimatch(pattern, ext(def, options));
+      };
+      m.Minimatch.defaults = function defaults(options) {
+        return orig.defaults(ext(def, options)).Minimatch;
+      };
+      m.filter = function filter2(pattern, options) {
+        return orig.filter(pattern, ext(def, options));
+      };
+      m.defaults = function defaults(options) {
+        return orig.defaults(ext(def, options));
+      };
+      m.makeRe = function makeRe2(pattern, options) {
+        return orig.makeRe(pattern, ext(def, options));
+      };
+      m.braceExpand = function braceExpand2(pattern, options) {
+        return orig.braceExpand(pattern, ext(def, options));
+      };
+      m.match = function(list, pattern, options) {
+        return orig.match(list, pattern, ext(def, options));
+      };
+      return m;
+    };
+    Minimatch.defaults = function(def) {
+      return minimatch2.defaults(def).Minimatch;
+    };
+    function minimatch2(p, pattern, options) {
+      assertValidPattern(pattern);
+      if (!options)
+        options = {};
+      if (!options.nocomment && pattern.charAt(0) === "#") {
+        return false;
+      }
+      return new Minimatch(pattern, options).match(p);
+    }
+    function Minimatch(pattern, options) {
+      if (!(this instanceof Minimatch)) {
+        return new Minimatch(pattern, options);
+      }
+      assertValidPattern(pattern);
+      if (!options)
+        options = {};
+      pattern = pattern.trim();
+      if (!options.allowWindowsEscape && path6.sep !== "/") {
+        pattern = pattern.split(path6.sep).join("/");
+      }
+      this.options = options;
+      this.set = [];
+      this.pattern = pattern;
+      this.regexp = null;
+      this.negate = false;
+      this.comment = false;
+      this.empty = false;
+      this.partial = !!options.partial;
+      this.make();
+    }
+    Minimatch.prototype.debug = function() {
+    };
+    Minimatch.prototype.make = make;
+    function make() {
+      var pattern = this.pattern;
+      var options = this.options;
+      if (!options.nocomment && pattern.charAt(0) === "#") {
+        this.comment = true;
+        return;
+      }
+      if (!pattern) {
+        this.empty = true;
+        return;
+      }
+      this.parseNegate();
+      var set = this.globSet = this.braceExpand();
+      if (options.debug)
+        this.debug = function debug4() {
+          console.error.apply(console, arguments);
+        };
+      this.debug(this.pattern, set);
+      set = this.globParts = set.map(function(s) {
+        return s.split(slashSplit);
+      });
+      this.debug(this.pattern, set);
+      set = set.map(function(s, si, set2) {
+        return s.map(this.parse, this);
+      }, this);
+      this.debug(this.pattern, set);
+      set = set.filter(function(s) {
+        return s.indexOf(false) === -1;
+      });
+      this.debug(this.pattern, set);
+      this.set = set;
+    }
+    Minimatch.prototype.parseNegate = parseNegate;
+    function parseNegate() {
+      var pattern = this.pattern;
+      var negate = false;
+      var options = this.options;
+      var negateOffset = 0;
+      if (options.nonegate)
+        return;
+      for (var i = 0, l = pattern.length; i < l && pattern.charAt(i) === "!"; i++) {
+        negate = !negate;
+        negateOffset++;
+      }
+      if (negateOffset)
+        this.pattern = pattern.substr(negateOffset);
+      this.negate = negate;
+    }
+    minimatch2.braceExpand = function(pattern, options) {
+      return braceExpand(pattern, options);
+    };
+    Minimatch.prototype.braceExpand = braceExpand;
+    function braceExpand(pattern, options) {
+      if (!options) {
+        if (this instanceof Minimatch) {
+          options = this.options;
+        } else {
+          options = {};
+        }
+      }
+      pattern = typeof pattern === "undefined" ? this.pattern : pattern;
+      assertValidPattern(pattern);
+      if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
+        return [pattern];
+      }
+      return expand(pattern);
+    }
+    var MAX_PATTERN_LENGTH = 1024 * 64;
+    var assertValidPattern = function(pattern) {
+      if (typeof pattern !== "string") {
+        throw new TypeError("invalid pattern");
+      }
+      if (pattern.length > MAX_PATTERN_LENGTH) {
+        throw new TypeError("pattern is too long");
+      }
+    };
+    Minimatch.prototype.parse = parse;
+    var SUBPARSE = {};
+    function parse(pattern, isSub) {
+      assertValidPattern(pattern);
+      var options = this.options;
+      if (pattern === "**") {
+        if (!options.noglobstar)
+          return GLOBSTAR;
+        else
+          pattern = "*";
+      }
+      if (pattern === "")
+        return "";
+      var re = "";
+      var hasMagic = !!options.nocase;
+      var escaping = false;
+      var patternListStack = [];
+      var negativeLists = [];
+      var stateChar;
+      var inClass = false;
+      var reClassStart = -1;
+      var classStart = -1;
+      var patternStart = pattern.charAt(0) === "." ? "" : options.dot ? "(?!(?:^|\\/)\\.{1,2}(?:$|\\/))" : "(?!\\.)";
+      var self = this;
+      function clearStateChar() {
+        if (stateChar) {
+          switch (stateChar) {
+            case "*":
+              re += star;
+              hasMagic = true;
+              break;
+            case "?":
+              re += qmark;
+              hasMagic = true;
+              break;
+            default:
+              re += "\\" + stateChar;
+              break;
+          }
+          self.debug("clearStateChar %j %j", stateChar, re);
+          stateChar = false;
+        }
+      }
+      for (var i = 0, len = pattern.length, c; i < len && (c = pattern.charAt(i)); i++) {
+        this.debug("%s	%s %s %j", pattern, i, re, c);
+        if (escaping && reSpecials[c]) {
+          re += "\\" + c;
+          escaping = false;
+          continue;
+        }
+        switch (c) {
+          case "/": {
+            return false;
+          }
+          case "\\":
+            clearStateChar();
+            escaping = true;
+            continue;
+          case "?":
+          case "*":
+          case "+":
+          case "@":
+          case "!":
+            this.debug("%s	%s %s %j <-- stateChar", pattern, i, re, c);
+            if (inClass) {
+              this.debug("  in class");
+              if (c === "!" && i === classStart + 1)
+                c = "^";
+              re += c;
+              continue;
+            }
+            self.debug("call clearStateChar %j", stateChar);
+            clearStateChar();
+            stateChar = c;
+            if (options.noext)
+              clearStateChar();
+            continue;
+          case "(":
+            if (inClass) {
+              re += "(";
+              continue;
+            }
+            if (!stateChar) {
+              re += "\\(";
+              continue;
+            }
+            patternListStack.push({
+              type: stateChar,
+              start: i - 1,
+              reStart: re.length,
+              open: plTypes[stateChar].open,
+              close: plTypes[stateChar].close
+            });
+            re += stateChar === "!" ? "(?:(?!(?:" : "(?:";
+            this.debug("plType %j %j", stateChar, re);
+            stateChar = false;
+            continue;
+          case ")":
+            if (inClass || !patternListStack.length) {
+              re += "\\)";
+              continue;
+            }
+            clearStateChar();
+            hasMagic = true;
+            var pl = patternListStack.pop();
+            re += pl.close;
+            if (pl.type === "!") {
+              negativeLists.push(pl);
+            }
+            pl.reEnd = re.length;
+            continue;
+          case "|":
+            if (inClass || !patternListStack.length || escaping) {
+              re += "\\|";
+              escaping = false;
+              continue;
+            }
+            clearStateChar();
+            re += "|";
+            continue;
+          case "[":
+            clearStateChar();
+            if (inClass) {
+              re += "\\" + c;
+              continue;
+            }
+            inClass = true;
+            classStart = i;
+            reClassStart = re.length;
+            re += c;
+            continue;
+          case "]":
+            if (i === classStart + 1 || !inClass) {
+              re += "\\" + c;
+              escaping = false;
+              continue;
+            }
+            var cs = pattern.substring(classStart + 1, i);
+            try {
+              RegExp("[" + cs + "]");
+            } catch (er) {
+              var sp = this.parse(cs, SUBPARSE);
+              re = re.substr(0, reClassStart) + "\\[" + sp[0] + "\\]";
+              hasMagic = hasMagic || sp[1];
+              inClass = false;
+              continue;
+            }
+            hasMagic = true;
+            inClass = false;
+            re += c;
+            continue;
+          default:
+            clearStateChar();
+            if (escaping) {
+              escaping = false;
+            } else if (reSpecials[c] && !(c === "^" && inClass)) {
+              re += "\\";
+            }
+            re += c;
+        }
+      }
+      if (inClass) {
+        cs = pattern.substr(classStart + 1);
+        sp = this.parse(cs, SUBPARSE);
+        re = re.substr(0, reClassStart) + "\\[" + sp[0];
+        hasMagic = hasMagic || sp[1];
+      }
+      for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
+        var tail = re.slice(pl.reStart + pl.open.length);
+        this.debug("setting tail", re, pl);
+        tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function(_, $1, $2) {
+          if (!$2) {
+            $2 = "\\";
+          }
+          return $1 + $1 + $2 + "|";
+        });
+        this.debug("tail=%j\n   %s", tail, tail, pl, re);
+        var t = pl.type === "*" ? star : pl.type === "?" ? qmark : "\\" + pl.type;
+        hasMagic = true;
+        re = re.slice(0, pl.reStart) + t + "\\(" + tail;
+      }
+      clearStateChar();
+      if (escaping) {
+        re += "\\\\";
+      }
+      var addPatternStart = false;
+      switch (re.charAt(0)) {
+        case "[":
+        case ".":
+        case "(":
+          addPatternStart = true;
+      }
+      for (var n = negativeLists.length - 1; n > -1; n--) {
+        var nl = negativeLists[n];
+        var nlBefore = re.slice(0, nl.reStart);
+        var nlFirst = re.slice(nl.reStart, nl.reEnd - 8);
+        var nlLast = re.slice(nl.reEnd - 8, nl.reEnd);
+        var nlAfter = re.slice(nl.reEnd);
+        nlLast += nlAfter;
+        var openParensBefore = nlBefore.split("(").length - 1;
+        var cleanAfter = nlAfter;
+        for (i = 0; i < openParensBefore; i++) {
+          cleanAfter = cleanAfter.replace(/\)[+*?]?/, "");
+        }
+        nlAfter = cleanAfter;
+        var dollar = "";
+        if (nlAfter === "" && isSub !== SUBPARSE) {
+          dollar = "$";
+        }
+        var newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast;
+        re = newRe;
+      }
+      if (re !== "" && hasMagic) {
+        re = "(?=.)" + re;
+      }
+      if (addPatternStart) {
+        re = patternStart + re;
+      }
+      if (isSub === SUBPARSE) {
+        return [re, hasMagic];
+      }
+      if (!hasMagic) {
+        return globUnescape(pattern);
+      }
+      var flags = options.nocase ? "i" : "";
+      try {
+        var regExp = new RegExp("^" + re + "$", flags);
+      } catch (er) {
+        return new RegExp("$.");
+      }
+      regExp._glob = pattern;
+      regExp._src = re;
+      return regExp;
+    }
+    minimatch2.makeRe = function(pattern, options) {
+      return new Minimatch(pattern, options || {}).makeRe();
+    };
+    Minimatch.prototype.makeRe = makeRe;
+    function makeRe() {
+      if (this.regexp || this.regexp === false)
+        return this.regexp;
+      var set = this.set;
+      if (!set.length) {
+        this.regexp = false;
+        return this.regexp;
+      }
+      var options = this.options;
+      var twoStar = options.noglobstar ? star : options.dot ? twoStarDot : twoStarNoDot;
+      var flags = options.nocase ? "i" : "";
+      var re = set.map(function(pattern) {
+        return pattern.map(function(p) {
+          return p === GLOBSTAR ? twoStar : typeof p === "string" ? regExpEscape(p) : p._src;
+        }).join("\\/");
+      }).join("|");
+      re = "^(?:" + re + ")$";
+      if (this.negate)
+        re = "^(?!" + re + ").*$";
+      try {
+        this.regexp = new RegExp(re, flags);
+      } catch (ex) {
+        this.regexp = false;
+      }
+      return this.regexp;
+    }
+    minimatch2.match = function(list, pattern, options) {
+      options = options || {};
+      var mm = new Minimatch(pattern, options);
+      list = list.filter(function(f) {
+        return mm.match(f);
+      });
+      if (mm.options.nonull && !list.length) {
+        list.push(pattern);
+      }
+      return list;
+    };
+    Minimatch.prototype.match = function match(f, partial) {
+      if (typeof partial === "undefined")
+        partial = this.partial;
+      this.debug("match", f, this.pattern);
+      if (this.comment)
+        return false;
+      if (this.empty)
+        return f === "";
+      if (f === "/" && partial)
+        return true;
+      var options = this.options;
+      if (path6.sep !== "/") {
+        f = f.split(path6.sep).join("/");
+      }
+      f = f.split(slashSplit);
+      this.debug(this.pattern, "split", f);
+      var set = this.set;
+      this.debug(this.pattern, "set", set);
+      var filename;
+      var i;
+      for (i = f.length - 1; i >= 0; i--) {
+        filename = f[i];
+        if (filename)
+          break;
+      }
+      for (i = 0; i < set.length; i++) {
+        var pattern = set[i];
+        var file = f;
+        if (options.matchBase && pattern.length === 1) {
+          file = [filename];
+        }
+        var hit = this.matchOne(file, pattern, partial);
+        if (hit) {
+          if (options.flipNegate)
+            return true;
+          return !this.negate;
+        }
+      }
+      if (options.flipNegate)
+        return false;
+      return this.negate;
+    };
+    Minimatch.prototype.matchOne = function(file, pattern, partial) {
+      var options = this.options;
+      this.debug(
+        "matchOne",
+        { "this": this, file, pattern }
+      );
+      this.debug("matchOne", file.length, pattern.length);
+      for (var fi = 0, pi = 0, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
+        this.debug("matchOne loop");
+        var p = pattern[pi];
+        var f = file[fi];
+        this.debug(pattern, p, f);
+        if (p === false)
+          return false;
+        if (p === GLOBSTAR) {
+          this.debug("GLOBSTAR", [pattern, p, f]);
+          var fr = fi;
+          var pr = pi + 1;
+          if (pr === pl) {
+            this.debug("** at the end");
+            for (; fi < fl; fi++) {
+              if (file[fi] === "." || file[fi] === ".." || !options.dot && file[fi].charAt(0) === ".")
+                return false;
+            }
+            return true;
+          }
+          while (fr < fl) {
+            var swallowee = file[fr];
+            this.debug("\nglobstar while", file, fr, pattern, pr, swallowee);
+            if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
+              this.debug("globstar found match!", fr, fl, swallowee);
+              return true;
+            } else {
+              if (swallowee === "." || swallowee === ".." || !options.dot && swallowee.charAt(0) === ".") {
+                this.debug("dot detected!", file, fr, pattern, pr);
+                break;
+              }
+              this.debug("globstar swallow a segment, and continue");
+              fr++;
+            }
+          }
+          if (partial) {
+            this.debug("\n>>> no match, partial?", file, fr, pattern, pr);
+            if (fr === fl)
+              return true;
+          }
+          return false;
+        }
+        var hit;
+        if (typeof p === "string") {
+          hit = f === p;
+          this.debug("string match", p, f, hit);
+        } else {
+          hit = f.match(p);
+          this.debug("pattern match", p, f, hit);
+        }
+        if (!hit)
+          return false;
+      }
+      if (fi === fl && pi === pl) {
+        return true;
+      } else if (fi === fl) {
+        return partial;
+      } else if (pi === pl) {
+        return fi === fl - 1 && file[fi] === "";
+      }
+      throw new Error("wtf?");
+    };
+    function globUnescape(s) {
+      return s.replace(/\\(.)/g, "$1");
+    }
+    function regExpEscape(s) {
+      return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+    }
+  }
+});
+
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
   MAX_AGE_ONE_YEAR: () => MAX_AGE_ONE_YEAR,
   build: () => build,
   diagnostics: () => diagnostics,
+  getDevManifest: () => getDevManifest,
   htmlContentType: () => htmlContentType,
   prepareCache: () => prepareCache,
   version: () => version
 });
 module.exports = __toCommonJS(src_exports);
-var import_build_utils3 = require("@vercel/build-utils");
+var import_build_utils5 = require("@vercel/build-utils");
 var import_superstatic = __toESM(require_superstatic());
 var import_nft2 = require("@vercel/nft");
 var import_async_sema3 = __toESM(require_lib());
 var import_escape_string_regexp3 = __toESM(require_escape_string_regexp());
 var import_find_up = __toESM(require_find_up());
 var import_fs_extra6 = __toESM(require_lib2());
-var import_path6 = __toESM(require("path"));
+var import_path7 = __toESM(require("path"));
 var import_semver5 = __toESM(require_semver());
 var import_url2 = __toESM(require("url"));
 
@@ -16695,6 +17513,243 @@ ${JSON.stringify(
   };
 }
 
+// src/dev-manifest.ts
+var import_build_utils4 = require("@vercel/build-utils");
+var import_minimatch = __toESM(require_minimatch());
+var import_path6 = require("path");
+
+// src/next-dev-config.ts
+var import_child_process = require("child_process");
+var import_build_utils3 = require("@vercel/build-utils");
+var loader = `
+  const { createRequire } = require('module');
+  const { join } = require('path');
+  const projectRequire = createRequire(join(process.cwd(), 'package.json'));
+  async function load(files) {
+    const nextRequire = createRequire(projectRequire.resolve('next/package.json'));
+    const { PHASE_DEVELOPMENT_SERVER } = nextRequire('next/constants');
+    const { default: loadConfig } = nextRequire('next/dist/server/config');
+    // Older Next versions interpret a third argument as a custom config override.
+    const config = await loadConfig(PHASE_DEVELOPMENT_SERVER, process.cwd());
+    const result = {
+      basePath: config.basePath,
+      pageExtensions: config.pageExtensions,
+      trailingSlash: config.trailingSlash === true,
+      skipTrailingSlashRedirect: config.skipTrailingSlashRedirect === true,
+      caseSensitiveRoutes: config.experimental?.caseSensitiveRoutes === true,
+    };
+    if (files.length) {
+      result.edgeRuntimeFiles = [];
+      const extensions = [...config.pageExtensions].sort((a, b) => b.length - a.length);
+      for (const file of files) {
+        const extension = extensions.find(ext => file.endsWith('.' + ext));
+        if (!extension) continue;
+        const entry = file.slice(0, -extension.length - 1).replace(/^src\\//, '');
+        if (!/^(app\\/(.*\\/)?route|pages\\/api(\\/.*)?)$/.test(entry)) continue;
+        if (entry.includes('[') || entry.split('/').some(part => part.startsWith('@') || (entry.startsWith('app/') && part.startsWith('_')) || /^\\(\\.{1,3}\\)/.test(part))) continue;
+        const router = entry.split('/')[0];
+        if (file.startsWith('src/') && files.some(candidate => candidate.startsWith(router + '/'))) continue;
+        // Next's static analysis reads exports without executing the handler.
+        const { getPageStaticInfo } = nextRequire('next/dist/build/analysis/get-page-static-info');
+        const { runtime } = await getPageStaticInfo({
+          pageFilePath: join(process.cwd(), file),
+          nextConfig: config,
+          isDev: true,
+          page: '/' + entry.split('/').slice(1).join('/'),
+          pageType: entry.startsWith('app/') ? 'app' : 'pages',
+        });
+        if (runtime === 'edge' || runtime === 'experimental-edge') result.edgeRuntimeFiles.push(file);
+      }
+    }
+    process.send(result);
+  }
+  process.once('message', files => load(files).catch(() => process.exit(1)));
+`;
+function loadNextDevRoutingConfig(cwd, env, files = []) {
+  return new Promise((resolve, reject) => {
+    const fail = () => reject(
+      new import_build_utils3.NowBuildError({
+        code: "NEXT_DEV_MANIFEST_CONFIG",
+        message: `Could not load Next.js development configuration in "${cwd}" for manifest discovery. Ensure Node.js and the project's Next.js dependency are installed, and that next dev can load next.config.* and statically analyze route runtime exports with the development environment. Configuration and route metadata must resolve within 10 seconds and return a string basePath and non-empty pageExtensions.`
+      })
+    );
+    let child;
+    try {
+      child = (0, import_child_process.spawn)(
+        (0, import_build_utils3.getNodeExecPath)(),
+        ["--input-type=commonjs", "-e", loader],
+        {
+          cwd,
+          env: { ...env, NODE_ENV: env.NODE_ENV ?? "development" },
+          stdio: ["ignore", "ignore", "ignore", "ipc"],
+          windowsHide: true
+        }
+      );
+    } catch {
+      fail();
+      return;
+    }
+    const timeout = setTimeout(() => {
+      child.kill("SIGKILL");
+      fail();
+    }, 1e4);
+    child.once("error", () => {
+      clearTimeout(timeout);
+      fail();
+    });
+    child.once("exit", () => {
+      clearTimeout(timeout);
+      fail();
+    });
+    child.once("message", (config) => {
+      clearTimeout(timeout);
+      child.kill("SIGKILL");
+      if (!config || typeof config !== "object" || !("basePath" in config) || typeof config.basePath !== "string" || !("pageExtensions" in config) || !Array.isArray(config.pageExtensions) || !config.pageExtensions.length || !config.pageExtensions.every(
+        (ext) => typeof ext === "string" && ext.length > 0
+      ) || "edgeRuntimeFiles" in config && (!Array.isArray(config.edgeRuntimeFiles) || !config.edgeRuntimeFiles.every((file) => typeof file === "string"))) {
+        fail();
+        return;
+      }
+      resolve({
+        basePath: config.basePath,
+        pageExtensions: config.pageExtensions,
+        trailingSlash: "trailingSlash" in config && config.trailingSlash === true,
+        skipTrailingSlashRedirect: "skipTrailingSlashRedirect" in config && config.skipTrailingSlashRedirect === true,
+        caseSensitiveRoutes: "caseSensitiveRoutes" in config && config.caseSensitiveRoutes === true,
+        ..."edgeRuntimeFiles" in config ? { edgeRuntimeFiles: config.edgeRuntimeFiles } : {}
+      });
+    });
+    child.send(files, (error) => {
+      if (error) {
+        clearTimeout(timeout);
+        child.kill("SIGKILL");
+        fail();
+      }
+    });
+  });
+}
+
+// src/dev-manifest.ts
+var getDevManifest = async ({
+  workPath,
+  build: build2,
+  files,
+  config,
+  env
+}) => {
+  const functions = /* @__PURE__ */ new Map();
+  const matchedFunctionPatterns = /* @__PURE__ */ new Set();
+  const entries = Object.entries(config.functions ?? {});
+  const entryDirectory = build2.src ? import_path6.posix.dirname(build2.src) : ".";
+  const prefix = entryDirectory === "." ? "" : `${entryDirectory}/`;
+  const sources = [...new Set(files)].filter((file) => file.startsWith(prefix));
+  let nextConfig;
+  for (const sourceFile of sources) {
+    const relativeFile = sourceFile.slice(prefix.length);
+    if (!/^(?:src\/)?(?:app|pages)\//.test(relativeFile))
+      continue;
+    const matched = entries.find(
+      ([pattern2]) => sourceFile === pattern2 || (0, import_minimatch.default)(sourceFile, pattern2)
+    );
+    const pattern = matched?.[0];
+    const hasTriggers = !!matched?.[1].experimentalTriggers?.length;
+    nextConfig ??= await loadNextDevRoutingConfig(
+      (0, import_path6.join)(workPath, entryDirectory),
+      env,
+      sources.map((file2) => file2.slice(prefix.length))
+    );
+    const file = relativeFile.replace(/^src\//, "");
+    const extension = [...nextConfig.pageExtensions].sort((a, b) => b.length - a.length).find((ext) => file.endsWith(`.${ext}`));
+    const extensionless = extension ? file.slice(0, -extension.length - 1) : "";
+    const isPagesApi = /^pages\/api(?:\/.+)?$/.test(extensionless);
+    const isAppRoute = /^app\/(?:.+\/)?route$/.test(extensionless);
+    const isPage = extensionless.startsWith("pages/") || /^app\/(?:.+\/)?page$/.test(extensionless);
+    if (!isPagesApi && !isAppRoute && !isPage && pattern !== sourceFile) {
+      continue;
+    }
+    const routerDirectory = file.split("/")[0];
+    if (relativeFile.startsWith("src/") && sources.some(
+      (candidate) => candidate.startsWith(`${prefix}${routerDirectory}/`)
+    )) {
+      if (!hasTriggers)
+        continue;
+      throw new import_build_utils4.NowBuildError({
+        code: "NEXT_DEV_MANIFEST_FUNCTION_UNSUPPORTED",
+        message: `Cannot include "${sourceFile}" in the development manifest: Next.js uses the root ${routerDirectory} directory instead of src/${routerDirectory}. Move the handler and its functions configuration to the active router directory.`
+      });
+    }
+    let pathname;
+    if (isPagesApi) {
+      pathname = extensionless.replace(/^pages/, "").replace(/\/index$/, "");
+    } else if (isAppRoute && !file.split("/").some((segment) => segment.startsWith("_"))) {
+      pathname = `/${file.split("/").slice(1, -1).filter((segment) => !(segment.startsWith("(") && segment.endsWith(")"))).join("/")}`;
+    }
+    if (!pathname || !/^\/(?:[A-Za-z0-9_.-]+(?:\/[A-Za-z0-9_.-]+)*)?$/.test(pathname) || pathname.split("/").some((segment) => segment === "." || segment === "..")) {
+      if (!hasTriggers)
+        continue;
+      throw new import_build_utils4.NowBuildError({
+        code: "NEXT_DEV_MANIFEST_FUNCTION_UNSUPPORTED",
+        message: `Cannot include "${sourceFile}" in the development manifest. Configure a static Next.js App Router route handler (app/**/route.*) or Pages API route (pages/api.* or pages/api/**) matching pageExtensions. Dynamic, private, parallel, and intercepted routes and rendered pages are not supported.`
+      });
+    }
+    if (nextConfig.basePath && entryDirectory !== ".") {
+      throw new import_build_utils4.NowBuildError({
+        code: "NEXT_BASEPATH_LEGACY_BUILDS",
+        message: "basePath can not be used with `builds` in vercel.json, use Project Settings to configure your monorepo instead"
+      });
+    }
+    const outputDirectory = import_path6.posix.join(entryDirectory, nextConfig.basePath);
+    const outputName = import_path6.posix.join(
+      outputDirectory,
+      pathname === "/" ? "index" : pathname
+    );
+    let outputPath = isPagesApi ? normalizeIndexOutput(outputName, true) : outputName;
+    if (nextConfig.edgeRuntimeFiles?.includes(relativeFile)) {
+      outputPath = import_path6.posix.join(
+        ".",
+        nextConfig.basePath,
+        pathname === "/" ? "index" : pathname
+      );
+      if (nextConfig.basePath) {
+        outputPath = normalizeIndexOutput(outputPath, true);
+      }
+    }
+    const existing = functions.get(outputPath);
+    if (existing) {
+      throw new import_build_utils4.NowBuildError({
+        code: "NEXT_DEV_MANIFEST_FUNCTION_COLLISION",
+        message: `Next.js sources "${existing.sourceFile}" and "${sourceFile}" resolve to the same development manifest output "${outputPath}". Each function must have a unique deployment output identity.`
+      });
+    }
+    const { experimentalTriggers } = await (0, import_build_utils4.getLambdaOptionsFromFunction)({
+      sourceFile,
+      config
+    });
+    let invocationPathname = `${nextConfig.basePath}${pathname === "/" ? "" : pathname}` || "/";
+    if (nextConfig.trailingSlash && !nextConfig.skipTrailingSlashRedirect && (pathname === "/" && nextConfig.basePath || new RegExp(
+      "^/(?!\\.well-known(?:/.*)?)(?:[^/]+/)*[^/\\.]+$",
+      nextConfig.caseSensitiveRoutes ? "" : "i"
+    ).test(invocationPathname))) {
+      invocationPathname += "/";
+    }
+    functions.set(outputPath, {
+      outputPath,
+      sourceFile,
+      invocation: {
+        type: "http",
+        pathname: invocationPathname
+      },
+      ...experimentalTriggers === void 0 ? {} : { experimentalTriggers }
+    });
+    if (pattern)
+      matchedFunctionPatterns.add(pattern);
+  }
+  return {
+    functions: [...functions.values()],
+    matchedFunctionPatterns: [...matchedFunctionPatterns]
+  };
+};
+
 // src/index.ts
 var version = 2;
 var htmlContentType = "text/html; charset=utf-8";
@@ -16705,23 +17760,23 @@ var IS_APP_CLIENT_SEGMENT_CACHE_ENABLED_VERSION = "v16.0.0";
 var MINIMUM_NEXT_ADAPTER_VERSION = "v16.2.0-canary.28";
 var MAX_AGE_ONE_YEAR = 31536e3;
 async function readPackageJson(entryPath) {
-  const packagePath = import_path6.default.join(entryPath, "package.json");
+  const packagePath = import_path7.default.join(entryPath, "package.json");
   try {
     return JSON.parse(await (0, import_fs_extra6.readFile)(packagePath, "utf8"));
   } catch (_err) {
-    (0, import_build_utils3.debug)("package.json not found in entry");
+    (0, import_build_utils5.debug)("package.json not found in entry");
     return {};
   }
 }
 async function writePackageJson(workPath, packageJson) {
   await (0, import_fs_extra6.writeFile)(
-    import_path6.default.join(workPath, "package.json"),
+    import_path7.default.join(workPath, "package.json"),
     JSON.stringify(packageJson, null, 2)
   );
 }
 async function writeNpmRc(workPath, token) {
   await (0, import_fs_extra6.writeFile)(
-    import_path6.default.join(workPath, ".npmrc"),
+    import_path7.default.join(workPath, ".npmrc"),
     `//registry.npmjs.org/:_authToken=${token}`
   );
 }
@@ -16765,7 +17820,7 @@ function isLegacyNext(nextVersion) {
 }
 var build = async (buildOptions) => {
   let { workPath, repoRootPath } = buildOptions;
-  const builderSpan = buildOptions.span ?? new import_build_utils3.Span({ name: "vc.builder" });
+  const builderSpan = buildOptions.span ?? new import_build_utils5.Span({ name: "vc.builder" });
   const {
     files,
     entrypoint,
@@ -16774,16 +17829,16 @@ var build = async (buildOptions) => {
     buildCallback
   } = buildOptions;
   validateEntrypoint(entrypoint);
-  let entryDirectory = import_path6.default.dirname(entrypoint);
-  let entryPath = import_path6.default.join(workPath, entryDirectory);
+  let entryDirectory = import_path7.default.dirname(entrypoint);
+  let entryPath = import_path7.default.join(workPath, entryDirectory);
   if (config.rootDirectory) {
     repoRootPath = entryPath;
-    entryPath = import_path6.default.join(entryPath, config.rootDirectory);
+    entryPath = import_path7.default.join(entryPath, config.rootDirectory);
   }
-  const outputDirectory = import_path6.default.join("./", config.outputDirectory || ".next");
-  const dotNextStatic = import_path6.default.join(entryPath, outputDirectory, "static");
+  const outputDirectory = import_path7.default.join("./", config.outputDirectory || ".next");
+  const dotNextStatic = import_path7.default.join(entryPath, outputDirectory, "static");
   const baseDir = repoRootPath || workPath;
-  (0, import_build_utils3.debug)(
+  (0, import_build_utils5.debug)(
     JSON.stringify(
       {
         repoRootPath,
@@ -16797,20 +17852,20 @@ var build = async (buildOptions) => {
       2
     )
   );
-  const prefixedEnvs = (0, import_build_utils3.getPrefixedEnvVars)({
+  const prefixedEnvs = (0, import_build_utils5.getPrefixedEnvVars)({
     envPrefix: "NEXT_PUBLIC_",
     envs: process.env
   });
   for (const [key, value] of Object.entries(prefixedEnvs)) {
     process.env[key] = value;
   }
-  await (0, import_build_utils3.download)(files, workPath, meta);
+  await (0, import_build_utils5.download)(files, workPath, meta);
   if (config.rootDirectory) {
-    workPath = import_path6.default.join(workPath, config.rootDirectory);
+    workPath = import_path7.default.join(workPath, config.rootDirectory);
   }
   let pkg = await readPackageJson(entryPath);
   const nextVersionRange = await getNextVersionRange(entryPath);
-  const nodeVersion = await (0, import_build_utils3.getNodeVersion)(entryPath, void 0, config, meta);
+  const nodeVersion = await (0, import_build_utils5.getNodeVersion)(entryPath, void 0, config, meta);
   const {
     cliType,
     lockfilePath,
@@ -16818,8 +17873,8 @@ var build = async (buildOptions) => {
     packageJsonPackageManager,
     packageJsonDevEngines,
     turboSupportsCorepackHome
-  } = await (0, import_build_utils3.scanParentDirs)(entryPath, true);
-  const spawnEnv = (0, import_build_utils3.getEnvForPackageManager)({
+  } = await (0, import_build_utils5.scanParentDirs)(entryPath, true);
+  const spawnEnv = (0, import_build_utils5.getEnvForPackageManager)({
     cliType,
     lockfileVersion,
     packageJsonPackageManager,
@@ -16838,21 +17893,21 @@ var build = async (buildOptions) => {
     console.warn("WARNING: You should not upload the `.next` directory.");
   }
   const isLegacy = nextVersionRange && isLegacyNext(nextVersionRange);
-  (0, import_build_utils3.debug)(`MODE: ${isLegacy ? "legacy" : "server(less)"}`);
+  (0, import_build_utils5.debug)(`MODE: ${isLegacy ? "legacy" : "server(less)"}`);
   if (isLegacy) {
     console.warn(
       "WARNING: your application is being deployed in @vercel/next's legacy mode. http://err.sh/vercel/vercel/now-next-legacy-mode"
     );
     await Promise.all([
-      (0, import_fs_extra6.remove)(import_path6.default.join(entryPath, "yarn.lock")),
-      (0, import_fs_extra6.remove)(import_path6.default.join(entryPath, "package-lock.json"))
+      (0, import_fs_extra6.remove)(import_path7.default.join(entryPath, "yarn.lock")),
+      (0, import_fs_extra6.remove)(import_path7.default.join(entryPath, "package-lock.json"))
     ]);
-    (0, import_build_utils3.debug)("Normalizing package.json");
+    (0, import_build_utils5.debug)("Normalizing package.json");
     pkg = normalizePackageJson(pkg);
-    (0, import_build_utils3.debug)("Normalized package.json result: ", pkg);
+    (0, import_build_utils5.debug)("Normalized package.json result: ", pkg);
     await writePackageJson(entryPath, pkg);
   }
-  let buildScriptName = (0, import_build_utils3.getScriptName)(pkg, [
+  let buildScriptName = (0, import_build_utils5.getScriptName)(pkg, [
     "vercel-build",
     "now-build",
     "build"
@@ -16872,10 +17927,10 @@ var build = async (buildOptions) => {
     buildScriptName = "vercel-build";
   }
   if (process.env.NPM_AUTH_TOKEN) {
-    (0, import_build_utils3.debug)("Found NPM_AUTH_TOKEN in environment, creating .npmrc");
+    (0, import_build_utils5.debug)("Found NPM_AUTH_TOKEN in environment, creating .npmrc");
     await writeNpmRc(entryPath, process.env.NPM_AUTH_TOKEN);
   }
-  const { detectedPackageManager } = (0, import_build_utils3.detectPackageManager)(
+  const { detectedPackageManager } = (0, import_build_utils5.detectPackageManager)(
     cliType,
     lockfileVersion,
     config.projectSettings?.createdAt
@@ -16890,7 +17945,7 @@ var build = async (buildOptions) => {
     install: JSON.stringify(shouldRunInstallCommand)
   });
   if (shouldRunInstallCommand) {
-    await builderSpan.child(import_build_utils3.BUILDER_INSTALLER_STEP, {
+    await builderSpan.child(import_build_utils5.BUILDER_INSTALLER_STEP, {
       cliType,
       lockfileVersion: lockfileVersion?.toString(),
       packageJsonPackageManager,
@@ -16901,12 +17956,12 @@ var build = async (buildOptions) => {
         console.log(
           `Running "install" command: \`${trimmedInstallCommand}\`...`
         );
-        await (0, import_build_utils3.execCommand)(trimmedInstallCommand, {
+        await (0, import_build_utils5.execCommand)(trimmedInstallCommand, {
           env: spawnEnv,
           cwd: entryPath
         });
       } else {
-        await (0, import_build_utils3.runNpmInstall)(
+        await (0, import_build_utils5.runNpmInstall)(
           entryPath,
           [],
           { env: spawnEnv },
@@ -16919,22 +17974,22 @@ var build = async (buildOptions) => {
     console.log(`Skipping "install" command...`);
   }
   if (spawnEnv.VERCEL_ANALYTICS_ID) {
-    (0, import_build_utils3.debug)("Found VERCEL_ANALYTICS_ID in environment");
-    const version2 = await (0, import_build_utils3.getInstalledPackageVersion)(
+    (0, import_build_utils5.debug)("Found VERCEL_ANALYTICS_ID in environment");
+    const version2 = await (0, import_build_utils5.getInstalledPackageVersion)(
       "@vercel/speed-insights",
       entryPath
     );
     if (version2) {
       delete spawnEnv.VERCEL_ANALYTICS_ID;
       delete process.env.VERCEL_ANALYTICS_ID;
-      (0, import_build_utils3.debug)(
+      (0, import_build_utils5.debug)(
         "@vercel/speed-insights is installed, removing VERCEL_ANALYTICS_ID from environment"
       );
     }
   }
   const nextVersion = getRealNextVersion(entryPath);
   if (!nextVersion) {
-    throw new import_build_utils3.NowBuildError({
+    throw new import_build_utils5.NowBuildError({
       code: "NEXT_NO_VERSION",
       message: 'No Next.js version detected. Make sure your package.json has "next" in either "dependencies" or "devDependencies". Also check your Root Directory setting matches the directory of your package.json file.'
     });
@@ -16946,7 +18001,7 @@ var build = async (buildOptions) => {
   );
   const isCorrectLocaleAPIRoutes = import_semver5.default.gte(nextVersion, "v11.0.2-canary.3");
   if (isServerMode) {
-    (0, import_build_utils3.debug)(
+    (0, import_build_utils5.debug)(
       `Application is being built in server mode since ${nextVersion} meets minimum version of ${SERVER_BUILD_MINIMUM_NEXT_VERSION}`
     );
   } else {
@@ -16955,7 +18010,7 @@ var build = async (buildOptions) => {
       if (Array.isArray(nowJsonData.routes) && nowJsonData.routes.length > 0) {
         hasLegacyRoutes = true;
         console.warn(
-          `WARNING: your application is being opted out of @vercel/next's optimized lambdas mode due to legacy routes in ${import_path6.default.basename(
+          `WARNING: your application is being opted out of @vercel/next's optimized lambdas mode due to legacy routes in ${import_path7.default.basename(
             nowJsonPath
           )}. http://err.sh/vercel/vercel/next-legacy-routes-optimized-lambdas`
         );
@@ -16989,7 +18044,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
     !process.env.NEXT_BUILDER_INTEGRATION && process.env.NEXT_ENABLE_ADAPTER === "1" && import_semver5.default.gte(nextVersion, MINIMUM_NEXT_ADAPTER_VERSION)
   );
   if (isAdapterEnabled) {
-    env.NEXT_ADAPTER_PATH = import_path6.default.join(__dirname, "adapter/index.js");
+    env.NEXT_ADAPTER_PATH = import_path7.default.join(__dirname, "adapter/index.js");
     env.NEXT_ADAPTER_VERCEL_CONFIG = JSON.stringify(config);
   } else {
     const defaultNextDeploymentId = getDefaultNextDeploymentId(env);
@@ -17002,30 +18057,30 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
     build: JSON.stringify(shouldRunCompileStep)
   });
   if (shouldRunCompileStep) {
-    await builderSpan.child(import_build_utils3.BUILDER_COMPILE_STEP, {
+    await builderSpan.child(import_build_utils5.BUILDER_COMPILE_STEP, {
       buildCommand,
       buildScriptName
     }).trace(async () => {
       if (buildCommand) {
-        const nodeBinPaths = (0, import_build_utils3.getNodeBinPaths)({
+        const nodeBinPaths = (0, import_build_utils5.getNodeBinPaths)({
           start: entryPath,
           base: repoRootPath
         });
-        const nodeBinPath = nodeBinPaths.join(import_path6.default.delimiter);
-        env.PATH = `${nodeBinPath}${import_path6.default.delimiter}${env.PATH}`;
+        const nodeBinPath = nodeBinPaths.join(import_path7.default.delimiter);
+        env.PATH = `${nodeBinPath}${import_path7.default.delimiter}${env.PATH}`;
         if (!env.YARN_NODE_LINKER) {
           env.YARN_NODE_LINKER = "node-modules";
         }
-        (0, import_build_utils3.debug)(
+        (0, import_build_utils5.debug)(
           `Added "${nodeBinPath}" to PATH env because a build command was used.`
         );
         console.log(`Running "${buildCommand}"`);
-        await (0, import_build_utils3.execCommand)(buildCommand, {
+        await (0, import_build_utils5.execCommand)(buildCommand, {
           cwd: entryPath,
           env
         });
       } else if (buildScriptName) {
-        await (0, import_build_utils3.runPackageJsonScript)(
+        await (0, import_build_utils5.runPackageJsonScript)(
           entryPath,
           buildScriptName,
           {
@@ -17035,7 +18090,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         );
       }
     });
-    (0, import_build_utils3.debug)("build command exited");
+    (0, import_build_utils5.debug)("build command exited");
   } else {
     console.log(`Skipping "build" command...`);
   }
@@ -17043,39 +18098,39 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
     await buildCallback(buildOptions);
   }
   try {
-    await (0, import_build_utils3.generateProjectManifest)({
+    await (0, import_build_utils5.generateProjectManifest)({
       workPath,
       nodeVersion,
       cliType,
       lockfilePath,
       lockfileVersion,
       framework: config.framework ?? void 0,
-      serviceType: buildOptions.service ? (0, import_build_utils3.getReportedServiceType)(buildOptions.service) : void 0
+      serviceType: buildOptions.service ? (0, import_build_utils5.getReportedServiceType)(buildOptions.service) : void 0
     });
   } catch (err) {
-    (0, import_build_utils3.debug)(
+    (0, import_build_utils5.debug)(
       `Failed to write next manifest: ${err instanceof Error ? err.message : String(err)}`
     );
   }
   let buildOutputVersion;
   try {
     const data = await (0, import_fs_extra6.readJSON)(
-      import_path6.default.join(entryPath, outputDirectory, "output/config.json")
+      import_path7.default.join(entryPath, outputDirectory, "output/config.json")
     );
     buildOutputVersion = data.version;
   } catch (_) {
   }
   if (buildOutputVersion) {
-    const publicDir = import_path6.default.join(entryPath, "public");
-    const staticOutputDir = import_path6.default.join(
+    const publicDir = import_path7.default.join(entryPath, "public");
+    const staticOutputDir = import_path7.default.join(
       entryPath,
       outputDirectory,
       "output/static"
     );
     if (await (0, import_fs_extra6.pathExists)(publicDir)) {
-      const publicFiles = await (0, import_build_utils3.glob)("**/*", publicDir);
+      const publicFiles = await (0, import_build_utils5.glob)("**/*", publicDir);
       for (const fileName of Object.keys(publicFiles)) {
-        const destPath = import_path6.default.join(staticOutputDir, fileName);
+        const destPath = import_path7.default.join(staticOutputDir, fileName);
         if (!await (0, import_fs_extra6.pathExists)(destPath)) {
           const srcPath = publicFiles[fileName].fsPath;
           await (0, import_fs_extra6.copy)(srcPath, destPath);
@@ -17083,15 +18138,15 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
       }
     }
     return {
-      buildOutputPath: import_path6.default.join(entryPath, outputDirectory, "output"),
+      buildOutputPath: import_path7.default.join(entryPath, outputDirectory, "output"),
       buildOutputVersion,
       framework: { slug: "nextjs", version: nextVersion }
     };
   }
-  const absoluteOutputDirectory = import_path6.default.join(entryPath, outputDirectory);
+  const absoluteOutputDirectory = import_path7.default.join(entryPath, outputDirectory);
   const outputDirExists = await (0, import_fs_extra6.pathExists)(absoluteOutputDirectory);
   if (!outputDirExists) {
-    throw new import_build_utils3.NowBuildError({
+    throw new import_build_utils5.NowBuildError({
       code: "NEXT_OUTPUT_DIR_MISSING",
       message: `The Next.js output directory "${outputDirectory}" was not found at "${absoluteOutputDirectory}". This is usually caused by one of the following:
 
@@ -17105,7 +18160,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
   }
   const outputDirContents = await (0, import_fs_extra6.readdir)(absoluteOutputDirectory);
   if (outputDirContents.length === 0) {
-    throw new import_build_utils3.NowBuildError({
+    throw new import_build_utils5.NowBuildError({
       code: "NEXT_OUTPUT_DIR_EMPTY",
       message: `The Next.js output directory "${outputDirectory}" exists but is empty. This is usually caused by one of the following:
 
@@ -17117,7 +18172,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
       link: "https://err.sh/vercel/vercel/now-next-routes-manifest"
     });
   }
-  let appMountPrefixNoTrailingSlash = import_path6.default.posix.join("/", entryDirectory).replace(/\/+$/, "");
+  let appMountPrefixNoTrailingSlash = import_path7.default.posix.join("/", entryDirectory).replace(/\/+$/, "");
   const requiredServerFilesManifest = isServerMode ? await getRequiredServerFilesManifest(entryPath, outputDirectory) : false;
   isServerMode = Boolean(requiredServerFilesManifest);
   const functionsConfigManifest = await getFunctionsConfigManifest(
@@ -17141,8 +18196,8 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
   const omittedPrerenderRoutes = new Set(
     Object.keys(prerenderManifest.omittedRoutes)
   );
-  const hasIsr404Page = typeof prerenderManifest.staticRoutes[routesManifest?.i18n ? import_path6.default.join("/", routesManifest?.i18n.defaultLocale, "/404") : "/404"]?.initialRevalidate === "number";
-  const hasIsr500Page = typeof prerenderManifest.staticRoutes[routesManifest?.i18n ? import_path6.default.join("/", routesManifest?.i18n.defaultLocale, "/500") : "/500"]?.initialRevalidate === "number";
+  const hasIsr404Page = typeof prerenderManifest.staticRoutes[routesManifest?.i18n ? import_path7.default.join("/", routesManifest?.i18n.defaultLocale, "/404") : "/404"]?.initialRevalidate === "number";
+  const hasIsr500Page = typeof prerenderManifest.staticRoutes[routesManifest?.i18n ? import_path7.default.join("/", routesManifest?.i18n.defaultLocale, "/500") : "/500"]?.initialRevalidate === "number";
   const wildcardConfig = routesManifest?.i18n?.domains && routesManifest.i18n.domains.length > 0 ? routesManifest.i18n.domains.map((item) => {
     return {
       domain: item.domain,
@@ -17150,7 +18205,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
     };
   }) : void 0;
   const privateOutputs = await getPrivateOutputs(
-    import_path6.default.join(entryPath, outputDirectory),
+    import_path7.default.join(entryPath, outputDirectory),
     {
       "next-stats.json": "_next/__private/stats.json",
       trace: "_next/__private/trace"
@@ -17171,12 +18226,12 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
   if (isLegacy || isSharedLambdas || isServerMode) {
     try {
       buildId = await (0, import_fs_extra6.readFile)(
-        import_path6.default.join(entryPath, outputDirectory, "BUILD_ID"),
+        import_path7.default.join(entryPath, outputDirectory, "BUILD_ID"),
         "utf8"
       );
       escapedBuildId = (0, import_escape_string_regexp3.default)(buildId);
     } catch (_err) {
-      throw new import_build_utils3.NowBuildError({
+      throw new import_build_utils5.NowBuildError({
         code: "NOW_NEXT_NO_BUILD_ID",
         message: 'The BUILD_ID file was not found in the Output Directory. Did you forget to run "next build" in your Build Command?'
       });
@@ -17260,26 +18315,26 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         if (routesManifest.basePath && routesManifest.basePath !== "/") {
           const nextBasePath = routesManifest.basePath;
           if (!nextBasePath.startsWith("/")) {
-            throw new import_build_utils3.NowBuildError({
+            throw new import_build_utils5.NowBuildError({
               code: "NEXT_BASEPATH_STARTING_SLASH",
               message: "basePath must start with `/`. Please upgrade your `@vercel/next` builder and try again. Contact support if this continues to happen."
             });
           }
           if (nextBasePath.endsWith("/")) {
-            throw new import_build_utils3.NowBuildError({
+            throw new import_build_utils5.NowBuildError({
               code: "NEXT_BASEPATH_TRAILING_SLASH",
               message: "basePath must not end with `/`. Please upgrade your `@vercel/next` builder and try again. Contact support if this continues to happen."
             });
           }
           if (entryDirectory.length > 1) {
-            throw new import_build_utils3.NowBuildError({
+            throw new import_build_utils5.NowBuildError({
               code: "NEXT_BASEPATH_LEGACY_BUILDS",
               message: "basePath can not be used with `builds` in vercel.json, use Project Settings to configure your monorepo instead",
               link: "https://vercel.com/docs/platform/projects#project-settings"
             });
           }
-          entryDirectory = import_path6.default.join(entryDirectory, nextBasePath);
-          appMountPrefixNoTrailingSlash = import_path6.default.posix.join("/", entryDirectory).replace(/\/+$/, "");
+          entryDirectory = import_path7.default.join(entryDirectory, nextBasePath);
+          appMountPrefixNoTrailingSlash = import_path7.default.posix.join("/", entryDirectory).replace(/\/+$/, "");
         }
         if (routesManifest.pages404) {
           hasPages404 = true;
@@ -17287,69 +18342,69 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         break;
       }
       default: {
-        throw new import_build_utils3.NowBuildError({
+        throw new import_build_utils5.NowBuildError({
           code: "NEXT_VERSION_OUTDATED",
           message: "This version of `@vercel/next` does not support the version of Next.js you are trying to deploy.\nPlease upgrade your `@vercel/next` builder and try again. Contact support if this continues to happen."
         });
       }
     }
   }
-  let dynamicPrefix = import_path6.default.posix.join("/", entryDirectory);
+  let dynamicPrefix = import_path7.default.posix.join("/", entryDirectory);
   dynamicPrefix = dynamicPrefix === "/" ? "" : dynamicPrefix;
   if (imagesManifest) {
     switch (imagesManifest.version) {
       case 1: {
         if (!imagesManifest.images) {
-          throw new import_build_utils3.NowBuildError({
+          throw new import_build_utils5.NowBuildError({
             code: "NEXT_IMAGES_MISSING",
             message: 'image-manifest.json "images" is required. Contact support if this continues to happen.'
           });
         }
         const { images } = imagesManifest;
         if (!Array.isArray(images.domains)) {
-          throw new import_build_utils3.NowBuildError({
+          throw new import_build_utils5.NowBuildError({
             code: "NEXT_IMAGES_DOMAINS",
             message: 'image-manifest.json "images.domains" must be an array. Contact support if this continues to happen.'
           });
         }
         if (!Array.isArray(images.sizes)) {
-          throw new import_build_utils3.NowBuildError({
+          throw new import_build_utils5.NowBuildError({
             code: "NEXT_IMAGES_SIZES",
             message: 'image-manifest.json "images.sizes" must be an array. Contact support if this continues to happen.'
           });
         }
         if (images.remotePatterns && !Array.isArray(images.remotePatterns)) {
-          throw new import_build_utils3.NowBuildError({
+          throw new import_build_utils5.NowBuildError({
             code: "NEXT_IMAGES_REMOTEPATTERNS",
             message: 'image-manifest.json "images.remotePatterns" must be an array. Contact support if this continues to happen'
           });
         }
         if (images.localPatterns && !Array.isArray(images.localPatterns)) {
-          throw new import_build_utils3.NowBuildError({
+          throw new import_build_utils5.NowBuildError({
             code: "NEXT_IMAGES_LOCALPATTERNS",
             message: 'image-manifest.json "images.localPatterns" must be an array. Contact support if this continues to happen'
           });
         }
         if (images.minimumCacheTTL && !Number.isInteger(images.minimumCacheTTL)) {
-          throw new import_build_utils3.NowBuildError({
+          throw new import_build_utils5.NowBuildError({
             code: "NEXT_IMAGES_MINIMUMCACHETTL",
             message: 'image-manifest.json "images.minimumCacheTTL" must be an integer. Contact support if this continues to happen.'
           });
         }
         if (images.qualities && !Array.isArray(images.qualities)) {
-          throw new import_build_utils3.NowBuildError({
+          throw new import_build_utils5.NowBuildError({
             code: "NEXT_IMAGES_QUALITIES",
             message: 'image-manifest.json "images.qualities" must be an array. Contact support if this continues to happen.'
           });
         }
         if (typeof images.dangerouslyAllowSVG !== "undefined" && typeof images.dangerouslyAllowSVG !== "boolean") {
-          throw new import_build_utils3.NowBuildError({
+          throw new import_build_utils5.NowBuildError({
             code: "NEXT_IMAGES_DANGEROUSLYALLOWSVG",
             message: 'image-manifest.json "images.dangerouslyAllowSVG" must be a boolean. Contact support if this continues to happen.'
           });
         }
         if (typeof images.contentSecurityPolicy !== "undefined" && typeof images.contentSecurityPolicy !== "string") {
-          throw new import_build_utils3.NowBuildError({
+          throw new import_build_utils5.NowBuildError({
             code: "NEXT_IMAGES_CONTENTSECURITYPOLICY",
             message: 'image-manifest.json "images.contentSecurityPolicy" must be a string. Contact support if this continues to happen.'
           });
@@ -17357,7 +18412,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         break;
       }
       default: {
-        throw new import_build_utils3.NowBuildError({
+        throw new import_build_utils5.NowBuildError({
           code: "NEXT_IMAGES_VERSION_UNKNOWN",
           message: "This version of `@vercel/next` does not support the version of Next.js you are trying to deploy.\nPlease upgrade your `@vercel/next` builder and try again. Contact support if this continues to happen."
         });
@@ -17370,20 +18425,20 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
     const { trailingSlash: trailingSlash2 = false } = exportIntent || {};
     const resultingExport = await getExportStatus(entryPath);
     if (!resultingExport) {
-      throw new import_build_utils3.NowBuildError({
+      throw new import_build_utils5.NowBuildError({
         code: "NEXT_EXPORT_FAILED",
         message: "Exporting Next.js app failed. Please check your build logs and contact us if this continues."
       });
     }
     if (resultingExport.success !== true) {
-      throw new import_build_utils3.NowBuildError({
+      throw new import_build_utils5.NowBuildError({
         code: "NEXT_EXPORT_FAILED",
         message: "Export of Next.js app failed. Please check your build logs."
       });
     }
     const outDirectory = resultingExport.outDirectory;
-    (0, import_build_utils3.debug)(`next export should use trailing slash: ${trailingSlash2}`);
-    const filesAfterBuild = await (0, import_build_utils3.glob)("**", outDirectory);
+    (0, import_build_utils5.debug)(`next export should use trailing slash: ${trailingSlash2}`);
+    const filesAfterBuild = await (0, import_build_utils5.glob)("**", outDirectory);
     const output = {
       ...filesAfterBuild,
       ...privateOutputs.files
@@ -17409,7 +18464,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         ...beforeFilesRewrites,
         // Make sure to 404 for the /404 path itself
         {
-          src: import_path6.default.posix.join("/", entryDirectory, "404/?"),
+          src: import_path7.default.posix.join("/", entryDirectory, "404/?"),
           status: 404,
           continue: true
         },
@@ -17420,7 +18475,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         // _next/image path
         ...routesManifest?.basePath ? [
           {
-            src: import_path6.default.posix.join("/", entryDirectory, "_next/image/?"),
+            src: import_path7.default.posix.join("/", entryDirectory, "_next/image/?"),
             dest: "/_next/image",
             check: true
           }
@@ -17428,12 +18483,12 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         // No-op _next/data rewrite to trigger handle: 'rewrites' and then 404
         // if no match to prevent rewriting _next/data unexpectedly
         {
-          src: import_path6.default.posix.join("/", entryDirectory, "_next/data/(.*)"),
-          dest: import_path6.default.posix.join("/", entryDirectory, "_next/data/$1"),
+          src: import_path7.default.posix.join("/", entryDirectory, "_next/data/(.*)"),
+          dest: import_path7.default.posix.join("/", entryDirectory, "_next/data/$1"),
           check: true
         },
         {
-          src: import_path6.default.posix.join("/", entryDirectory, "_next/data/(.*)"),
+          src: import_path7.default.posix.join("/", entryDirectory, "_next/data/(.*)"),
           status: 404
         },
         // These need to come before handle: miss or else they are grouped
@@ -17443,16 +18498,16 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         // an index page
         { handle: "resource" },
         ...fallbackRewrites,
-        { src: import_path6.default.posix.join("/", entryDirectory, ".*"), status: 404 },
+        { src: import_path7.default.posix.join("/", entryDirectory, ".*"), status: 404 },
         // 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: import_path6.default.posix.join("/", entryDirectory, "_next/static/.+"),
+          src: import_path7.default.posix.join("/", entryDirectory, "_next/static/.+"),
           status: 404,
           check: true,
-          dest: import_path6.default.posix.join(
+          dest: import_path7.default.posix.join(
             "/",
             entryDirectory,
             "_next/static/not-found.txt"
@@ -17470,7 +18525,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         {
           // This ensures we only match known emitted-by-Next.js files and not
           // user-emitted files which may be missing a hash in their filename.
-          src: import_path6.default.posix.join(
+          src: import_path7.default.posix.join(
             "/",
             entryDirectory,
             `_next/static/(?:[^/]+/pages|pages|chunks|runtime|css|image|media|${escapedBuildId})/.+`
@@ -17485,12 +18540,12 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         },
         ...onMatchHeaders,
         // error handling
-        ...output[import_path6.default.posix.join("./", entryDirectory, "404")] || output[import_path6.default.posix.join("./", entryDirectory, "404/index")] ? [
+        ...output[import_path7.default.posix.join("./", entryDirectory, "404")] || output[import_path7.default.posix.join("./", entryDirectory, "404/index")] ? [
           { handle: "error" },
           {
             status: 404,
-            src: import_path6.default.posix.join(entryDirectory, ".*"),
-            dest: import_path6.default.posix.join("/", entryDirectory, "404")
+            src: import_path7.default.posix.join(entryDirectory, ".*"),
+            dest: import_path7.default.posix.join("/", entryDirectory, "404")
           }
         ] : []
       ],
@@ -17499,8 +18554,8 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
     };
   }
   if (isLegacy) {
-    (0, import_build_utils3.debug)("Running npm install --production...");
-    await (0, import_build_utils3.runNpmInstall)(
+    (0, import_build_utils5.debug)("Running npm install --production...");
+    await (0, import_build_utils5.runNpmInstall)(
       entryPath,
       ["--production"],
       {
@@ -17511,7 +18566,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
     );
   }
   if (process.env.NPM_AUTH_TOKEN) {
-    await (0, import_fs_extra6.remove)(import_path6.default.join(entryPath, ".npmrc"));
+    await (0, import_fs_extra6.remove)(import_path7.default.join(entryPath, ".npmrc"));
   }
   const trailingSlashRedirects = [];
   let trailingSlash = false;
@@ -17540,15 +18595,15 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
   let page404Path = "";
   let hasStatic500;
   if (isLegacy) {
-    const filesAfterBuild = await (0, import_build_utils3.glob)("**", entryPath);
-    (0, import_build_utils3.debug)("Preparing serverless function files...");
-    const dotNextRootFiles = await (0, import_build_utils3.glob)(`${outputDirectory}/*`, entryPath);
-    const dotNextServerRootFiles = await (0, import_build_utils3.glob)(
+    const filesAfterBuild = await (0, import_build_utils5.glob)("**", entryPath);
+    (0, import_build_utils5.debug)("Preparing serverless function files...");
+    const dotNextRootFiles = await (0, import_build_utils5.glob)(`${outputDirectory}/*`, entryPath);
+    const dotNextServerRootFiles = await (0, import_build_utils5.glob)(
       `${outputDirectory}/server/*`,
       entryPath
     );
     const nodeModules = excludeFiles(
-      await (0, import_build_utils3.glob)("node_modules/**", entryPath),
+      await (0, import_build_utils5.glob)("node_modules/**", entryPath),
       (file) => file.startsWith("node_modules/.cache")
     );
     const nextFiles = {
@@ -17559,7 +18614,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
     if (filesAfterBuild["next.config.js"]) {
       nextFiles["next.config.js"] = filesAfterBuild["next.config.js"];
     }
-    const pagesDir = import_path6.default.join(
+    const pagesDir = import_path7.default.join(
       entryPath,
       outputDirectory,
       "server",
@@ -17572,7 +18627,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
       entryPath,
       outputDirectory
     });
-    const launcherPath = import_path6.default.join(__dirname, "legacy-launcher.js");
+    const launcherPath = import_path7.default.join(__dirname, "legacy-launcher.js");
     const launcherData = await (0, import_fs_extra6.readFile)(launcherPath, "utf8");
     await Promise.all(
       Object.keys(pages).map(async (page) => {
@@ -17592,7 +18647,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         };
         let lambdaOptions = {};
         if (config && config.functions) {
-          lambdaOptions = await (0, import_build_utils3.getLambdaOptionsFromFunction)({
+          lambdaOptions = await (0, import_build_utils5.getLambdaOptionsFromFunction)({
             sourceFile: await getSourceFilePathFromPage({
               workPath: entryPath,
               page
@@ -17600,12 +18655,12 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
             config
           });
         }
-        (0, import_build_utils3.debug)(`Creating serverless function for page: "${page}"...`);
-        lambdas[import_path6.default.posix.join(entryDirectory, pathname)] = new import_build_utils3.NodejsLambda({
+        (0, import_build_utils5.debug)(`Creating serverless function for page: "${page}"...`);
+        lambdas[import_path7.default.posix.join(entryDirectory, pathname)] = new import_build_utils5.NodejsLambda({
           files: {
             ...nextFiles,
             ...pageFiles,
-            "___next_launcher.cjs": new import_build_utils3.FileBlob({ data: launcher })
+            "___next_launcher.cjs": new import_build_utils5.FileBlob({ data: launcher })
           },
           handler: "___next_launcher.cjs",
           runtime: nodeVersion.runtime,
@@ -17621,12 +18676,12 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
           },
           shouldDisableAutomaticFetchInstrumentation: process.env.VERCEL_TRACING_DISABLE_AUTOMATIC_FETCH_INSTRUMENTATION === "1"
         });
-        (0, import_build_utils3.debug)(`Created serverless function for page: "${page}"`);
+        (0, import_build_utils5.debug)(`Created serverless function for page: "${page}"`);
       })
     );
   } else {
-    (0, import_build_utils3.debug)("Preparing serverless function files...");
-    const pagesDir = import_path6.default.join(
+    (0, import_build_utils5.debug)("Preparing serverless function files...");
+    const pagesDir = import_path7.default.join(
       entryPath,
       outputDirectory,
       isServerMode ? "server" : "serverless",
@@ -17634,10 +18689,10 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
     );
     let appDir = null;
     const appPathRoutesManifest = await (0, import_fs_extra6.readJSON)(
-      import_path6.default.join(entryPath, outputDirectory, "app-path-routes-manifest.json")
+      import_path7.default.join(entryPath, outputDirectory, "app-path-routes-manifest.json")
     ).catch(() => null);
     if (appPathRoutesManifest) {
-      appDir = import_path6.default.join(pagesDir, "../app");
+      appDir = import_path7.default.join(pagesDir, "../app");
     }
     const { pages, appPaths: lambdaAppPaths } = await getServerlessPages({
       pagesDir,
@@ -17648,7 +18703,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
     const canUsePreviewMode = Object.keys(pages).some(
       (page) => isApiPage(pages[page].fsPath)
     );
-    const originalStaticPages = await (0, import_build_utils3.glob)("**/*.html", pagesDir);
+    const originalStaticPages = await (0, import_build_utils5.glob)("**/*.html", pagesDir);
     staticPages = filterStaticPages(
       originalStaticPages,
       dynamicPages,
@@ -17658,14 +18713,14 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
       nextVersion,
       routesManifest
     );
-    hasStatic500 = !!staticPages[import_path6.default.posix.join(entryDirectory, "500")];
-    static404Page = staticPages[import_path6.default.posix.join(entryDirectory, "404")] && hasPages404 ? import_path6.default.posix.join(entryDirectory, "404") : staticPages[import_path6.default.posix.join(entryDirectory, "_errors/404")] ? import_path6.default.posix.join(entryDirectory, "_errors/404") : void 0;
+    hasStatic500 = !!staticPages[import_path7.default.posix.join(entryDirectory, "500")];
+    static404Page = staticPages[import_path7.default.posix.join(entryDirectory, "404")] && hasPages404 ? import_path7.default.posix.join(entryDirectory, "404") : staticPages[import_path7.default.posix.join(entryDirectory, "_errors/404")] ? import_path7.default.posix.join(entryDirectory, "_errors/404") : void 0;
     const { i18n: i18n2 } = routesManifest || {};
     if (!static404Page && i18n2) {
-      static404Page = staticPages[import_path6.default.posix.join(entryDirectory, i18n2.defaultLocale, "404")] ? import_path6.default.posix.join(entryDirectory, i18n2.defaultLocale, "404") : void 0;
+      static404Page = staticPages[import_path7.default.posix.join(entryDirectory, i18n2.defaultLocale, "404")] ? import_path7.default.posix.join(entryDirectory, i18n2.defaultLocale, "404") : void 0;
     }
     if (!hasStatic500 && i18n2) {
-      hasStatic500 = !!staticPages[import_path6.default.posix.join(entryDirectory, i18n2.defaultLocale, "500")];
+      hasStatic500 = !!staticPages[import_path7.default.posix.join(entryDirectory, i18n2.defaultLocale, "500")];
     }
     if (routesManifest) {
       switch (routesManifest.version) {
@@ -17682,7 +18737,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
               }
               const route = {
                 src: (dataRoute.namedDataRouteRegex || dataRoute.dataRouteRegex).replace(/^\^/, `^${appMountPrefixNoTrailingSlash}`),
-                dest: import_path6.default.posix.join(
+                dest: import_path7.default.posix.join(
                   "/",
                   entryDirectory,
                   // make sure to route SSG data route to the data prerender
@@ -17745,7 +18800,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
           break;
         }
         default: {
-          throw new import_build_utils3.NowBuildError({
+          throw new import_build_utils5.NowBuildError({
             code: "NEXT_VERSION_OUTDATED",
             message: "This version of `@vercel/next` does not support the version of Next.js you are trying to deploy.\nPlease upgrade your `@vercel/next` builder and try again. Contact support if this continues to happen."
           });
@@ -17774,7 +18829,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
           `A routes-manifest could not be located, please check your outputDirectory and try again.`
         );
       }
-      const localePrefixed404 = !!(routesManifest.i18n && originalStaticPages[import_path6.default.posix.join(".", routesManifest.i18n.defaultLocale, "404.html")]);
+      const localePrefixed404 = !!(routesManifest.i18n && originalStaticPages[import_path7.default.posix.join(".", routesManifest.i18n.defaultLocale, "404.html")]);
       return serverBuild({
         config,
         functionsConfigManifest,
@@ -17834,7 +18889,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         console.info(nextConfig);
         console.info();
       }
-      throw new import_build_utils3.NowBuildError({
+      throw new import_build_utils5.NowBuildError({
         code: "NEXT_NO_SERVERLESS_PAGES",
         message: "No serverless pages were built",
         link: "https://err.sh/vercel/vercel/now-next-no-serverless-pages-built"
@@ -17843,7 +18898,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
     let requiresTracing = hasLambdas;
     try {
       if (nextVersion && import_semver5.default.lt(nextVersion, ExperimentalTraceVersion)) {
-        (0, import_build_utils3.debug)(
+        (0, import_build_utils5.debug)(
           "Next.js version is too old for us to trace the required dependencies.\nAssuming Next.js has handled it!"
         );
         requiresTracing = false;
@@ -17915,7 +18970,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
       );
       for (const page of mergedPageKeys) {
         const fileList = parentFilesMap.get(
-          import_path6.default.relative(baseDir, pages[page].fsPath)
+          import_path7.default.relative(baseDir, pages[page].fsPath)
         );
         if (!fileList) {
           throw new Error(
@@ -17949,22 +19004,22 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         console.timeEnd(zippingLabel);
       }
     } else {
-      assets = await (0, import_build_utils3.glob)(
+      assets = await (0, import_build_utils5.glob)(
         "assets/**",
-        import_path6.default.join(entryPath, outputDirectory, "serverless")
+        import_path7.default.join(entryPath, outputDirectory, "serverless")
       );
       const assetKeys = Object.keys(assets);
       if (assetKeys.length > 0) {
-        (0, import_build_utils3.debug)(
+        (0, import_build_utils5.debug)(
           "detected (legacy) assets to be bundled with serverless function:"
         );
-        assetKeys.forEach((assetFile) => (0, import_build_utils3.debug)(`	${assetFile}`));
-        (0, import_build_utils3.debug)(
+        assetKeys.forEach((assetFile) => (0, import_build_utils5.debug)(`	${assetFile}`));
+        (0, import_build_utils5.debug)(
           "\nPlease upgrade to Next.js 9.1 to leverage modern asset handling."
         );
       }
     }
-    const launcherPath = import_path6.default.join(__dirname, "templated-launcher.js");
+    const launcherPath = import_path7.default.join(__dirname, "templated-launcher.js");
     const launcherData = await (0, import_fs_extra6.readFile)(launcherPath, "utf8");
     const allLambdasLabel = `All serverless functions created in`;
     if (hasLambdas) {
@@ -18008,7 +19063,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
       for (const group of initialApiLambdaGroups) {
         group.isApiLambda = true;
       }
-      (0, import_build_utils3.debug)(
+      (0, import_build_utils5.debug)(
         JSON.stringify(
           {
             apiLambdaGroups: initialApiLambdaGroups.map((group) => ({
@@ -18046,8 +19101,8 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
           if (page === "_error.js" && (static404Page && staticPages[static404Page] || hasPages404 && pages["404.js"])) {
             continue;
           }
-          const pageFileName = import_path6.default.normalize(
-            import_path6.default.relative(workPath, pages[page].fsPath)
+          const pageFileName = import_path7.default.normalize(
+            import_path7.default.relative(workPath, pages[page].fsPath)
           );
           const pathname = page.replace(/\.js$/, "");
           const routeIsDynamic = isDynamicRoute(pathname, nextVersion);
@@ -18058,7 +19113,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
           if (nonLambdaSsgPages.has(`/${pathname}`)) {
             continue;
           }
-          const outputName = import_path6.default.join("/", entryDirectory, pathname);
+          const outputName = import_path7.default.join("/", entryDirectory, pathname);
           const lambdaGroupIndex = routeIsApi ? apiLambdaGroupIndex : nonApiLambdaGroupIndex;
           const lambdaGroups = routeIsApi ? apiLambdaGroups : pageLambdaGroups;
           const lastLambdaGroup = lambdaGroups[lambdaGroupIndex];
@@ -18070,7 +19125,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
               pseudoLayer: group.pseudoLayer,
               lambdaCombinedBytes: group.pseudoLayerBytes,
               maxConcurrency: group.maxConcurrency,
-              lambdaIdentifier: import_path6.default.join(
+              lambdaIdentifier: import_path7.default.join(
                 entryDirectory,
                 `__NEXT_${routeIsApi ? "API" : "PAGE"}_LAMBDA_${lambdaGroupIndex}`
               )
@@ -18082,7 +19137,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
                 /\/index$/,
                 "(/|/index|)"
               )}/?$`,
-              dest: `${import_path6.default.join("/", currentLambdaGroup.lambdaIdentifier)}`,
+              dest: `${import_path7.default.join("/", currentLambdaGroup.lambdaIdentifier)}`,
               headers: {
                 "x-nextjs-page": outputName
               },
@@ -18104,13 +19159,13 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
             addPageLambdaRoute((0, import_escape_string_regexp3.default)(outputName));
           }
           if (page === "_error.js" || hasPages404 && page === "404.js") {
-            page404Path = import_path6.default.join("/", entryDirectory, pathname);
+            page404Path = import_path7.default.join("/", entryDirectory, pathname);
           }
           currentLambdaGroup.pages[outputName] = {
             pageFileName,
             pageName: page
           };
-          currentLambdaGroup.pseudoLayer[import_path6.default.join(import_path6.default.relative(baseDir, entryPath), pageFileName)] = compressedPages[page];
+          currentLambdaGroup.pseudoLayer[import_path7.default.join(import_path7.default.relative(baseDir, entryPath), pageFileName)] = compressedPages[page];
           lambdaGroups[lambdaGroupIndex] = currentLambdaGroup;
         }
         if (routeIsApi) {
@@ -18132,22 +19187,22 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
           if (isDynamicRoute(pathname, nextVersion)) {
             dynamicPages.push(normalizePage(pathname));
           }
-          const pageFileName = import_path6.default.normalize(
-            import_path6.default.relative(entryPath, pages[page].fsPath)
+          const pageFileName = import_path7.default.normalize(
+            import_path7.default.relative(entryPath, pages[page].fsPath)
           );
           const launcher = launcherData.replace(
             /__LAUNCHER_PAGE_PATH__/g,
             JSON.stringify(requiresTracing ? `./${pageFileName}` : "./page")
           );
           const launcherFiles = {
-            [import_path6.default.join(
-              import_path6.default.relative(baseDir, entryPath),
+            [import_path7.default.join(
+              import_path7.default.relative(baseDir, entryPath),
               "___next_launcher.cjs"
-            )]: new import_build_utils3.FileBlob({ data: launcher })
+            )]: new import_build_utils5.FileBlob({ data: launcher })
           };
           let lambdaOptions = {};
           if (config && config.functions) {
-            lambdaOptions = await (0, import_build_utils3.getLambdaOptionsFromFunction)({
+            lambdaOptions = await (0, import_build_utils5.getLambdaOptionsFromFunction)({
               sourceFile: await getSourceFilePathFromPage({
                 workPath: entryPath,
                 page
@@ -18156,7 +19211,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
             });
           }
           const outputName = normalizeIndexOutput(
-            import_path6.default.join(entryDirectory, pathname),
+            import_path7.default.join(entryDirectory, pathname),
             isServerMode
           );
           if (requiresTracing) {
@@ -18168,11 +19223,11 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
                   return prev;
                 }, {}),
                 {
-                  [import_path6.default.join(import_path6.default.relative(baseDir, entryPath), pageFileName)]: compressedPages[page]
+                  [import_path7.default.join(import_path7.default.relative(baseDir, entryPath), pageFileName)]: compressedPages[page]
                 }
               ],
-              handler: import_path6.default.join(
-                import_path6.default.relative(baseDir, entryPath),
+              handler: import_path7.default.join(
+                import_path7.default.relative(baseDir, entryPath),
                 "___next_launcher.cjs"
               ),
               operationType: getOperationType({
@@ -18191,11 +19246,11 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
               },
               layers: [
                 {
-                  [import_path6.default.join(import_path6.default.relative(baseDir, entryPath), "page.js")]: compressedPages[page]
+                  [import_path7.default.join(import_path7.default.relative(baseDir, entryPath), "page.js")]: compressedPages[page]
                 }
               ],
-              handler: import_path6.default.join(
-                import_path6.default.relative(baseDir, entryPath),
+              handler: import_path7.default.join(
+                import_path7.default.relative(baseDir, entryPath),
                 "___next_launcher.cjs"
               ),
               operationType: getOperationType({ pageFileName }),
@@ -18235,7 +19290,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
       )
     );
     if (isSharedLambdas) {
-      const launcherPath2 = import_path6.default.join(__dirname, "templated-launcher-shared.js");
+      const launcherPath2 = import_path7.default.join(__dirname, "templated-launcher-shared.js");
       const launcherData2 = await (0, import_fs_extra6.readFile)(launcherPath2, "utf8");
       const completeDynamicRoutes = await getDynamicRoutes({
         entryPath,
@@ -18290,7 +19345,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
                 try {
                   const pages = {
                     ${groupPageKeys.map(
-                (page) => `'${page}': () => require('./${import_path6.default.join(
+                (page) => `'${page}': () => require('./${import_path7.default.join(
                   "./",
                   group.pages[page].pageFileName
                 )}')`
@@ -18380,10 +19435,10 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
               `
             );
             const launcherFiles = {
-              [import_path6.default.join(
-                import_path6.default.relative(baseDir, entryPath),
+              [import_path7.default.join(
+                import_path7.default.relative(baseDir, entryPath),
                 "___next_launcher.cjs"
-              )]: new import_build_utils3.FileBlob({ data: launcher })
+              )]: new import_build_utils5.FileBlob({ data: launcher })
             };
             for (const page of groupPageKeys) {
               pageLambdaMap[page] = group.lambdaIdentifier;
@@ -18398,8 +19453,8 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
                 ...assets
               },
               layers: [group.pseudoLayer],
-              handler: import_path6.default.join(
-                import_path6.default.relative(baseDir, entryPath),
+              handler: import_path7.default.join(
+                import_path7.default.relative(baseDir, entryPath),
                 "___next_launcher.cjs"
               ),
               operationType,
@@ -18482,7 +19537,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
               `^${appMountPrefixNoTrailingSlash}`
             ),
             // Location of lambda in builder output
-            dest: import_path6.default.posix.join(entryDirectory, dataRoute),
+            dest: import_path7.default.posix.join(entryDirectory, dataRoute),
             check: true
           });
           if (!prefetchDataRoute || !prefetchDataRouteRegex)
@@ -18492,7 +19547,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
               /^\^/,
               `^${appMountPrefixNoTrailingSlash}`
             ),
-            dest: import_path6.default.posix.join(entryDirectory, prefetchDataRoute),
+            dest: import_path7.default.posix.join(entryDirectory, prefetchDataRoute),
             check: true
           });
         }
@@ -18501,12 +19556,12 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
   }
   if (!isSharedLambdas) {
     omittedPrerenderRoutes.forEach((routeKey) => {
-      const routeFileNoExt = import_path6.default.posix.join(
+      const routeFileNoExt = import_path7.default.posix.join(
         entryDirectory,
         routeKey === "/" ? "/index" : routeKey
       );
       if (typeof lambdas[routeFileNoExt] === void 0) {
-        throw new import_build_utils3.NowBuildError({
+        throw new import_build_utils5.NowBuildError({
           code: "NEXT__UNKNOWN_ROUTE_KEY",
           message: `invariant: unknown lambda ${routeKey} (lookup: ${routeFileNoExt}) | please report this immediately`
         });
@@ -18572,31 +19627,31 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         // $wildcard
         // This is split into two rules to avoid matching the `/index` route as it causes issues with trailing slash redirect
         {
-          src: `^${import_path6.default.posix.join(
+          src: `^${import_path7.default.posix.join(
             "/",
             entryDirectory,
             "/"
           )}(?!(?:_next/.*|${i18n.locales.map((locale) => (0, import_escape_string_regexp3.default)(locale)).join("|")})(?:/.*|$))$`,
           // we aren't able to ensure trailing slash mode here
           // so ensure this comes after the trailing slash redirect
-          dest: `${entryDirectory !== "." ? import_path6.default.posix.join("/", entryDirectory) : ""}$wildcard${trailingSlash ? "/" : ""}`,
+          dest: `${entryDirectory !== "." ? import_path7.default.posix.join("/", entryDirectory) : ""}$wildcard${trailingSlash ? "/" : ""}`,
           continue: true
         },
         {
-          src: `^${import_path6.default.join(
+          src: `^${import_path7.default.join(
             "/",
             entryDirectory,
             "/"
           )}(?!(?:_next/.*|${i18n.locales.map((locale) => (0, import_escape_string_regexp3.default)(locale)).join("|")})(?:/.*|$))(.*)$`,
           // we aren't able to ensure trailing slash mode here
           // so ensure this comes after the trailing slash redirect
-          dest: `${entryDirectory !== "." ? import_path6.default.join("/", entryDirectory) : ""}$wildcard/$1`,
+          dest: `${entryDirectory !== "." ? import_path7.default.join("/", entryDirectory) : ""}$wildcard/$1`,
           continue: true
         },
         // Handle redirecting to locale specific domains
         ...i18n.domains && i18n.domains.length > 0 && i18n.localeDetection !== false ? [
           {
-            src: `^${import_path6.default.join("/", entryDirectory)}/?(?:${i18n.locales.map((locale) => (0, import_escape_string_regexp3.default)(locale)).join("|")})?/?$`,
+            src: `^${import_path7.default.join("/", entryDirectory)}/?(?:${i18n.locales.map((locale) => (0, import_escape_string_regexp3.default)(locale)).join("|")})?/?$`,
             locale: {
               redirect: i18n.domains.reduce(
                 (prev, item) => {
@@ -18637,8 +19692,8 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
           }
         ] : [],
         {
-          src: `^${import_path6.default.join("/", entryDirectory)}$`,
-          dest: `${import_path6.default.join("/", entryDirectory, i18n.defaultLocale)}`,
+          src: `^${import_path7.default.join("/", entryDirectory)}$`,
+          dest: `${import_path7.default.join("/", entryDirectory, i18n.defaultLocale)}`,
           continue: true
         },
         // Auto-prefix non-locale path with default locale
@@ -18647,12 +19702,12 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         // e.g. for /de/posts/[slug] x-now-route-matches would have
         // 1=posts%2Fpost-1
         {
-          src: `^${import_path6.default.join(
+          src: `^${import_path7.default.join(
             "/",
             entryDirectory,
             "/"
           )}(?!(?:_next/.*|${i18n.locales.map((locale) => (0, import_escape_string_regexp3.default)(locale)).join("|")})(?:/.*|$))(.*)$`,
-          dest: `${import_path6.default.join("/", entryDirectory, i18n.defaultLocale)}/$1`,
+          dest: `${import_path7.default.join("/", entryDirectory, i18n.defaultLocale)}/$1`,
           continue: true
         }
       ] : [],
@@ -18662,13 +19717,13 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
       // Make sure to 404 for the /404 path itself
       ...i18n ? [
         {
-          src: `${import_path6.default.join("/", entryDirectory, "/")}(?:${i18n.locales.map((locale) => (0, import_escape_string_regexp3.default)(locale)).join("|")})?[/]?404/?`,
+          src: `${import_path7.default.join("/", entryDirectory, "/")}(?:${i18n.locales.map((locale) => (0, import_escape_string_regexp3.default)(locale)).join("|")})?[/]?404/?`,
           status: 404,
           continue: true
         }
       ] : [
         {
-          src: import_path6.default.join("/", entryDirectory, "404/?"),
+          src: import_path7.default.join("/", entryDirectory, "404/?"),
           status: 404,
           continue: true
         }
@@ -18676,13 +19731,13 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
       // Make sure to 500 when visiting /500 directly for static 500
       ...!hasStatic500 ? [] : i18n ? [
         {
-          src: `${import_path6.default.join("/", entryDirectory, "/")}(?:${i18n.locales.map((locale) => (0, import_escape_string_regexp3.default)(locale)).join("|")})?[/]?500`,
+          src: `${import_path7.default.join("/", entryDirectory, "/")}(?:${i18n.locales.map((locale) => (0, import_escape_string_regexp3.default)(locale)).join("|")})?[/]?500`,
           status: 500,
           continue: true
         }
       ] : [
         {
-          src: import_path6.default.join("/", entryDirectory, "500"),
+          src: import_path7.default.join("/", entryDirectory, "500"),
           status: 500,
           continue: true
         }
@@ -18705,7 +19760,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
       // _next/image path
       ...routesManifest?.basePath ? [
         {
-          src: import_path6.default.join("/", entryDirectory, "_next/image/?"),
+          src: import_path7.default.join("/", entryDirectory, "_next/image/?"),
           dest: "/_next/image",
           check: true
         }
@@ -18713,8 +19768,8 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
       // No-op _next/data rewrite to trigger handle: 'rewrites' and then 404
       // if no match to prevent rewriting _next/data unexpectedly
       {
-        src: import_path6.default.join("/", entryDirectory, "_next/data/(.*)"),
-        dest: import_path6.default.join("/", entryDirectory, "_next/data/$1"),
+        src: import_path7.default.join("/", entryDirectory, "_next/data/(.*)"),
+        dest: import_path7.default.join("/", entryDirectory, "_next/data/$1"),
         check: true
       },
       // These need to come before handle: miss or else they are grouped
@@ -18724,15 +19779,15 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
       // an index page
       { handle: "resource" },
       ...fallbackRewrites,
-      { src: import_path6.default.join("/", entryDirectory, ".*"), status: 404 },
+      { src: import_path7.default.join("/", entryDirectory, ".*"), status: 404 },
       // 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: import_path6.default.join("/", entryDirectory, "_next/static/.+"),
+        src: import_path7.default.join("/", entryDirectory, "_next/static/.+"),
         status: 404,
         check: true,
-        dest: import_path6.default.join("/", entryDirectory, "_next/static/not-found.txt"),
+        dest: import_path7.default.join("/", entryDirectory, "_next/static/not-found.txt"),
         headers: {
           "content-type": "text/plain; charset=utf-8"
         }
@@ -18740,8 +19795,8 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
       // remove locale prefixes to check public files
       ...i18n ? [
         {
-          src: `^${import_path6.default.join("/", entryDirectory)}/?(?:${i18n.locales.map((locale) => (0, import_escape_string_regexp3.default)(locale)).join("|")})/(.*)`,
-          dest: `${import_path6.default.join("/", entryDirectory, "/")}$1`,
+          src: `^${import_path7.default.join("/", entryDirectory)}/?(?:${i18n.locales.map((locale) => (0, import_escape_string_regexp3.default)(locale)).join("|")})/(.*)`,
+          dest: `${import_path7.default.join("/", entryDirectory, "/")}$1`,
           check: true
         }
       ] : [],
@@ -18749,7 +19804,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
       // to allow checking for lambda
       ...isSharedLambdas || !i18n ? [] : [
         {
-          src: `${import_path6.default.join("/", entryDirectory, "/")}(?:${i18n?.locales.map((locale) => (0, import_escape_string_regexp3.default)(locale)).join("|")})/(.*)`,
+          src: `${import_path7.default.join("/", entryDirectory, "/")}(?:${i18n?.locales.map((locale) => (0, import_escape_string_regexp3.default)(locale)).join("|")})/(.*)`,
           dest: "/$1",
           check: true
         }
@@ -18762,8 +19817,8 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
       // ensure we 404 for non-existent _next/data routes before
       // trying page dynamic routes
       {
-        src: import_path6.default.join("/", entryDirectory, "_next/data/(.*)"),
-        dest: import_path6.default.join("/", entryDirectory, "404"),
+        src: import_path7.default.join("/", entryDirectory, "_next/data/(.*)"),
+        dest: import_path7.default.join("/", entryDirectory, "404"),
         status: 404,
         check: true
       },
@@ -18778,7 +19833,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
       {
         // This ensures we only match known emitted-by-Next.js files and not
         // user-emitted files which may be missing a hash in their filename.
-        src: import_path6.default.join(
+        src: import_path7.default.join(
           "/",
           entryDirectory,
           `_next/static/(?:[^/]+/pages|pages|chunks|runtime|css|image|media|${escapedBuildId})/.+`
@@ -18798,7 +19853,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         { handle: "error" },
         ...i18n && (static404Page || hasIsr404Page) ? [
           {
-            src: `${import_path6.default.join(
+            src: `${import_path7.default.join(
               "/",
               entryDirectory,
               "/"
@@ -18808,16 +19863,16 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
             caseSensitive: true
           },
           {
-            src: import_path6.default.join("/", entryDirectory, ".*"),
+            src: import_path7.default.join("/", entryDirectory, ".*"),
             dest: `/${i18n.defaultLocale}/404`,
             status: 404
           }
         ] : [
           isSharedLambdas ? {
-            src: import_path6.default.join("/", entryDirectory, ".*"),
+            src: import_path7.default.join("/", entryDirectory, ".*"),
             // if static 404 is not present but we have pages/404.js
             // it is a lambda due to _app getInitialProps
-            dest: import_path6.default.join(
+            dest: import_path7.default.join(
               "/",
               static404Page ? static404Page : pageLambdaMap[page404Path]
             ),
@@ -18828,13 +19883,13 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
               }
             }
           } : {
-            src: import_path6.default.join("/", entryDirectory, ".*"),
+            src: import_path7.default.join("/", entryDirectory, ".*"),
             // if static 404 is not present but we have pages/404.js
             // it is a lambda due to _app getInitialProps
-            dest: static404Page ? import_path6.default.join("/", static404Page) : import_path6.default.join(
+            dest: static404Page ? import_path7.default.join("/", static404Page) : import_path7.default.join(
               "/",
               entryDirectory,
-              hasPages404 && lambdas[import_path6.default.join("./", entryDirectory, "404")] ? "404" : "_error"
+              hasPages404 && lambdas[import_path7.default.join("./", entryDirectory, "404")] ? "404" : "_error"
             ),
             status: 404
           }
@@ -18842,7 +19897,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         // static 500 page if present
         ...!hasStatic500 ? [] : i18n ? [
           {
-            src: `${import_path6.default.join(
+            src: `${import_path7.default.join(
               "/",
               entryDirectory,
               "/"
@@ -18851,14 +19906,14 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
             status: 500
           },
           {
-            src: import_path6.default.join("/", entryDirectory, ".*"),
+            src: import_path7.default.join("/", entryDirectory, ".*"),
             dest: `/${i18n.defaultLocale}/500`,
             status: 500
           }
         ] : [
           {
-            src: import_path6.default.join("/", entryDirectory, ".*"),
-            dest: import_path6.default.join("/", entryDirectory, "/500"),
+            src: import_path7.default.join("/", entryDirectory, ".*"),
+            dest: import_path7.default.join("/", entryDirectory, "/500"),
             status: 500
           }
         ]
@@ -18868,7 +19923,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
     ...deploymentId && { deploymentId }
   };
 };
-var packageManifestDiagnostics = (0, import_build_utils3.createDiagnostics)("node");
+var packageManifestDiagnostics = (0, import_build_utils5.createDiagnostics)("node");
 var diagnostics = async ({
   config,
   entrypoint,
@@ -18876,12 +19931,12 @@ var diagnostics = async ({
   repoRootPath,
   ...rest
 }) => {
-  const entryDirectory = import_path6.default.dirname(entrypoint);
-  const entryPath = import_path6.default.join(workPath, entryDirectory);
-  const outputDirectory = import_path6.default.join("./", config.outputDirectory || ".next");
+  const entryDirectory = import_path7.default.dirname(entrypoint);
+  const entryPath = import_path7.default.join(workPath, entryDirectory);
+  const outputDirectory = import_path7.default.join("./", config.outputDirectory || ".next");
   const basePath = repoRootPath || workPath;
-  const diagnosticsEntrypoint = import_path6.default.relative(basePath, entryPath);
-  (0, import_build_utils3.debug)(
+  const diagnosticsEntrypoint = import_path7.default.relative(basePath, entryPath);
+  (0, import_build_utils5.debug)(
     `Reading diagnostics file in diagnosticsEntrypoint=${diagnosticsEntrypoint}`
   );
   return {
@@ -18893,29 +19948,29 @@ var diagnostics = async ({
       ...rest
     }),
     // Collect output in `.next/diagnostics`
-    ...await (0, import_build_utils3.glob)(
+    ...await (0, import_build_utils5.glob)(
       "*",
-      import_path6.default.join(basePath, diagnosticsEntrypoint, outputDirectory, "diagnostics")
+      import_path7.default.join(basePath, diagnosticsEntrypoint, outputDirectory, "diagnostics")
     ),
     // Collect `.next/trace` file
-    ...await (0, import_build_utils3.glob)(
+    ...await (0, import_build_utils5.glob)(
       "trace",
-      import_path6.default.join(basePath, diagnosticsEntrypoint, outputDirectory)
+      import_path7.default.join(basePath, diagnosticsEntrypoint, outputDirectory)
     ),
     // Collect `.next/trace-build` file
-    ...await (0, import_build_utils3.glob)(
+    ...await (0, import_build_utils5.glob)(
       "trace-build",
-      import_path6.default.join(basePath, diagnosticsEntrypoint, outputDirectory)
+      import_path7.default.join(basePath, diagnosticsEntrypoint, outputDirectory)
     ),
     // Collect `.next/turbopack` file
-    ...await (0, import_build_utils3.glob)(
+    ...await (0, import_build_utils5.glob)(
       "turbopack",
-      import_path6.default.join(basePath, diagnosticsEntrypoint, outputDirectory)
+      import_path7.default.join(basePath, diagnosticsEntrypoint, outputDirectory)
     ),
     // Collect `.next/trace-turbopack` file
-    ...await (0, import_build_utils3.glob)(
+    ...await (0, import_build_utils5.glob)(
       "trace-turbopack",
-      import_path6.default.join(basePath, diagnosticsEntrypoint, outputDirectory)
+      import_path7.default.join(basePath, diagnosticsEntrypoint, outputDirectory)
     )
   };
 };
@@ -18925,34 +19980,34 @@ var prepareCache = async ({
   entrypoint,
   config = {}
 }) => {
-  (0, import_build_utils3.debug)("Preparing cache...");
-  const entryDirectory = import_path6.default.dirname(entrypoint);
-  const entryPath = import_path6.default.join(workPath, entryDirectory);
-  const outputDirectory = import_path6.default.join("./", config.outputDirectory || ".next");
+  (0, import_build_utils5.debug)("Preparing cache...");
+  const entryDirectory = import_path7.default.dirname(entrypoint);
+  const entryPath = import_path7.default.join(workPath, entryDirectory);
+  const outputDirectory = import_path7.default.join("./", config.outputDirectory || ".next");
   const nextVersionRange = await getNextVersionRange(entryPath);
   const isLegacy = nextVersionRange && isLegacyNext(nextVersionRange);
   if (isLegacy) {
     return {};
   }
-  (0, import_build_utils3.debug)("Producing cache file manifest...");
+  (0, import_build_utils5.debug)("Producing cache file manifest...");
   const isMonorepo = repoRootPath && repoRootPath !== workPath;
   const cacheBasePath = repoRootPath || workPath;
-  const cacheEntrypoint = import_path6.default.relative(cacheBasePath, entryPath);
+  const cacheEntrypoint = import_path7.default.relative(cacheBasePath, entryPath);
   const cache = {
-    ...await (0, import_build_utils3.glob)(
-      isMonorepo ? "**/node_modules/**" : import_path6.default.join(cacheEntrypoint, "node_modules/**"),
+    ...await (0, import_build_utils5.glob)(
+      isMonorepo ? "**/node_modules/**" : import_path7.default.join(cacheEntrypoint, "node_modules/**"),
       cacheBasePath
     ),
-    ...await (0, import_build_utils3.glob)(
-      import_path6.default.join(cacheEntrypoint, outputDirectory, "cache/**"),
+    ...await (0, import_build_utils5.glob)(
+      import_path7.default.join(cacheEntrypoint, outputDirectory, "cache/**"),
       cacheBasePath
     ),
-    ...await (0, import_build_utils3.glob)(
-      isMonorepo ? "**/.yarn/cache/**" : import_path6.default.join(cacheEntrypoint, ".yarn/cache/**"),
+    ...await (0, import_build_utils5.glob)(
+      isMonorepo ? "**/.yarn/cache/**" : import_path7.default.join(cacheEntrypoint, ".yarn/cache/**"),
       cacheBasePath
     )
   };
-  (0, import_build_utils3.debug)("Cache file manifest produced");
+  (0, import_build_utils5.debug)("Cache file manifest produced");
   return cache;
 };
 // Annotate the CommonJS export names for ESM import in node:
@@ -18960,6 +20015,7 @@ var prepareCache = async ({
   MAX_AGE_ONE_YEAR,
   build,
   diagnostics,
+  getDevManifest,
   htmlContentType,
   prepareCache,
   version