@netlify/plugin-nextjs 5.0.0-rc.0 → 5.0.0-rc.2

package/dist/build/content/server.js

@@ -8,7 +8,7 @@ import {
   copyNextDependencies,
   copyNextServerCode,
   writeTagsManifest
-} from "../../esm-chunks/chunk-4J4A5OE2.js";
+} from "../../esm-chunks/chunk-52WMBYKL.js";
 import "../../esm-chunks/chunk-VZNKO4OO.js";
 import "../../esm-chunks/chunk-UYKENJEU.js";
 import "../../esm-chunks/chunk-5JVNISGM.js";

package/dist/build/content/static.js

@@ -9,7 +9,7 @@ import {
   copyStaticContent,
   publishStaticDir,
   unpublishStaticDir
-} from "../../esm-chunks/chunk-WQIG4U66.js";
+} from "../../esm-chunks/chunk-MPZEWLBG.js";
 import "../../esm-chunks/chunk-VZNKO4OO.js";
 import "../../esm-chunks/chunk-TYCYFZ22.js";
 import "../../esm-chunks/chunk-5JVNISGM.js";

package/dist/build/functions/edge.js

@@ -6,9 +6,9 @@
     
 import {
   createEdgeHandlers
-} from "../../esm-chunks/chunk-UX4JCTAE.js";
+} from "../../esm-chunks/chunk-ZZOGIP2V.js";
 import "../../esm-chunks/chunk-VZNKO4OO.js";
-import "../../esm-chunks/chunk-PGQNT7XM.js";
+import "../../esm-chunks/chunk-655Y7ISI.js";
 import "../../esm-chunks/chunk-5JVNISGM.js";
 export {
   createEdgeHandlers

package/dist/build/functions/server.js

@@ -6,10 +6,10 @@
     
 import {
   createServerHandler
-} from "../../esm-chunks/chunk-FTCARYDZ.js";
-import "../../esm-chunks/chunk-4J4A5OE2.js";
+} from "../../esm-chunks/chunk-E3NFUTWC.js";
+import "../../esm-chunks/chunk-52WMBYKL.js";
 import "../../esm-chunks/chunk-VZNKO4OO.js";
