@vercel/next 4.4.2 → 4.4.5

package/dist/index.js

@@ -400,6 +400,396 @@ var require_dist = __commonJS({
   }
 });
 
+// ../../node_modules/.pnpm/path-to-regexp@6.3.0/node_modules/path-to-regexp/dist/index.js
+var require_dist2 = __commonJS({
+  "../../node_modules/.pnpm/path-to-regexp@6.3.0/node_modules/path-to-regexp/dist/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.pathToRegexp = exports.tokensToRegexp = exports.regexpToFunction = exports.match = exports.tokensToFunction = exports.compile = exports.parse = void 0;
+    function lexer(str) {
+      var tokens = [];
+      var i = 0;
+      while (i < str.length) {
+        var char = str[i];
+        if (char === "*" || char === "+" || char === "?") {
+          tokens.push({ type: "MODIFIER", index: i, value: str[i++] });
+          continue;
+        }
+        if (char === "\\") {
+          tokens.push({ type: "ESCAPED_CHAR", index: i++, value: str[i++] });
+          continue;
+        }
+        if (char === "{") {
+          tokens.push({ type: "OPEN", index: i, value: str[i++] });
+          continue;
+        }
+        if (char === "}") {
+          tokens.push({ type: "CLOSE", index: i, value: str[i++] });
+          continue;
+        }
+        if (char === ":") {
+          var name = "";
+          var j = i + 1;
+          while (j < str.length) {
+            var code = str.charCodeAt(j);
+            if (
+              // `0-9`
+              code >= 48 && code <= 57 || // `A-Z`
+              code >= 65 && code <= 90 || // `a-z`
+              code >= 97 && code <= 122 || // `_`
+              code === 95
+            ) {
+              name += str[j++];
+              continue;
+            }
+            break;
+          }
+          if (!name)
+            throw new TypeError("Missing parameter name at ".concat(i));
+          tokens.push({ type: "NAME", index: i, value: name });
+          i = j;
+          continue;
+        }
+        if (char === "(") {
+          var count = 1;
+          var pattern = "";
+          var j = i + 1;
+          if (str[j] === "?") {
+            throw new TypeError('Pattern cannot start with "?" at '.concat(j));
+          }
+          while (j < str.length) {
+            if (str[j] === "\\") {
+              pattern += str[j++] + str[j++];
+              continue;
+            }
+            if (str[j] === ")") {
+              count--;
+              if (count === 0) {
+                j++;
+                break;
+              }
+            } else if (str[j] === "(") {
+              count++;
+              if (str[j + 1] !== "?") {
+                throw new TypeError("Capturing groups are not allowed at ".concat(j));
+              }
+            }
+            pattern += str[j++];
+          }
+          if (count)
+            throw new TypeError("Unbalanced pattern at ".concat(i));
+          if (!pattern)
+            throw new TypeError("Missing pattern at ".concat(i));
+          tokens.push({ type: "PATTERN", index: i, value: pattern });
+          i = j;
+          continue;
+        }
+        tokens.push({ type: "CHAR", index: i, value: str[i++] });
+      }
+      tokens.push({ type: "END", index: i, value: "" });
+      return tokens;
+    }
+    function parse(str, options) {
+      if (options === void 0) {
+        options = {};
+      }
+      var tokens = lexer(str);
+      var _a = options.prefixes, prefixes = _a === void 0 ? "./" : _a, _b = options.delimiter, delimiter = _b === void 0 ? "/#?" : _b;
+      var result = [];
+      var key = 0;
+      var i = 0;
+      var path5 = "";
+      var tryConsume = function(type) {
+        if (i < tokens.length && tokens[i].type === type)
+          return tokens[i++].value;
+      };
+      var mustConsume = function(type) {
+        var value2 = tryConsume(type);
+        if (value2 !== void 0)
+          return value2;
+        var _a2 = tokens[i], nextType = _a2.type, index = _a2.index;
+        throw new TypeError("Unexpected ".concat(nextType, " at ").concat(index, ", expected ").concat(type));
+      };
+      var consumeText = function() {
+        var result2 = "";
+        var value2;
+        while (value2 = tryConsume("CHAR") || tryConsume("ESCAPED_CHAR")) {
+          result2 += value2;
+        }
+        return result2;
+      };
+      var isSafe = function(value2) {
+        for (var _i = 0, delimiter_1 = delimiter; _i < delimiter_1.length; _i++) {
+          var char2 = delimiter_1[_i];
+          if (value2.indexOf(char2) > -1)
+            return true;
+        }
+        return false;
+      };
+      var safePattern = function(prefix2) {
+        var prev = result[result.length - 1];
+        var prevText = prefix2 || (prev && typeof prev === "string" ? prev : "");
+        if (prev && !prevText) {
+          throw new TypeError('Must have text between two parameters, missing text after "'.concat(prev.name, '"'));
+        }
+        if (!prevText || isSafe(prevText))
+          return "[^".concat(escapeString(delimiter), "]+?");
+        return "(?:(?!".concat(escapeString(prevText), ")[^").concat(escapeString(delimiter), "])+?");
+      };
+      while (i < tokens.length) {
+        var char = tryConsume("CHAR");
+        var name = tryConsume("NAME");
+        var pattern = tryConsume("PATTERN");
+        if (name || pattern) {
+          var prefix = char || "";
+          if (prefixes.indexOf(prefix) === -1) {
+            path5 += prefix;
+            prefix = "";
+          }
+          if (path5) {
+            result.push(path5);
+            path5 = "";
+          }
+          result.push({
+            name: name || key++,
+            prefix,
+            suffix: "",
+            pattern: pattern || safePattern(prefix),
+            modifier: tryConsume("MODIFIER") || ""
+          });
+          continue;
+        }
+        var value = char || tryConsume("ESCAPED_CHAR");
+        if (value) {
+          path5 += value;
+          continue;
+        }
+        if (path5) {
+          result.push(path5);
+          path5 = "";
+        }
+        var open = tryConsume("OPEN");
+        if (open) {
+          var prefix = consumeText();
+          var name_1 = tryConsume("NAME") || "";
+          var pattern_1 = tryConsume("PATTERN") || "";
+          var suffix = consumeText();
+          mustConsume("CLOSE");
+          result.push({
+            name: name_1 || (pattern_1 ? key++ : ""),
+            pattern: name_1 && !pattern_1 ? safePattern(prefix) : pattern_1,
+            prefix,
+            suffix,
+            modifier: tryConsume("MODIFIER") || ""
+          });
+          continue;
+        }
+        mustConsume("END");
+      }
+      return result;
+    }
+    exports.parse = parse;
+    function compile(str, options) {
+      return tokensToFunction(parse(str, options), options);
+    }
+    exports.compile = compile;
+    function tokensToFunction(tokens, options) {
+      if (options === void 0) {
+        options = {};
+      }
+      var reFlags = flags(options);
+      var _a = options.encode, encode = _a === void 0 ? function(x) {
+        return x;
+      } : _a, _b = options.validate, validate = _b === void 0 ? true : _b;
+      var matches = tokens.map(function(token) {
+        if (typeof token === "object") {
+          return new RegExp("^(?:".concat(token.pattern, ")$"), reFlags);
+        }
+      });
+      return function(data) {
+        var path5 = "";
+        for (var i = 0; i < tokens.length; i++) {
+          var token = tokens[i];
+          if (typeof token === "string") {
+            path5 += token;
+            continue;
+          }
+          var value = data ? data[token.name] : void 0;
+          var optional = token.modifier === "?" || token.modifier === "*";
+          var repeat = token.modifier === "*" || token.modifier === "+";
+          if (Array.isArray(value)) {
+            if (!repeat) {
+              throw new TypeError('Expected "'.concat(token.name, '" to not repeat, but got an array'));
+            }
+            if (value.length === 0) {
+              if (optional)
+                continue;
+              throw new TypeError('Expected "'.concat(token.name, '" to not be empty'));
+            }
+            for (var j = 0; j < value.length; j++) {
+              var segment = encode(value[j], token);
+              if (validate && !matches[i].test(segment)) {
+                throw new TypeError('Expected all "'.concat(token.name, '" to match "').concat(token.pattern, '", but got "').concat(segment, '"'));
+              }
+              path5 += token.prefix + segment + token.suffix;
+            }
+            continue;
+          }
+          if (typeof value === "string" || typeof value === "number") {
+            var segment = encode(String(value), token);
+            if (validate && !matches[i].test(segment)) {
+              throw new TypeError('Expected "'.concat(token.name, '" to match "').concat(token.pattern, '", but got "').concat(segment, '"'));
+            }
+            path5 += token.prefix + segment + token.suffix;
+            continue;
+          }
+          if (optional)
+            continue;
+          var typeOfMessage = repeat ? "an array" : "a string";
+          throw new TypeError('Expected "'.concat(token.name, '" to be ').concat(typeOfMessage));
+        }
+        return path5;
+      };
+    }
+    exports.tokensToFunction = tokensToFunction;
+    function match(str, options) {
+      var keys = [];
+      var re = pathToRegexp(str, keys, options);
+      return regexpToFunction(re, keys, options);
+    }
+    exports.match = match;
+    function regexpToFunction(re, keys, options) {
+      if (options === void 0) {
+        options = {};
+      }
+      var _a = options.decode, decode = _a === void 0 ? function(x) {
+        return x;
+      } : _a;
+      return function(pathname) {
+        var m = re.exec(pathname);
+        if (!m)
+          return false;
+        var path5 = m[0], index = m.index;
+        var params = /* @__PURE__ */ Object.create(null);
+        var _loop_1 = function(i2) {
+          if (m[i2] === void 0)
+            return "continue";
+          var key = keys[i2 - 1];
+          if (key.modifier === "*" || key.modifier === "+") {
+            params[key.name] = m[i2].split(key.prefix + key.suffix).map(function(value) {
+              return decode(value, key);
+            });
+          } else {
+            params[key.name] = decode(m[i2], key);
+          }
+        };
+        for (var i = 1; i < m.length; i++) {
+          _loop_1(i);
+        }
+        return { path: path5, index, params };
+      };
+    }
+    exports.regexpToFunction = regexpToFunction;
+    function escapeString(str) {
+      return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
+    }
+    function flags(options) {
+      return options && options.sensitive ? "" : "i";
+    }
+    function regexpToRegexp(path5, keys) {
+      if (!keys)
+        return path5;
+      var groupsRegex = /\((?:\?<(.*?)>)?(?!\?)/g;
+      var index = 0;
+      var execResult = groupsRegex.exec(path5.source);
+      while (execResult) {
+        keys.push({
+          // Use parenthesized substring match if available, index otherwise
+          name: execResult[1] || index++,
+          prefix: "",
+          suffix: "",
+          modifier: "",
+          pattern: ""
+        });
+        execResult = groupsRegex.exec(path5.source);
+      }
+      return path5;
+    }
+    function arrayToRegexp(paths, keys, options) {
+      var parts = paths.map(function(path5) {
+        return pathToRegexp(path5, keys, options).source;
+      });
+      return new RegExp("(?:".concat(parts.join("|"), ")"), flags(options));
+    }
+    function stringToRegexp(path5, keys, options) {
+      return tokensToRegexp(parse(path5, options), keys, options);
+    }
+    function tokensToRegexp(tokens, keys, options) {
+      if (options === void 0) {
+        options = {};
+      }
+      var _a = options.strict, strict = _a === void 0 ? false : _a, _b = options.start, start = _b === void 0 ? true : _b, _c = options.end, end = _c === void 0 ? true : _c, _d = options.encode, encode = _d === void 0 ? function(x) {
+        return x;
+      } : _d, _e = options.delimiter, delimiter = _e === void 0 ? "/#?" : _e, _f = options.endsWith, endsWith = _f === void 0 ? "" : _f;
+      var endsWithRe = "[".concat(escapeString(endsWith), "]|$");
+      var delimiterRe = "[".concat(escapeString(delimiter), "]");
+      var route = start ? "^" : "";
+      for (var _i = 0, tokens_1 = tokens; _i < tokens_1.length; _i++) {
+        var token = tokens_1[_i];
+        if (typeof token === "string") {
+          route += escapeString(encode(token));
+        } else {
+          var prefix = escapeString(encode(token.prefix));
+          var suffix = escapeString(encode(token.suffix));
+          if (token.pattern) {
+            if (keys)
+              keys.push(token);
+            if (prefix || suffix) {
+              if (token.modifier === "+" || token.modifier === "*") {
+                var mod = token.modifier === "*" ? "?" : "";
+                route += "(?:".concat(prefix, "((?:").concat(token.pattern, ")(?:").concat(suffix).concat(prefix, "(?:").concat(token.pattern, "))*)").concat(suffix, ")").concat(mod);
+              } else {
+                route += "(?:".concat(prefix, "(").concat(token.pattern, ")").concat(suffix, ")").concat(token.modifier);
+              }
+            } else {
+              if (token.modifier === "+" || token.modifier === "*") {
+                throw new TypeError('Can not repeat "'.concat(token.name, '" without a prefix and suffix'));
+              }
+              route += "(".concat(token.pattern, ")").concat(token.modifier);
+            }
+          } else {
+            route += "(?:".concat(prefix).concat(suffix, ")").concat(token.modifier);
+          }
+        }
+      }
+      if (end) {
+        if (!strict)
+          route += "".concat(delimiterRe, "?");
+        route += !options.endsWith ? "$" : "(?=".concat(endsWithRe, ")");
+      } else {
+        var endToken = tokens[tokens.length - 1];
+        var isEndDelimited = typeof endToken === "string" ? delimiterRe.indexOf(endToken[endToken.length - 1]) > -1 : endToken === void 0;
+        if (!strict) {
+          route += "(?:".concat(delimiterRe, "(?=").concat(endsWithRe, "))?");
+        }
+        if (!isEndDelimited) {
+          route += "(?=".concat(delimiterRe, "|").concat(endsWithRe, ")");
+        }
+      }
+      return new RegExp(route, flags(options));
+    }
+    exports.tokensToRegexp = tokensToRegexp;
+    function pathToRegexp(path5, keys, options) {
+      if (path5 instanceof RegExp)
+        return regexpToRegexp(path5, keys);
+      if (Array.isArray(path5))
+        return arrayToRegexp(path5, keys, options);
+      return stringToRegexp(path5, keys, options);
+    }
+    exports.pathToRegexp = pathToRegexp;
+  }
+});
+
 // ../routing-utils/dist/superstatic.js
 var require_superstatic = __commonJS({
   "../routing-utils/dist/superstatic.js"(exports, module2) {
@@ -433,8 +823,39 @@ var require_superstatic = __commonJS({
       sourceToRegex: () => sourceToRegex
     });
     module2.exports = __toCommonJS2(superstatic_exports);
-    var import_url3 = require("url");
+    var import_url4 = require("url");
     var import_path_to_regexp = require_dist();
+    var import_path_to_regexp_updated = require_dist2();
+    function pathToRegexp(callerId, path5, keys, options) {
+      const currentRegExp = (0, import_path_to_regexp.pathToRegexp)(path5, keys, options);
+      try {
+        const currentKeys = keys;
+        const newKeys = [];
+        const newRegExp = (0, import_path_to_regexp_updated.pathToRegexp)(path5, newKeys, options);
+        const isDiffRegExp = currentRegExp.toString() !== newRegExp.toString();
+        if (process.env.FORCE_PATH_TO_REGEXP_LOG || isDiffRegExp) {
+          const message = JSON.stringify({
+            path: path5,
+            currentRegExp: currentRegExp.toString(),
+            newRegExp: newRegExp.toString()
+          });
+          console.error(`[vc] PATH TO REGEXP PATH DIFF @ #${callerId}: ${message}`);
+        }
+        const isDiffKeys = keys?.toString() !== newKeys?.toString();
+        if (process.env.FORCE_PATH_TO_REGEXP_LOG || isDiffKeys) {
+          const message = JSON.stringify({
+            isDiffKeys,
+            currentKeys,
+            newKeys
+          });
+          console.error(`[vc] PATH TO REGEXP KEYS DIFF @ #${callerId}: ${message}`);
+        }
+      } catch (err) {
+        const error = err;
+        console.error(`[vc] PATH TO REGEXP ERROR @ #${callerId}: ${error.message}`);
+      }
+      return currentRegExp;
+    }
     var UN_NAMED_SEGMENT = "__UN_NAMED_SEGMENT__";
     function getCleanUrls(filePaths) {
       const htmlFiles = filePaths.map(toRoute).filter((f) => f.endsWith(".html")).map((f) => ({
@@ -590,7 +1011,7 @@ var require_superstatic = __commonJS({
     }
     function sourceToRegex(source) {
       const keys = [];
-      const r = (0, import_path_to_regexp.pathToRegexp)(source, keys, {
+      const r = pathToRegexp("632", source, keys, {
         strict: true,
         sensitive: true,
         delimiter: "/"
@@ -649,7 +1070,7 @@ var require_superstatic = __commonJS({
         indexes[name] = "$" + name;
         escapedDestination = escapeSegment(escapedDestination, name);
       });
-      const parsedDestination = (0, import_url3.parse)(escapedDestination, true);
+      const parsedDestination = (0, import_url4.parse)(escapedDestination, true);
       delete parsedDestination.href;
       delete parsedDestination.path;
       delete parsedDestination.search;
@@ -663,9 +1084,9 @@ var require_superstatic = __commonJS({
       const hashKeys = [];
       const hostnameKeys = [];
       try {
-        (0, import_path_to_regexp.pathToRegexp)(pathname, pathnameKeys);
-        (0, import_path_to_regexp.pathToRegexp)(hash || "", hashKeys);
-        (0, import_path_to_regexp.pathToRegexp)(hostname || "", hostnameKeys);
+        pathToRegexp("528", pathname, pathnameKeys);
+        pathToRegexp("834", hash || "", hashKeys);
+        pathToRegexp("712", hostname || "", hostnameKeys);
       } catch (_) {
       }
       destParams = new Set(
@@ -701,7 +1122,7 @@ var require_superstatic = __commonJS({
           }
         }
       }
-      destination = (0, import_url3.format)({
+      destination = (0, import_url4.format)({
         ...rest,
         hostname,
         pathname,
@@ -7736,24 +8157,24 @@ var require_util = __commonJS({
     }
     exports.urlParse = urlParse;
     function urlGenerate(aParsedUrl) {
-      let url3 = "";
+      let url4 = "";
       if (aParsedUrl.scheme) {
-        url3 += aParsedUrl.scheme + ":";
+        url4 += aParsedUrl.scheme + ":";
       }
-      url3 += "//";
+      url4 += "//";
       if (aParsedUrl.auth) {
-        url3 += aParsedUrl.auth + "@";
+        url4 += aParsedUrl.auth + "@";
       }
       if (aParsedUrl.host) {
-        url3 += aParsedUrl.host;
+        url4 += aParsedUrl.host;
       }
       if (aParsedUrl.port) {
-        url3 += ":" + aParsedUrl.port;
+        url4 += ":" + aParsedUrl.port;
       }
       if (aParsedUrl.path) {
-        url3 += aParsedUrl.path;
+        url4 += aParsedUrl.path;
       }
-      return url3;
+      return url4;
     }
     exports.urlGenerate = urlGenerate;
     var MAX_CACHED_INPUTS = 32;
@@ -7781,12 +8202,12 @@ var require_util = __commonJS({
     }
     var normalize = lruMemoize(function normalize2(aPath) {
       let path5 = aPath;
-      const url3 = urlParse(aPath);
-      if (url3) {
-        if (!url3.path) {
+      const url4 = urlParse(aPath);
+      if (url4) {
+        if (!url4.path) {
           return aPath;
         }
-        path5 = url3.path;
+        path5 = url4.path;
       }
       const isAbsolute = exports.isAbsolute(path5);
       const parts = [];
@@ -7826,9 +8247,9 @@ var require_util = __commonJS({
       if (path5 === "") {
         path5 = isAbsolute ? "/" : ".";
       }
-      if (url3) {
-        url3.path = path5;
-        return urlGenerate(url3);
+      if (url4) {
+        url4.path = path5;
+        return urlGenerate(url4);
       }
       return path5;
     });
@@ -9149,13 +9570,13 @@ var require_source_map_consumer = __commonJS({
         if (this.sourceRoot != null) {
           relativeSource = util.relative(this.sourceRoot, relativeSource);
         }
-        let url3;
-        if (this.sourceRoot != null && (url3 = util.urlParse(this.sourceRoot))) {
+        let url4;
+        if (this.sourceRoot != null && (url4 = util.urlParse(this.sourceRoot))) {
           const fileUriAbsPath = relativeSource.replace(/^file:\/\//, "");
-          if (url3.scheme == "file" && this._sources.has(fileUriAbsPath)) {
+          if (url4.scheme == "file" && this._sources.has(fileUriAbsPath)) {
             return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)];
           }
-          if ((!url3.path || url3.path == "/") && this._sources.has("/" + relativeSource)) {
+          if ((!url4.path || url4.path == "/") && this._sources.has("/" + relativeSource)) {
             return this.sourcesContent[this._sources.indexOf("/" + relativeSource)];
           }
         }
@@ -10374,7 +10795,7 @@ var import_find_up = __toESM(require_find_up());
 var import_fs_extra6 = __toESM(require_lib2());
 var import_path5 = __toESM(require("path"));
 var import_semver4 = __toESM(require_semver());
-var import_url2 = __toESM(require("url"));
+var import_url3 = __toESM(require("url"));
 
 // src/create-serverless-config.ts
 var import_fs_extra4 = __toESM(require_lib2());
@@ -10545,6 +10966,9 @@ var RSC_PREFETCH_SUFFIX = ".prefetch.rsc";
 var MAX_UNCOMPRESSED_LAMBDA_SIZE = !isNaN(
   Number(process.env.MAX_UNCOMPRESSED_LAMBDA_SIZE)
 ) ? Number(process.env.MAX_UNCOMPRESSED_LAMBDA_SIZE) : DEFAULT_MAX_UNCOMPRESSED_LAMBDA_SIZE;
+var skipDefaultLocaleRewrite = Boolean(
+  process.env.NEXT_EXPERIMENTAL_DEFER_DEFAULT_LOCALE_REWRITE
+);
 var TEST_DYNAMIC_ROUTE = /\/\[[^\/]+?\](?=\/|$)/;
 function isDynamicRoute(route) {
   route = route.startsWith("/") ? route : `/${route}`;
@@ -10823,9 +11247,12 @@ async function getDynamicRoutes({
   return routes;
 }
 function localizeDynamicRoutes(dynamicRoutes, dynamicPrefix, entryDirectory, staticPages, prerenderManifest, routesManifest, isServerMode, isCorrectLocaleAPIRoutes, inversedAppPathRoutesManifest) {
-  return dynamicRoutes.map((route) => {
-    if (route.middleware !== void 0 || route.middlewarePath !== void 0)
-      return route;
+  const finalDynamicRoutes = [];
+  for (const route of dynamicRoutes) {
+    if (route.middleware !== void 0 || route.middlewarePath !== void 0) {
+      finalDynamicRoutes.push(route);
+      continue;
+    }
     const { i18n } = routesManifest || {};
     if (i18n) {
       const { pathname } = import_url.default.parse(route.dest);
@@ -10836,6 +11263,14 @@ function localizeDynamicRoutes(dynamicRoutes, dynamicPrefix, entryDirectory, sta
       const isAutoExport = staticPages[addLocaleOrDefault(pathname, routesManifest).substring(1)];
       const isAppRoute = inversedAppPathRoutesManifest?.[pathnameNoPrefix || ""];
       const isLocalePrefixed = isFallback || isBlocking || isAutoExport || isServerMode;
+      if (skipDefaultLocaleRewrite && isLocalePrefixed && routesManifest?.i18n?.localeDetection === false) {
+        const nonLocalePrefixedRoute = JSON.parse(JSON.stringify(route));
+        nonLocalePrefixedRoute.src = nonLocalePrefixedRoute.src.replace(
+          "^",
+          `^${dynamicPrefix || ""}[/]?`
+        );
+        finalDynamicRoutes.push(nonLocalePrefixedRoute);
+      }
       route.src = route.src.replace(
         "^",
         `^${dynamicPrefix ? `${dynamicPrefix}[/]?` : "[/]?"}(?${isLocalePrefixed ? "<nextLocale>" : ":"}${i18n.locales.map((locale) => (0, import_escape_string_regexp.default)(locale)).join("|")})?`
@@ -10849,8 +11284,9 @@ function localizeDynamicRoutes(dynamicRoutes, dynamicPrefix, entryDirectory, sta
     } else {
       route.src = route.src.replace("^", `^${dynamicPrefix}`);
     }
-    return route;
-  });
+    finalDynamicRoutes.push(route);
+  }
+  return finalDynamicRoutes;
 }
 async function getImagesManifest(entryPath, outputDirectory) {
   const pathImagesManifest = import_path2.default.join(
@@ -13097,6 +13533,7 @@ var legacy_versions_default = [
 
 // src/server-build.ts
 var import_path4 = __toESM(require("path"));
+var import_url2 = __toESM(require("url"));
 var import_semver3 = __toESM(require_semver());
 var import_async_sema2 = __toESM(require_lib());
 var import_build_utils2 = require("@vercel/build-utils");
@@ -13186,6 +13623,9 @@ async function serverBuild({
   const experimentalAllowBundling = Boolean(
     process.env.NEXT_EXPERIMENTAL_FUNCTION_BUNDLING
   );
+  const skipDefaultLocaleRewrite2 = Boolean(
+    process.env.NEXT_EXPERIMENTAL_DEFER_DEFAULT_LOCALE_REWRITE
+  );
   const lambdas = {};
   const prerenders = {};
   const lambdaPageKeys = Object.keys(lambdaPages);
@@ -13205,6 +13645,7 @@ async function serverBuild({
   let appRscPrefetches = {};
   let appBuildTraces = {};
   let appDir = null;
+  const rscHeader = routesManifest.rsc?.header?.toLowerCase() || "__rsc__";
   if (appPathRoutesManifest) {
     appDir = import_path4.default.join(pagesDir, "../app");
     appBuildTraces = await (0, import_build_utils2.glob)("**/*.js.nft.json", appDir);
@@ -13216,20 +13657,84 @@ async function serverBuild({
         value.contentType = rscContentTypeHeader;
       }
     }
-    for (const rewrite of afterFilesRewrites) {
-      if (rewrite.src && rewrite.dest) {
-        const rscSuffix = isAppPPREnabled ? `(\\.prefetch)?\\.rsc` : "\\.rsc";
-        rewrite.src = rewrite.src.replace(
-          /\/?\(\?:\/\)\?/,
-          `(?<rscsuff>${rscSuffix})?(?:/)?`
+    const modifyRewrites = (rewrites, isAfterFilesRewrite = false) => {
+      for (let i = 0; i < rewrites.length; i++) {
+        const rewrite = rewrites[i];
+        if (!rewrite.src || !rewrite.dest)
+          continue;
+        const { protocol, pathname, query } = import_url2.default.parse(rewrite.dest);
+        if (isAfterFilesRewrite) {
+          const rscSuffix = isAppPPREnabled ? `(\\.prefetch)?\\.rsc` : "\\.rsc";
+          rewrite.src = rewrite.src.replace(
+            /\/?\(\?:\/\)\?/,
+            `(?<rscsuff>${rscSuffix})?(?:/)?`
+          );
+          let destQueryIndex = rewrite.dest.indexOf("?");
+          if (destQueryIndex === -1) {
+            destQueryIndex = rewrite.dest.length;
+          }
+          rewrite.dest = rewrite.dest.substring(0, destQueryIndex) + "$rscsuff" + rewrite.dest.substring(destQueryIndex);
+        }
+        const { rewriteHeaders } = routesManifest;
+        if (!rewriteHeaders)
+          continue;
+        if (protocol || !pathname && !query)
+          continue;
+        const missing = "missing" in rewrite && rewrite.missing ? rewrite.missing : [];
+        let found = missing.filter(
+          (h) => h.type === "header" && h.key.toLowerCase() === rscHeader
         );
-        let destQueryIndex = rewrite.dest.indexOf("?");
-        if (destQueryIndex === -1) {
-          destQueryIndex = rewrite.dest.length;
+        if (found.some(
+          (m) => (
+            // These are rules that don't have a value check or those that
+            // have their value set to '1'.
+            !m.value || m.value === "1"
+          )
+        )) {
+          continue;
         }
-        rewrite.dest = rewrite.dest.substring(0, destQueryIndex) + "$rscsuff" + rewrite.dest.substring(destQueryIndex);
+        const has = "has" in rewrite && rewrite.has ? (
+          // As we mutate the array below, we need to clone it to avoid
+          // mutating the original
+          [...rewrite.has]
+        ) : [];
+        found = has.filter(
+          (h) => h.type === "header" && h.key.toLowerCase() === rscHeader
+        );
+        if (found.some(
+          (h) => (
+            // These are rules that have a value set to anything other than
+            // '1'.
+            h.value && h.value !== "1"
+          )
+        )) {
+          continue;
+        }
+        for (const h of found) {
+          has.splice(has.indexOf(h), 1);
+        }
+        has.push({ type: "header", key: rscHeader, value: "1" });
+        const headers2 = "headers" in rewrite && rewrite.headers ? (
+          // Clone the existing headers to avoid mutating the original
+          // object.
+          { ...rewrite.headers }
+        ) : {};
+        const updated = {
+          ...rewrite,
+          has,
+          headers: headers2
+        };
+        if (pathname)
+          headers2[rewriteHeaders.pathHeader] = pathname;
+        if (query)
+          headers2[rewriteHeaders.queryHeader] = query;
+        rewrites.splice(i, 0, updated);
+        i++;
       }
-    }
+    };
+    modifyRewrites(beforeFilesRewrites);
+    modifyRewrites(afterFilesRewrites, true);
+    modifyRewrites(fallbackRewrites);
   }
   const isCorrectNotFoundRoutes = import_semver3.default.gte(
     nextVersion,
@@ -14282,7 +14787,6 @@ ${JSON.stringify(
       }
     }
   }
-  const rscHeader = routesManifest.rsc?.header?.toLowerCase() || "__rsc__";
   const rscPrefetchHeader = routesManifest.rsc?.prefetchHeader?.toLowerCase();
   const rscVaryHeader = routesManifest?.rsc?.varyHeader || "RSC, Next-Router-State-Tree, Next-Router-Prefetch";
   const appNotFoundPath = import_path4.default.posix.join(".", entryDirectory, "_not-found");
@@ -14420,33 +14924,38 @@ ${JSON.stringify(
             continue: true
           }
         ] : [],
-        {
-          src: `^${import_path4.default.posix.join("/", entryDirectory)}$`,
-          dest: `${import_path4.default.posix.join(
-            "/",
-            entryDirectory,
-            i18n.defaultLocale
-          )}`,
-          continue: true
-        },
-        // Auto-prefix non-locale path with default locale
-        // note for prerendered pages this will cause
-        // x-now-route-matches to contain the path minus the locale
-        // e.g. for /de/posts/[slug] x-now-route-matches would have
-        // 1=posts%2Fpost-1
-        {
-          src: `^${import_path4.default.posix.join(
-            "/",
-            entryDirectory,
-            "/"
-          )}(?!(?:_next/.*|${i18n.locales.map((locale) => (0, import_escape_string_regexp2.default)(locale)).join("|")})(?:/.*|$))(.*)$`,
-          dest: `${import_path4.default.posix.join(
-            "/",
-            entryDirectory,
-            i18n.defaultLocale
-          )}/$1`,
-          continue: true
-        }
+        // We only want to add these rewrites before user redirects
+        // when `skipDefaultLocaleRewrite` is not flagged on
+        // and when localeDetection is enabled.
+        ...!skipDefaultLocaleRewrite2 || i18n.localeDetection !== false ? [
+          {
+            src: `^${import_path4.default.posix.join("/", entryDirectory)}$`,
+            dest: `${import_path4.default.posix.join(
+              "/",
+              entryDirectory,
+              i18n.defaultLocale
+            )}`,
+            continue: true
+          },
+          // Auto-prefix non-locale path with default locale
+          // note for prerendered pages this will cause
+          // x-now-route-matches to contain the path minus the locale
+          // e.g. for /de/posts/[slug] x-now-route-matches would have
+          // 1=posts%2Fpost-1
+          {
+            src: `^${import_path4.default.posix.join(
+              "/",
+              entryDirectory,
+              "/"
+            )}(?!(?:_next/.*|${i18n.locales.map((locale) => (0, import_escape_string_regexp2.default)(locale)).join("|")})(?:/.*|$))(.*)$`,
+            dest: `${import_path4.default.posix.join(
+              "/",
+              entryDirectory,
+              i18n.defaultLocale
+            )}/$1`,
+            continue: true
+          }
+        ] : []
       ] : [],
       ...headers,
       ...redirects,
@@ -14677,6 +15186,37 @@ ${JSON.stringify(
       // remove locale prefixes to check public files and
       // to allow checking non-prefixed lambda outputs
       ...i18n ? [
+        // When `skipDefaultLocaleRewrite` is flagged on and localeDetection is disabled,
+        // we only want to add the rewrite as the fallback case once routing is complete.
+        ...skipDefaultLocaleRewrite2 && i18n.localeDetection === false ? [
+          {
+            src: `^${import_path4.default.posix.join("/", entryDirectory)}$`,
+            dest: `${import_path4.default.posix.join(
+              "/",
+              entryDirectory,
+              i18n.defaultLocale
+            )}`,
+            check: true
+          },
+          // Auto-prefix non-locale path with default locale
+          // note for prerendered pages this will cause
+          // x-now-route-matches to contain the path minus the locale
+          // e.g. for /de/posts/[slug] x-now-route-matches would have
+          // 1=posts%2Fpost-1
+          {
+            src: `^${import_path4.default.posix.join(
+              "/",
+              entryDirectory,
+              "/"
+            )}(?!(?:_next/.*|${i18n.locales.map((locale) => (0, import_escape_string_regexp2.default)(locale)).join("|")})(?:/.*|$))(.*)$`,
+            dest: `${import_path4.default.posix.join(
+              "/",
+              entryDirectory,
+              i18n.defaultLocale
+            )}/$1`,
+            check: true
+          }
+        ] : [],
         {
           src: import_path4.default.posix.join(
             "/",
@@ -16578,7 +17118,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
     for (let i = 0; i < dynamicRoutes.length; i++) {
       const route = dynamicRoutes[i];
       mergedDynamicRoutesLambdaRoutes.push(route);
-      const { pathname } = import_url2.default.parse(route.dest);
+      const { pathname } = import_url3.default.parse(route.dest);
       if (pathname && pageLambdaMap[pathname]) {
         mergedDynamicRoutesLambdaRoutes.push(
           dynamicPageLambdaRoutesMap[pathname]
@@ -16588,7 +17128,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
     for (let i = 0; i < dataRoutes.length; i++) {
       const route = dataRoutes[i];
       mergedDataRoutesLambdaRoutes.push(route);
-      const { pathname } = import_url2.default.parse(route.dest);
+      const { pathname } = import_url3.default.parse(route.dest);
       if (pathname && pageLambdaMap[pathname] && dynamicPageLambdaRoutesMap[pathname]) {
         mergedDataRoutesLambdaRoutes.push(dynamicPageLambdaRoutesMap[pathname]);
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/next",
-  "version": "4.4.2",
+  "version": "4.4.5",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/next-js",
@@ -30,8 +30,8 @@
     "@types/semver": "6.0.0",
     "@types/text-table": "0.2.1",
     "@types/webpack-sources": "3.2.0",
-    "@vercel/build-utils": "9.0.1",
-    "@vercel/routing-utils": "5.0.0",
+    "@vercel/build-utils": "9.1.1",
+    "@vercel/routing-utils": "5.0.2",
     "async-sema": "3.0.1",
     "buffer-crc32": "0.2.13",
     "bytes": "3.1.2",