-import "../../esm-chunks/chunk-PGQNT7XM.js";
+import "../../esm-chunks/chunk-655Y7ISI.js";
 import "../../esm-chunks/chunk-UYKENJEU.js";
 import "../../esm-chunks/chunk-5JVNISGM.js";
 export {

package/dist/build/plugin-context.js

@@ -8,7 +8,7 @@ import {
   EDGE_HANDLER_NAME,
   PluginContext,
   SERVER_HANDLER_NAME
-} from "../esm-chunks/chunk-PGQNT7XM.js";
+} from "../esm-chunks/chunk-655Y7ISI.js";
 import "../esm-chunks/chunk-5JVNISGM.js";
 export {
   EDGE_HANDLER_NAME,

package/dist/esm-chunks/{chunk-NL5YH5N6.js → chunk-3SUDZQ7L.js}

@@ -14,7 +14,7 @@ import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 var getRunConfig = async () => {
-  return JSON.parse(await readFile(resolve(RUN_CONFIG), "utf-8"));
+  return JSON.parse(await readFile(resolve(PLUGIN_DIR, RUN_CONFIG), "utf-8"));
 };
 var setRunConfig = (config) => {
   const cacheHandler = join(PLUGIN_DIR, ".netlify/dist/run/handlers/cache.cjs");

package/dist/esm-chunks/{chunk-4J4A5OE2.js → chunk-52WMBYKL.js}

@@ -19,7 +19,9 @@ var import_fast_glob = __toESM(require_out(), 1);
 import { existsSync } from "node:fs";
 import { cp, mkdir, readFile, readdir, readlink, symlink, writeFile } from "node:fs/promises";
 import { createRequire } from "node:module";
-import { dirname, join, resolve } from "node:path";
+import { dirname, join, resolve, sep } from "node:path";
+import { sep as posixSep } from "node:path/posix";
+var toPosixPath = (path) => path.split(sep).join(posixSep);
 var copyNextServerCode = async (ctx) => {
   const reqServerFilesPath = join(
     ctx.standaloneRootDir,
@@ -27,7 +29,7 @@ var copyNextServerCode = async (ctx) => {
     "required-server-files.json"
   );
   const reqServerFiles = JSON.parse(await readFile(reqServerFilesPath, "utf-8"));
-  if (ctx.distDir.replace(new RegExp(`^${ctx.packagePath}/?`), "") !== reqServerFiles.config.distDir) {
+  if (toPosixPath(ctx.distDir).replace(new RegExp(`^${ctx.packagePath}/?`), "") !== reqServerFiles.config.distDir) {
     reqServerFiles.config.distDir = ctx.nextDistDir;
     await writeFile(reqServerFilesPath, JSON.stringify(reqServerFiles));
   }
@@ -38,7 +40,7 @@ var copyNextServerCode = async (ctx) => {
     "utf-8"
   );
   const srcDir = join(ctx.standaloneDir, ctx.nextDistDir);
-  const nextFolder = ctx.distDir === ctx.buildConfig.distDir ? ctx.distDir : ctx.nextDistDir;
+  const nextFolder = toPosixPath(ctx.distDir) === toPosixPath(ctx.buildConfig.distDir) ? ctx.distDir : ctx.nextDistDir;
   const destDir = join(ctx.serverHandlerDir, nextFolder);
   const paths = await (0, import_fast_glob.default)(
     [`*`, `server/*`, `server/chunks/*`, `server/edge-chunks/*`, `server/+(app|pages)/**/*.js`],
@@ -109,8 +111,9 @@ var copyNextDependencies = async (ctx) => {
   await Promise.all(promises);
   const require2 = createRequire(ctx.serverHandlerDir);
   try {
-    require2.resolve("styled-jsx");
-    require2.resolve("next");
+    const nextEntryAbsolutePath = require2.resolve("next");
+    const nextRequire = createRequire(nextEntryAbsolutePath);
+    nextRequire.resolve("styled-jsx");
   } catch {
     throw new Error(
       "node_modules are not installed correctly, if you are using pnpm please set the public hoist pattern to: `public-hoist-pattern[]=*`.\nRefer to your docs for more details: https://docs.netlify.com/integrations/frameworks/next-js/overview/#pnpm-support"

package/dist/esm-chunks/{chunk-PGQNT7XM.js → chunk-655Y7ISI.js}

@@ -6,7 +6,7 @@
     
 
 // src/build/plugin-context.ts
-import { readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -47,7 +47,7 @@ var PluginContext = class {
    * The working directory inside the lambda that is used for monorepos to execute the serverless function
    */
   get lambdaWorkingDirectory() {
-    return join("/var/task", this.distFolder);
+    return join("/var/task", this.distDirParent);
   }
   /**
    * Retrieves the root of the `.next/standalone` directory
@@ -64,17 +64,17 @@ var PluginContext = class {
     const dir = this.buildConfig.distDir ?? DEFAULT_PUBLISH_DIR;
     return relative(process.cwd(), resolve(this.packagePath, dir));
   }
-  /** The dist folder represents the parent directory of the .next folder or custom distDir */
-  get distFolder() {
+  /** Represents the parent directory of the .next folder or custom distDir */
+  get distDirParent() {
     return join(this.distDir, "..");
   }
   /** The `.next` folder or what the custom dist dir is set to */
   get nextDistDir() {
-    return relative(this.distFolder, this.distDir);
+    return relative(this.distDirParent, this.distDir);
   }
   /** Retrieves the `.next/standalone/` directory monorepo aware */
   get standaloneDir() {
-    return join(this.standaloneRootDir, this.distFolder);
+    return join(this.standaloneRootDir, this.distDirParent);
   }
   /**
    * Absolute path of the directory that is published and deployed to the Netlify CDN
@@ -106,7 +106,7 @@ var PluginContext = class {
     if (this.packagePath.length === 0) {
       return this.serverHandlerRootDir;
     }
-    return join(this.serverHandlerRootDir, this.distFolder);
+    return join(this.serverHandlerRootDir, this.distDirParent);
   }
   get nextServerHandler() {
     if (this.packagePath.length !== 0) {
@@ -170,6 +170,18 @@ var PluginContext = class {
   failBuild(message, error) {
     return this.utils.build.failBuild(message, error instanceof Error ? { error } : void 0);
   }
+  verifyPublishDir() {
+    if (!existsSync(this.publishDir)) {
+      this.failBuild(
+        `Your publish directory was not found at: ${this.publishDir}, please check your build settings`
+      );
+    }
+    if (this.publishDir === this.resolve(this.packagePath)) {
+      this.failBuild(
+        `Your publish directory cannot be the same as the base directory of your site, please check your build settings`
+      );
+    }
+  }
 };
 
 export {

package/dist/esm-chunks/{chunk-FTCARYDZ.js → chunk-E3NFUTWC.js}

@@ -8,13 +8,13 @@ import {
   copyNextDependencies,
   copyNextServerCode,
   writeTagsManifest
-} from "./chunk-4J4A5OE2.js";
+} from "./chunk-52WMBYKL.js";
 import {
   require_out
 } from "./chunk-VZNKO4OO.js";
 import {
   SERVER_HANDLER_NAME
-} from "./chunk-PGQNT7XM.js";
+} from "./chunk-655Y7ISI.js";
 import {
   __toESM
 } from "./chunk-5JVNISGM.js";
@@ -22,17 +22,42 @@ import {
 // src/build/functions/server.ts
 var import_fast_glob = __toESM(require_out(), 1);
 import { cp, mkdir, readFile, rm, writeFile } from "fs/promises";
-import { join } from "node:path";
+import { join, relative } from "node:path";
+import { join as posixJoin } from "node:path/posix";
 var copyHandlerDependencies = async (ctx) => {
+  const promises = [];
+  const { included_files: includedFiles = [] } = ctx.netlifyConfig.functions?.["*"] || {};
+  if (includedFiles.length !== 0) {
+    const resolvedFiles = await Promise.all(
+      includedFiles.map((globPattern) => (0, import_fast_glob.glob)(globPattern, { cwd: process.cwd() }))
+    );
+    for (const filePath of resolvedFiles.flat()) {
+      promises.push(
+        cp(
+          join(process.cwd(), filePath),
+          // the serverHandlerDir is aware of the dist dir.
+          // The distDir must not be the package path therefore we need to rely on the
+          // serverHandlerDir instead of the serverHandlerRootDir
+          // therefore we need to remove the package path from the filePath
+          join(ctx.serverHandlerDir, relative(ctx.packagePath, filePath)),
+          {
+            recursive: true,
+            force: true
+          }
+        )
+      );
+    }
+  }
   const fileList = await (0, import_fast_glob.glob)("dist/**/*", { cwd: ctx.pluginDir });
-  await Promise.all(
-    [...fileList].map(
-      (path) => cp(join(ctx.pluginDir, path), join(ctx.serverHandlerDir, ".netlify", path), {
+  for (const filePath of fileList) {
+    promises.push(
+      cp(join(ctx.pluginDir, filePath), join(ctx.serverHandlerDir, ".netlify", filePath), {
         recursive: true,
         force: true
       })
-    )
-  );
+    );
+  }
+  await Promise.all(promises);
 };
 var writeHandlerManifest = async (ctx) => {
   await writeFile(
@@ -61,7 +86,7 @@ var getHandlerFile = async (ctx) => {
   const templatesDir = join(ctx.pluginDir, "dist/build/templates");
   if (ctx.packagePath.length !== 0) {
     const template = await readFile(join(templatesDir, "handler-monorepo.tmpl.js"), "utf-8");
-    return template.replaceAll("{{cwd}}", ctx.lambdaWorkingDirectory).replace("{{nextServerHandler}}", ctx.nextServerHandler);
+    return template.replaceAll("{{cwd}}", posixJoin(ctx.lambdaWorkingDirectory)).replace("{{nextServerHandler}}", posixJoin(ctx.nextServerHandler));
   }
   return await readFile(join(templatesDir, "handler.tmpl.js"), "utf-8");
 };

package/dist/esm-chunks/{chunk-WQIG4U66.js → chunk-MPZEWLBG.js}

@@ -18,7 +18,7 @@ import {
 var import_fast_glob = __toESM(require_out(), 1);
 import { existsSync } from "node:fs";
 import { cp, mkdir, rename, rm } from "node:fs/promises";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 var copyStaticContent = async (ctx) => {
   const srcDir = join(ctx.publishDir, "server/pages");
   const destDir = ctx.blobDir;
@@ -58,7 +58,7 @@ var copyStaticAssets = async (ctx) => {
 var publishStaticDir = async (ctx) => {
   try {
     await rm(ctx.tempPublishDir, { recursive: true, force: true });
-    await mkdir(ctx.tempPublishDir, { recursive: true });
+    await mkdir(basename(ctx.tempPublishDir), { recursive: true });
     await rename(ctx.publishDir, ctx.tempPublishDir);
     await rename(ctx.staticDir, ctx.publishDir);
   } catch (error) {

package/dist/esm-chunks/chunk-ZZOGIP2V.js

@@ -0,0 +1,531 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  require_out
+} from "./chunk-VZNKO4OO.js";
+import {
+  EDGE_HANDLER_NAME
+} from "./chunk-655Y7ISI.js";
+import {
+  __commonJS,
+  __toESM
+} from "./chunk-5JVNISGM.js";
+
+// node_modules/path-to-regexp/dist/index.js
+var require_dist = __commonJS({
+  "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;
+      var defaultPattern = "[^".concat(escapeString(options.delimiter || "/#?"), "]+?");
+      var result = [];
+      var key = 0;
+      var i = 0;
+      var path = "";
+      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;
+      };
+      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) {
+            path += prefix;
+            prefix = "";
+          }
+          if (path) {
+            result.push(path);
+            path = "";
+          }
+          result.push({
+            name: name || key++,
+            prefix,
+            suffix: "",
+            pattern: pattern || defaultPattern,
+            modifier: tryConsume("MODIFIER") || ""
+          });
+          continue;
+        }
+        var value = char || tryConsume("ESCAPED_CHAR");
+        if (value) {
+          path += value;
+          continue;
+        }
+        if (path) {
+          result.push(path);
+          path = "";
+        }
+        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 ? defaultPattern : 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 path = "";
+        for (var i = 0; i < tokens.length; i++) {
+          var token = tokens[i];
+          if (typeof token === "string") {
+            path += 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, '"'));
+              }
+              path += 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, '"'));
+            }
+            path += 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 path;
+      };
+    }
+    exports.tokensToFunction = tokensToFunction;
+    function match(str, options) {
+      var keys = [];
+      var re = pathToRegexp2(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 path = 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, index, params };
+      };
+    }
+    exports.regexpToFunction = regexpToFunction;
+    function escapeString(str) {
+      return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
+    }
+    function flags(options) {
+      return options && options.sensitive ? "" : "i";
+    }
+    function regexpToRegexp(path, keys) {
+      if (!keys)
+        return path;
+      var groupsRegex = /\((?:\?<(.*?)>)?(?!\?)/g;
+      var index = 0;
+      var execResult = groupsRegex.exec(path.source);
+      while (execResult) {
+        keys.push({
+          // Use parenthesized substring match if available, index otherwise
+          name: execResult[1] || index++,
+          prefix: "",
+          suffix: "",
+          modifier: "",
+          pattern: ""
+        });
+        execResult = groupsRegex.exec(path.source);
+      }
+      return path;
+    }
+    function arrayToRegexp(paths, keys, options) {
+      var parts = paths.map(function(path) {
+        return pathToRegexp2(path, keys, options).source;
+      });
+      return new RegExp("(?:".concat(parts.join("|"), ")"), flags(options));
+    }
+    function stringToRegexp(path, keys, options) {
+      return tokensToRegexp(parse(path, 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 === "*") {
+                route += "((?:".concat(token.pattern, ")").concat(token.modifier, ")");
+              } else {
+                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 pathToRegexp2(path, keys, options) {
+      if (path instanceof RegExp)
+        return regexpToRegexp(path, keys);
+      if (Array.isArray(path))
+        return arrayToRegexp(path, keys, options);
+      return stringToRegexp(path, keys, options);
+    }
+    exports.pathToRegexp = pathToRegexp2;
+  }
+});
+
+// src/build/functions/edge.ts
+var import_fast_glob = __toESM(require_out(), 1);
+var import_path_to_regexp = __toESM(require_dist(), 1);
+import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname, join, relative } from "node:path";
+var writeEdgeManifest = async (ctx, manifest) => {
+  await mkdir(ctx.edgeFunctionsDir, { recursive: true });
+  await writeFile(join(ctx.edgeFunctionsDir, "manifest.json"), JSON.stringify(manifest, null, 2));
+};
+var copyRuntime = async (ctx, handlerDirectory) => {
+  const files = await (0, import_fast_glob.glob)("edge-runtime/**/*", {
+    cwd: ctx.pluginDir,
+    ignore: ["**/*.test.ts"],
+    dot: true
+  });
+  await Promise.all(
+    files.map(
+      (path) => cp(join(ctx.pluginDir, path), join(handlerDirectory, path), { recursive: true })
+    )
+  );
+};
+var augmentMatchers = (matchers, ctx) => {
+  if (!ctx.buildConfig.i18n) {
+    return matchers;
+  }
+  return matchers.flatMap((matcher) => {
+    if (matcher.originalSource && matcher.locale !== false) {
+      return [
+        matcher,
+        {
+          ...matcher,
+          regexp: (0, import_path_to_regexp.pathToRegexp)(matcher.originalSource).source
+        }
+      ];
+    }
+    return matcher;
+  });
+};
+var writeHandlerFile = async (ctx, { matchers, name }) => {
+  const nextConfig = ctx.buildConfig;
+  const handlerName = getHandlerName({ name });
+  const handlerDirectory = join(ctx.edgeFunctionsDir, handlerName);
+  const handlerRuntimeDirectory = join(handlerDirectory, "edge-runtime");
+  await copyRuntime(ctx, handlerDirectory);
+  await writeFile(
+    join(handlerRuntimeDirectory, "matchers.json"),
+    JSON.stringify(augmentMatchers(matchers, ctx))
+  );
+  const minimalNextConfig = {
+    basePath: nextConfig.basePath,
+    i18n: nextConfig.i18n,
+    trailingSlash: nextConfig.trailingSlash,
+    skipMiddlewareUrlNormalize: nextConfig.skipMiddlewareUrlNormalize
+  };
+  await writeFile(
+    join(handlerRuntimeDirectory, "next.config.json"),
+    JSON.stringify(minimalNextConfig)
+  );
+  await writeFile(
+    join(handlerDirectory, `${handlerName}.js`),
+    `
+    import {handleMiddleware} from './edge-runtime/middleware.ts';
+    import handler from './server/${name}.js';
+    export default (req, context) => handleMiddleware(req, context, handler);
+    `
+  );
+};
+var copyHandlerDependencies = async (ctx, { name, files, wasm }) => {
+  const srcDir = join(ctx.standaloneDir, ctx.nextDistDir);
+  const destDir = join(ctx.edgeFunctionsDir, getHandlerName({ name }));
+  await Promise.all(
+    files.map(async (file) => {
+      if (file === `server/${name}.js`) {
+        const edgeRuntimeDir = join(ctx.pluginDir, "edge-runtime");
+        const shimPath = join(edgeRuntimeDir, "shim/index.js");
+        const shim = await readFile(shimPath, "utf8");
+        const importsDir = relative(dirname(join(srcDir, file)), join(srcDir, "server"));
+        const importsSrc = `${importsDir || "."}/edge-runtime-webpack.js`;
+        const imports = `import '${importsSrc}';`;
+        const exports = `export default _ENTRIES["middleware_${name}"].default;`;
+        const parts = [shim, imports];
+        if (wasm?.length) {
+          parts.push(
+            `import { decode as _base64Decode } from "../edge-runtime/vendor/deno.land/std@0.175.0/encoding/base64.ts";`
+          );
+          for (const wasmChunk of wasm ?? []) {
+            const data = await readFile(join(srcDir, wasmChunk.filePath));
+            parts.push(
+              `const ${wasmChunk.name} = _base64Decode(${JSON.stringify(
+                data.toString("base64")
+              )}).buffer`
+            );
+          }
+        }
+        const entrypoint = await readFile(join(srcDir, file), "utf8");
+        await mkdir(dirname(join(destDir, file)), { recursive: true });
+        await writeFile(join(destDir, file), [...parts, entrypoint, exports].join("\n;"));
+      } else {
+        await cp(join(srcDir, file), join(destDir, file));
+      }
+    })
+  );
+};
+var createEdgeHandler = async (ctx, definition) => {
+  await copyHandlerDependencies(ctx, definition);
+  await writeHandlerFile(ctx, definition);
+};
+var getHandlerName = ({ name }) => `${EDGE_HANDLER_NAME}-${name.replace(/\W/g, "-")}`;
+var buildHandlerDefinition = (ctx, { name, matchers, page }) => {
+  const fun = getHandlerName({ name });
+  const funName = name.endsWith("middleware") ? "Next.js Middleware Handler" : `Next.js Edge Handler: ${page}`;
+  const cache = name.endsWith("middleware") ? void 0 : "manual";
+  const generator = `${ctx.pluginName}@${ctx.pluginVersion}`;
+  return augmentMatchers(matchers, ctx).map((matcher) => ({
+    function: fun,
+    name: funName,
+    pattern: matcher.regexp,
+    cache,
+    generator
+  }));
+};
+var createEdgeHandlers = async (ctx) => {
+  await rm(ctx.edgeFunctionsDir, { recursive: true, force: true });
+  const nextManifest = await ctx.getMiddlewareManifest();
+  const nextDefinitions = [
+    ...Object.values(nextManifest.middleware)
+    // ...Object.values(nextManifest.functions)
+  ];
+  await Promise.all(nextDefinitions.map((def) => createEdgeHandler(ctx, def)));
+  const netlifyDefinitions = nextDefinitions.flatMap((def) => buildHandlerDefinition(ctx, def));
+  const netlifyManifest = {
+    version: 1,
+    functions: netlifyDefinitions
+  };
+  await writeEdgeManifest(ctx, netlifyManifest);
+};
+
+export {
+  createEdgeHandlers
+};

package/dist/esm-chunks/{package-5SG7C3OT.js → package-V53S3A76.js}

@@ -8,7 +8,7 @@ import "./chunk-5JVNISGM.js";
 
 // package.json
 var name = "@netlify/plugin-nextjs";
-var version = "5.0.0-rc.0";
+var version = "5.0.0-rc.2";
 var description = "Run Next.js seamlessly on Netlify";
 var main = "./dist/index.js";
 var type = "module";
@@ -52,12 +52,12 @@ var devDependencies = {
   "@fastly/http-compute-js": "1.1.4",
   "@netlify/blobs": "^6.5.0",
   "@netlify/build": "^29.36.1",
-  "@netlify/edge-bundler": "^11.2.2",
+  "@netlify/edge-bundler": "^11.3.0",
   "@netlify/edge-functions": "^2.3.1",
   "@netlify/eslint-config-node": "^7.0.1",
   "@netlify/functions": "^2.5.1",
   "@netlify/serverless-functions-api": "^1.10.1",
-  "@netlify/zip-it-and-ship-it": "^9.29.2",
+  "@netlify/zip-it-and-ship-it": "^9.30.0",
   "@opentelemetry/api": "^1.7.0",
   "@opentelemetry/exporter-trace-otlp-http": "^0.48.0",
   "@opentelemetry/resources": "^1.21.0",
@@ -84,6 +84,7 @@ var devDependencies = {
   os: "^0.1.2",
   outdent: "^0.8.0",
   "p-limit": "^4.0.0",
+  "path-to-regexp": "^6.2.1",
   picomatch: "^3.0.1",
   "regexp-tree": "^0.1.27",
   typescript: "^5.1.6",

package/dist/index.js

@@ -12,14 +12,14 @@ import {
   copyStaticContent,
   publishStaticDir,
   unpublishStaticDir
-} from "./esm-chunks/chunk-WQIG4U66.js";
+} from "./esm-chunks/chunk-MPZEWLBG.js";
 import {
   createEdgeHandlers
-} from "./esm-chunks/chunk-UX4JCTAE.js";
+} from "./esm-chunks/chunk-ZZOGIP2V.js";
 import {
   createServerHandler
-} from "./esm-chunks/chunk-FTCARYDZ.js";
-import "./esm-chunks/chunk-4J4A5OE2.js";
+} from "./esm-chunks/chunk-E3NFUTWC.js";
+import "./esm-chunks/chunk-52WMBYKL.js";
 import "./esm-chunks/chunk-VZNKO4OO.js";
 import {
   restoreBuildCache,
@@ -30,13 +30,12 @@ import {
 } from "./esm-chunks/chunk-XXBTIYSL.js";
 import {
   PluginContext
-} from "./esm-chunks/chunk-PGQNT7XM.js";
+} from "./esm-chunks/chunk-655Y7ISI.js";
 import "./esm-chunks/chunk-UYKENJEU.js";
 import "./esm-chunks/chunk-TYCYFZ22.js";
 import "./esm-chunks/chunk-5JVNISGM.js";
 
 // src/index.ts
-import { existsSync } from "node:fs";
 var onPreBuild = async (options) => {
   process.env.NEXT_PRIVATE_STANDALONE = "true";
   if (!options.constants.IS_LOCAL) {
@@ -45,12 +44,7 @@ var onPreBuild = async (options) => {
 };
 var onBuild = async (options) => {
   const ctx = new PluginContext(options);
-  if (!existsSync(ctx.publishDir)) {
-    ctx.failBuild(
-      `Publish directory not found under: ${ctx.publishDir}, please check your netlify.toml`
-    );
-  }
-  await setImageConfig(ctx);
+  ctx.verifyPublishDir();
   if (!options.constants.IS_LOCAL) {
     await saveBuildCache(ctx);
   }
@@ -59,7 +53,8 @@ var onBuild = async (options) => {
     copyStaticContent(ctx),
     copyPrerenderedContent(ctx),
     createServerHandler(ctx),
-    createEdgeHandlers(ctx)
+    createEdgeHandlers(ctx),
+    setImageConfig(ctx)
   ]);
 };
 var onPostBuild = async (options) => {

package/dist/run/config.js

@@ -8,7 +8,7 @@ import {
   getRunConfig,
   getTagsManifest,
   setRunConfig
-} from "../esm-chunks/chunk-NL5YH5N6.js";
+} from "../esm-chunks/chunk-3SUDZQ7L.js";
 import "../esm-chunks/chunk-UYKENJEU.js";
 import "../esm-chunks/chunk-5JVNISGM.js";
 export {

package/dist/run/handlers/server.js

@@ -12,7 +12,7 @@ import {
 } from "../../esm-chunks/chunk-HYBEXB2Z.js";
 import {
   getTagsManifest
-} from "../../esm-chunks/chunk-NL5YH5N6.js";
+} from "../../esm-chunks/chunk-3SUDZQ7L.js";
 import "../../esm-chunks/chunk-UYKENJEU.js";
 import {
   adjustDateHeader,

package/dist/run/handlers/tracing.js

@@ -52794,7 +52794,7 @@ var import_semantic_conventions = __toESM(require_src2(), 1);
 var import_api = __toESM(require_src(), 1);
 var {
   default: { version, name }
-} = await import("../../esm-chunks/package-5SG7C3OT.js");
+} = await import("../../esm-chunks/package-V53S3A76.js");
 var sdk = new import_sdk_node.NodeSDK({
   resource: new import_resources.Resource({
     [import_semantic_conventions.SemanticResourceAttributes.SERVICE_NAME]: name,

package/edge-runtime/lib/next-request.ts

@@ -24,6 +24,7 @@ export interface RequestData {
     basePath?: string
     i18n?: I18NConfig | null
     trailingSlash?: boolean
+    skipMiddlewareUrlNormalize?: boolean
   }
   page?: {
     name?: string
@@ -50,19 +51,23 @@ const normalizeRequestURL = (
       url.pathname,
       nextConfig?.i18n?.locales,
     )
-    url.pathname = pathname
+    if (!nextConfig?.skipMiddlewareUrlNormalize) {
+      url.pathname = pathname || '/'
+    }
     detectedLocale = detected
   }
 
-  // We want to run middleware for data requests and expose the URL of the
-  // corresponding pages, so we have to normalize the URLs before running
-  // the handler.
-  url.pathname = normalizeDataUrl(url.pathname)
+  if (!nextConfig?.skipMiddlewareUrlNormalize) {
+    // We want to run middleware for data requests and expose the URL of the
+    // corresponding pages, so we have to normalize the URLs before running
+    // the handler.
+    url.pathname = normalizeDataUrl(url.pathname)
 
-  // Normalizing the trailing slash based on the `trailingSlash` configuration
-  // property from the Next.js config.
-  if (nextConfig?.trailingSlash && url.pathname !== '/' && !url.pathname.endsWith('/')) {
-    url.pathname = `${url.pathname}/`
+    // Normalizing the trailing slash based on the `trailingSlash` configuration
+    // property from the Next.js config.
+    if (nextConfig?.trailingSlash && url.pathname !== '/' && !url.pathname.endsWith('/')) {
+      url.pathname = `${url.pathname}/`
+    }
   }
 
   if (didRemoveBasePath) {

package/edge-runtime/lib/response.ts

@@ -247,9 +247,10 @@ function normalizeLocalizedTarget({
     !normalizedTarget.pathname.startsWith(`/api/`) &&
     !normalizedTarget.pathname.startsWith(`/_next/static/`)
   ) {
-    targetUrl.pathname = addBasePath(`/${locale}${normalizedTarget.pathname}`, nextConfig?.basePath)
+    targetUrl.pathname =
+      addBasePath(`/${locale}${normalizedTarget.pathname}`, nextConfig?.basePath) || `/`
   } else {
-    targetUrl.pathname = addBasePath(normalizedTarget.pathname, nextConfig?.basePath)
+    targetUrl.pathname = addBasePath(normalizedTarget.pathname, nextConfig?.basePath) || `/`
   }
   return targetUrl.toString()
 }

package/edge-runtime/lib/util.ts

@@ -56,7 +56,7 @@ export function normalizeLocalePath(pathname: string, locales?: string[]): PathL
     if (pathnameParts[1] && pathnameParts[1].toLowerCase() === locale.toLowerCase()) {
       detectedLocale = locale
       pathnameParts.splice(1, 1)
-      pathname = pathnameParts.join('/') || '/'
+      pathname = pathnameParts.join('/')
       return true
     }
     return false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/plugin-nextjs",
-  "version": "5.0.0-rc.0",
+  "version": "5.0.0-rc.2",
   "description": "Run Next.js seamlessly on Netlify",
   "main": "./dist/index.js",
   "type": "module",

package/dist/esm-chunks/chunk-UX4JCTAE.js

@@ -1,134 +0,0 @@
-
-      var require = await (async () => {
-        var { createRequire } = await import("node:module");
-        return createRequire(import.meta.url);
-      })();
-    
-import {
-  require_out
-} from "./chunk-VZNKO4OO.js";
-import {
-  EDGE_HANDLER_NAME
-} from "./chunk-PGQNT7XM.js";
-import {
-  __toESM
-} from "./chunk-5JVNISGM.js";
-
-// src/build/functions/edge.ts
-var import_fast_glob = __toESM(require_out(), 1);
-import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { dirname, join, relative } from "node:path";
-var writeEdgeManifest = async (ctx, manifest) => {
-  await mkdir(ctx.edgeFunctionsDir, { recursive: true });
-  await writeFile(join(ctx.edgeFunctionsDir, "manifest.json"), JSON.stringify(manifest, null, 2));
-};
-var copyRuntime = async (ctx, handlerDirectory) => {
-  const files = await (0, import_fast_glob.glob)("edge-runtime/**/*", {
-    cwd: ctx.pluginDir,
-    ignore: ["**/*.test.ts"],
-    dot: true
-  });
-  await Promise.all(
-    files.map(
-      (path) => cp(join(ctx.pluginDir, path), join(handlerDirectory, path), { recursive: true })
-    )
-  );
-};
-var writeHandlerFile = async (ctx, { matchers, name }) => {
-  const nextConfig = ctx.buildConfig;
-  const handlerName = getHandlerName({ name });
-  const handlerDirectory = join(ctx.edgeFunctionsDir, handlerName);
-  const handlerRuntimeDirectory = join(handlerDirectory, "edge-runtime");
-  await copyRuntime(ctx, handlerDirectory);
-  await writeFile(join(handlerRuntimeDirectory, "matchers.json"), JSON.stringify(matchers));
-  const minimalNextConfig = {
-    basePath: nextConfig.basePath,
-    i18n: nextConfig.i18n,
-    trailingSlash: nextConfig.trailingSlash
-  };
-  await writeFile(
-    join(handlerRuntimeDirectory, "next.config.json"),
-    JSON.stringify(minimalNextConfig)
-  );
-  await writeFile(
-    join(handlerDirectory, `${handlerName}.js`),
-    `
-    import {handleMiddleware} from './edge-runtime/middleware.ts';
-    import handler from './server/${name}.js';
-    export default (req, context) => handleMiddleware(req, context, handler);
-    `
-  );
-};
-var copyHandlerDependencies = async (ctx, { name, files, wasm }) => {
-  const srcDir = join(ctx.standaloneDir, ctx.nextDistDir);
-  const destDir = join(ctx.edgeFunctionsDir, getHandlerName({ name }));
-  await Promise.all(
-    files.map(async (file) => {
-      if (file === `server/${name}.js`) {
-        const edgeRuntimeDir = join(ctx.pluginDir, "edge-runtime");
-        const shimPath = join(edgeRuntimeDir, "shim/index.js");
-        const shim = await readFile(shimPath, "utf8");
-        const importsDir = relative(dirname(join(srcDir, file)), join(srcDir, "server"));
-        const importsSrc = `${importsDir || "."}/edge-runtime-webpack.js`;
-        const imports = `import '${importsSrc}';`;
-        const exports = `export default _ENTRIES["middleware_${name}"].default;`;
-        const parts = [shim, imports];
-        if (wasm?.length) {
-          parts.push(
-            `import { decode as _base64Decode } from "../edge-runtime/vendor/deno.land/std@0.175.0/encoding/base64.ts";`
-          );
-          for (const wasmChunk of wasm ?? []) {
-            const data = await readFile(join(srcDir, wasmChunk.filePath));
-            parts.push(
-              `const ${wasmChunk.name} = _base64Decode(${JSON.stringify(
-                data.toString("base64")
-              )}).buffer`
-            );
-          }
-        }
-        const entrypoint = await readFile(join(srcDir, file), "utf8");
-        await mkdir(dirname(join(destDir, file)), { recursive: true });
-        await writeFile(join(destDir, file), [...parts, entrypoint, exports].join("\n;"));
-      } else {
-        await cp(join(srcDir, file), join(destDir, file));
-      }
-    })
-  );
-};
-var createEdgeHandler = async (ctx, definition) => {
-  await copyHandlerDependencies(ctx, definition);
-  await writeHandlerFile(ctx, definition);
-};
-var getHandlerName = ({ name }) => `${EDGE_HANDLER_NAME}-${name.replace(/\W/g, "-")}`;
-var buildHandlerDefinition = (ctx, { name, matchers, page }) => {
-  const fun = getHandlerName({ name });
-  const funName = name.endsWith("middleware") ? "Next.js Middleware Handler" : `Next.js Edge Handler: ${page}`;
-  const cache = name.endsWith("middleware") ? void 0 : "manual";
-  const generator = `${ctx.pluginName}@${ctx.pluginVersion}`;
-  return matchers.map((matcher) => ({
-    function: fun,
-    name: funName,
-    pattern: matcher.regexp,
-    cache,
-    generator
-  }));
-};
-var createEdgeHandlers = async (ctx) => {
-  await rm(ctx.edgeFunctionsDir, { recursive: true, force: true });
-  const nextManifest = await ctx.getMiddlewareManifest();
-  const nextDefinitions = [
-    ...Object.values(nextManifest.middleware)
-    // ...Object.values(nextManifest.functions)
-  ];
-  await Promise.all(nextDefinitions.map((def) => createEdgeHandler(ctx, def)));
-  const netlifyDefinitions = nextDefinitions.flatMap((def) => buildHandlerDefinition(ctx, def));
-  const netlifyManifest = {
-    version: 1,
-    functions: netlifyDefinitions
-  };
-  await writeEdgeManifest(ctx, netlifyManifest);
-};
-
-export {
-  createEdgeHandlers
-};