@edgeone/opennextjs-pages 0.1.5-beta.1 → 0.1.6

package/dist/build/plugin-context.js

@@ -22,7 +22,7 @@ import { fileURLToPath } from "node:url";
 var MODULE_DIR = fileURLToPath(new URL(".", import.meta.url));
 var PLUGIN_DIR = join(MODULE_DIR, "../..");
 var DEFAULT_PUBLISH_DIR = ".next";
-var SERVER_HANDLER_NAME = "cloud-functions/ssr-node";
+var SERVER_HANDLER_NAME = "server-handler";
 var EDGE_HANDLER_NAME = "edgeone-edge-handler";
 var PluginContext = class {
   edgeoneConfig;

package/dist/build/routes.js

@@ -9,85 +9,18 @@ import "../esm-chunks/chunk-6BT4RYQJ.js";
 // src/build/routes.ts
 import * as fs from "fs";
 import * as path from "path";
-import {
-  convertRedirects,
-  convertRewrites,
-  convertHeaders,
-  convertTrailingSlash
-} from "./route-utils.js";
-function hasAppRouter(appPathRoutesManifest) {
-  return appPathRoutesManifest && Object.keys(appPathRoutesManifest).length > 0;
-}
-function getBuildId(ctx) {
-  try {
-    const buildIdPath = path.join(ctx.publishDir, "BUILD_ID");
-    if (fs.existsSync(buildIdPath)) {
-      return fs.readFileSync(buildIdPath, "utf-8").trim();
-    }
-  } catch {
-  }
-  return null;
-}
-function isRE2Compatible(regex) {
-  if (/\(\?[=!<]/.test(regex)) {
-    return false;
-  }
-  if (/\\[1-9]/.test(regex)) {
-    return false;
-  }
-  return true;
-}
-function convertNamedRegexToSrc(namedRegex, basePath = "") {
-  const regexWithoutNamedGroups = namedRegex.replace(/\(\?<[a-zA-Z][a-zA-Z0-9_]*>/g, "(");
-  if (!isRE2Compatible(regexWithoutNamedGroups)) {
-    console.warn(`[opennext] Warning: Regex not RE2 compatible, skipping: ${namedRegex}`);
-    return null;
-  }
-  let src = namedRegex.replace(/\(\?<[a-zA-Z][a-zA-Z0-9_]*>/g, "(");
-  if (basePath && !src.startsWith(`^${basePath}`)) {
-    src = src.replace(/^\^/, `^${basePath}`);
-  }
-  return src;
-}
-function getDynamicRoutes(dynamicRoutes, basePath = "") {
-  const routes = [];
-  for (const route of dynamicRoutes) {
-    if (route.namedRegex) {
-      const src = convertNamedRegexToSrc(route.namedRegex, basePath);
-      if (src) {
-        routes.push({ src });
-      }
-    } else if (route.regex) {
-      if (isRE2Compatible(route.regex)) {
-        let src = route.regex;
-        if (basePath && !src.startsWith(`^${basePath}`)) {
-          src = src.replace(/^\^/, `^${basePath}`);
-        }
-        routes.push({ src });
-      }
-    }
-  }
-  return routes;
-}
-function getDataRoutes(dataRoutes, basePath = "") {
-  const routes = [];
-  for (const route of dataRoutes) {
-    if (route.namedDataRouteRegex) {
-      const src = convertNamedRegexToSrc(route.namedDataRouteRegex, basePath);
-      if (src) {
-        routes.push({ src });
-      }
-    } else if (route.dataRouteRegex) {
-      if (isRE2Compatible(route.dataRouteRegex)) {
-        let src = route.dataRouteRegex;
-        if (basePath && !src.startsWith(`^${basePath}`)) {
-          src = src.replace(/^\^/, `^${basePath}`);
-        }
-        routes.push({ src });
-      }
-    }
-  }
-  return routes;
+function isRE2Compatible(regexSource) {
+  const unsupported = [
+    /\(\?[=!<]/,
+    // 断言（前瞻、后顾）
+    /\(\?>/,
+    // 原子组
+    /\\(\d+)/,
+    // 反向引用 \1 \2
+    /\(\?\(/
+    // 条件表达式
+  ];
+  return !unsupported.some((r) => r.test(regexSource));
 }
 async function getMiddlewareConfig(ctx) {
   try {
@@ -158,8 +91,8 @@ async function getMiddlewareConfig(ctx) {
     return null;
   }
 }
-function updateEdgeFunctionsConfigJson(middlewareConfig) {
-  const metaJsonPath = path.join(process.cwd(), ".edgeone/edge-functions/config.json");
+function updateEdgeFunctionsMetaJson(middlewareConfig) {
+  const metaJsonPath = path.join(process.cwd(), ".edgeone/edge-functions/meta.json");
   let meta = { routes: [] };
   if (fs.existsSync(metaJsonPath)) {
     try {
@@ -177,128 +110,101 @@ function updateEdgeFunctionsConfigJson(middlewareConfig) {
   }
   fs.writeFileSync(metaJsonPath, JSON.stringify(meta, null, 2), "utf-8");
 }
+var convertNextRoutePattern = (path2) => {
+  if (!path2.includes("[")) {
+    return path2;
+  }
+  let convertedPath = path2;
+  const optionalCatchAllMatch = path2.match(/\[\[\.\.\.([^\]]+)\]\]/);
+  if (optionalCatchAllMatch) {
+    const paramName = optionalCatchAllMatch[1];
+    convertedPath = convertedPath.replace(/\[\[\.\.\.([^\]]+)\]\]/g, `:${paramName}*`);
+  }
+  const catchAllMatch = path2.match(/\[\.\.\.([^\]]+)\]/);
+  if (catchAllMatch) {
+    const paramName = catchAllMatch[1];
+    convertedPath = convertedPath.replace(/\[\.\.\.([^\]]+)\]/g, `:${paramName}*`);
+  }
+  const dynamicMatch = path2.match(/\[([^\]]+)\]/);
+  if (dynamicMatch) {
+    const paramName = dynamicMatch[1];
+    convertedPath = convertedPath.replace(/\[([^\]]+)\]/g, `:${paramName}`);
+  }
+  return convertedPath;
+};
 var createRouteMeta = async (ctx) => {
-  const routes = [];
-  const routesManifest = await ctx.getRoutesManifest();
-  const appPathRoutesManifest = await ctx.getAppPathRoutesManifest();
-  const isAppRouter = hasAppRouter(appPathRoutesManifest);
-  const basePath = routesManifest?.basePath || "";
-  const trailingSlash = ctx.requiredServerFiles?.config?.trailingSlash ?? false;
-  const redirects = routesManifest?.redirects || [];
-  const headers = routesManifest?.headers || [];
-  const rewrites = routesManifest?.rewrites || { beforeFiles: [], afterFiles: [], fallback: [] };
-  let beforeFilesRewrites = [];
-  let afterFilesRewrites = [];
-  let fallbackRewrites = [];
-  if (Array.isArray(rewrites)) {
-    afterFilesRewrites = rewrites;
-  } else {
-    beforeFilesRewrites = rewrites.beforeFiles || [];
-    afterFilesRewrites = rewrites.afterFiles || [];
-    fallbackRewrites = rewrites.fallback || [];
-  }
-  const dynamicRoutes = routesManifest?.dynamicRoutes || [];
-  const dataRoutes = routesManifest?.dataRoutes || [];
-  const buildId = getBuildId(ctx);
-  const staticCacheRegex = buildId ? `^${basePath}/_next/static/(?:[^/]+/pages|pages|chunks|runtime|css|image|media|${buildId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")})/.+` : `^${basePath}/_next/static/(?:[^/]+/pages|pages|chunks|runtime|css|image|media)/.+`;
-  routes.push({
-    src: staticCacheRegex,
-    headers: {
-      "cache-control": "public,max-age=31536000,immutable"
-    },
-    continue: true
-  });
-  if (trailingSlash) {
-    routes.push(...convertTrailingSlash(true));
-  } else {
-    routes.push(...convertTrailingSlash(false));
-  }
-  if (headers.length > 0) {
-    try {
-      routes.push(...convertHeaders(headers));
-    } catch (e) {
-      console.warn("[opennext] Warning: Failed to convert some headers:", e);
+  const routeMap = {};
+  const manifest = await ctx.getPrerenderManifest();
+  if (manifest?.routes) {
+    for (const [route, routeInfo] of Object.entries(manifest.routes)) {
+      routeMap[route] = {
+        // 提取关键信息到routeMap
+        isStatic: routeInfo.initialRevalidateSeconds === false,
+        initialRevalidateSeconds: routeInfo.initialRevalidateSeconds || void 0,
+        srcRoute: routeInfo.srcRoute || void 0,
+        dataRoute: routeInfo.dataRoute || void 0
+      };
     }
   }
-  const userRedirects = redirects.filter((r) => !r.internal);
-  if (userRedirects.length > 0) {
-    try {
-      routes.push(...convertRedirects(userRedirects));
-    } catch (e) {
-      console.warn("[opennext] Warning: Failed to convert some redirects:", e);
+  const pagesManifest = await ctx.getPagesManifest();
+  if (pagesManifest) {
+    for (const [route, filePath] of Object.entries(pagesManifest)) {
+      if (!routeMap[route]) {
+        routeMap[route] = {};
+      }
+      if (filePath.startsWith("pages") && filePath.endsWith(".html")) {
+        routeMap[route].isStatic = true;
+      }
     }
   }
-  if (beforeFilesRewrites.length > 0) {
-    try {
-      routes.push(...convertRewrites(beforeFilesRewrites));
-    } catch (e) {
-      console.warn("[opennext] Warning: Failed to convert beforeFiles rewrites:", e);
+  const appPathRoutesManifest = await ctx.getAppPathRoutesManifest();
+  if (appPathRoutesManifest) {
+    for (const [route, actualRoute] of Object.entries(appPathRoutesManifest)) {
+      if (!routeMap[actualRoute]) {
+        routeMap[actualRoute] = {};
+      }
     }
   }
-  if (isAppRouter) {
-    const rscVary = "RSC, Next-Router-State-Tree, Next-Router-Prefetch, Next-Router-Segment-Prefetch";
-    routes.push({
-      src: `^${basePath}/?$`,
-      has: [{ type: "header", key: "rsc", value: "1" }],
-      dest: `${basePath}/index.rsc`,
-      headers: { vary: rscVary },
-      continue: true
-    });
-    routes.push({
-      src: `^${basePath}/(.+?)(?:/)?$`,
-      exclude: "\\.rsc/?$",
-      has: [{ type: "header", key: "rsc", value: "1" }],
-      dest: `${basePath}/$1.rsc`,
-      headers: { vary: rscVary },
-      continue: true
-    });
-  }
-  routes.push({
-    src: `^${basePath}/404/?$`,
-    status: 404,
-    continue: true,
-    missing: [{ type: "header", key: "x-prerender-revalidate" }]
-  });
-  routes.push({
-    src: `^${basePath}/500$`,
-    status: 500,
-    continue: true
-  });
-  routes.push({
-    src: `^${basePath}/((?:[^/]+/)*[^/.]+)/$`,
-    dest: `${basePath}/$1`,
-    continue: true
-  });
-  routes.push({ handle: "filesystem" });
-  if (afterFilesRewrites.length > 0) {
-    try {
-      routes.push(...convertRewrites(afterFilesRewrites));
-    } catch (e) {
-      console.warn("[opennext] Warning: Failed to convert afterFiles rewrites:", e);
+  const routesManifest = await ctx.getRoutesManifest();
+  if (routesManifest) {
+    const dataRoutes = routesManifest.dataRoutes;
+    if (dataRoutes) {
+      for (const { page, dataRouteRegex } of dataRoutes) {
+        routeMap[dataRouteRegex] = {
+          isStatic: routeMap[page]?.isStatic || false
+        };
+      }
     }
   }
-  if (fallbackRewrites.length > 0) {
-    try {
-      routes.push(...convertRewrites(fallbackRewrites));
-    } catch (e) {
-      console.warn("[opennext] Warning: Failed to convert fallback rewrites:", e);
+  const imagesManifest = await ctx.getImagesManifest();
+  if (imagesManifest) {
+    if (imagesManifest.images) {
+      const imageConfig = imagesManifest.images;
+      routeMap[imageConfig.path] = {};
     }
   }
-  if (dynamicRoutes.length > 0) {
-    routes.push(...getDynamicRoutes(dynamicRoutes, basePath));
+  const convertedRouteMap = {};
+  const pathsToDelete = [];
+  for (const [routePath, routeConfig] of Object.entries(routeMap)) {
+    const convertedPath = convertNextRoutePattern(routePath);
+    if (convertedPath !== routePath) {
+      pathsToDelete.push(routePath);
+      convertedRouteMap[convertedPath] = routeConfig;
+    }
   }
-  if (dataRoutes.length > 0) {
-    routes.push(...getDataRoutes(dataRoutes, basePath));
+  for (const pathToDelete of pathsToDelete) {
+    delete routeMap[pathToDelete];
   }
-  routes.push({
-    src: `^${basePath}/.*$`
-  });
+  Object.assign(routeMap, convertedRouteMap);
+  const routesArray = Object.entries(routeMap).map(([path2, config]) => ({
+    path: path2,
+    ...config
+  }));
   const serverHandlerDir = ctx.serverHandlerRootDir;
   if (!fs.existsSync(serverHandlerDir)) {
     fs.mkdirSync(serverHandlerDir, { recursive: true });
   }
-  const nextVersion = ctx.nextVersion || null;
-  const imagesManifest = await ctx.getImagesManifest();
+  const metaFilePath = path.join(serverHandlerDir, "meta.json");
   const updatedRedirects = [];
   if (imagesManifest?.images?.path) {
     const imagePath = imagesManifest.images.path;
@@ -309,24 +215,21 @@ var createRouteMeta = async (ctx) => {
     };
     updatedRedirects.push(nextImageRedirect);
   }
-  const config = {
-    version: 3,
-    routes,
+  const metaData = {
     conf: {
       redirects: updatedRedirects
     },
-    ...nextVersion ? { framework: { version: nextVersion } } : {}
+    nextRoutes: routesArray
   };
-  const configFilePath = path.join(serverHandlerDir, "config.json");
   fs.writeFileSync(
-    configFilePath,
-    JSON.stringify(config, null, 2),
+    metaFilePath,
+    JSON.stringify(metaData, null, 2),
     "utf-8"
   );
-  console.log(`[opennext] Generated ${configFilePath} with ${routes.length} routes`);
   const middlewareConfig = await getMiddlewareConfig(ctx);
-  updateEdgeFunctionsConfigJson(middlewareConfig);
+  updateEdgeFunctionsMetaJson(middlewareConfig);
 };
 export {
+  convertNextRoutePattern,
   createRouteMeta
 };

package/dist/run/handlers/tags-handler.cjs

@@ -28,7 +28,7 @@ module.exports = __toCommonJS(tags_handler_exports);
 
 // package.json
 var name = "@edgeone/opennextjs-pages";
-var version = "0.1.5-beta.1";
+var version = "0.1.6";
 
 // src/run/handlers/tags-handler.cts
 var import_request_context = require("./request-context.cjs");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@edgeone/opennextjs-pages",
-  "version": "0.1.5-beta.1",
+  "version": "0.1.6",
   "description": "",
   "main": "./dist/index.js",
   "type": "module",

package/dist/build/route-utils.js

@@ -1,698 +0,0 @@
-
-      var require = await (async () => {
-        var { createRequire } = await import("node:module");
-        return createRequire(import.meta.url);
-      })();
-    
-import {
-  __commonJS,
-  __toESM
-} from "../esm-chunks/chunk-6BT4RYQJ.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, _b = options.delimiter, delimiter = _b === void 0 ? "/#?" : _b;
-      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;
-      };
-      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) {
-            path += prefix;
-            prefix = "";
-          }
-          if (path) {
-            result.push(path);
-            path = "";
-          }
-          result.push({
-            name: name || key++,
-            prefix,
-            suffix: "",
-            pattern: pattern || safePattern(prefix),
-            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 ? safePattern(prefix) : pattern_1,
-            prefix,
-            suffix,
-            modifier: tryConsume("MODIFIER") || ""
-          });
-          continue;
-        }
-        mustConsume("END");
-      }
-      return result;
-    }
-    exports.parse = parse;
-    function compile2(str, options) {
-      return tokensToFunction(parse(str, options), options);
-    }
-    exports.compile = compile2;
-    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 === "*") {
-                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 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/route-utils.ts
-var import_path_to_regexp = __toESM(require_dist(), 1);
-import { parse as parseUrl, format as formatUrl } from "url";
-var UN_NAMED_SEGMENT = "__UN_NAMED_SEGMENT__";
-function sourceToRegex(source) {
-  const keys = [];
-  const r = (0, import_path_to_regexp.pathToRegexp)(source, keys, {
-    strict: true,
-    sensitive: true,
-    delimiter: "/"
-  });
-  const segments = keys.map((k) => k.name).map((name) => {
-    if (typeof name !== "string") {
-      return UN_NAMED_SEGMENT;
-    }
-    return name;
-  });
-  return { src: r.source, segments };
-}
-var namedGroupsRegex = /\(\?<([a-zA-Z][a-zA-Z0-9_]*)>/g;
-function normalizeHasKeys(hasItems = []) {
-  for (const hasItem of hasItems) {
-    if ("key" in hasItem && hasItem.type === "header") {
-      hasItem.key = hasItem.key.toLowerCase();
-    }
-  }
-  return hasItems;
-}
-function collectHasSegments(has) {
-  const hasSegments = /* @__PURE__ */ new Set();
-  for (const hasItem of has || []) {
-    if (!hasItem.value && "key" in hasItem) {
-      hasSegments.add(hasItem.key);
-    }
-    if (typeof hasItem.value === "string") {
-      for (const match of hasItem.value.matchAll(namedGroupsRegex)) {
-        if (match[1]) {
-          hasSegments.add(match[1]);
-        }
-      }
-      if (hasItem.type === "host") {
-        hasSegments.add("host");
-      }
-    }
-  }
-  return [...hasSegments];
-}
-function toSegmentDest(index) {
-  return "$" + (index + 1).toString();
-}
-var escapeSegment = (str, segmentName) => str.replace(
-  new RegExp(`:${segmentName}`, "g"),
-  `__ESC_COLON_${segmentName}`
-);
-var unescapeSegments = (str) => str.replace(/__ESC_COLON_/gi, ":");
-function safelyCompile(value, indexes, attemptDirectCompile) {
-  if (!value) {
-    return value;
-  }
-  if (attemptDirectCompile) {
-    try {
-      return (0, import_path_to_regexp.compile)(value, { validate: false })(indexes);
-    } catch (_) {
-    }
-  }
-  for (const key of Object.keys(indexes)) {
-    if (value.includes(`:${key}`)) {
-      value = value.replace(
-        new RegExp(`:${key}\\*`, "g"),
-        `:${key}--ESCAPED_PARAM_ASTERISK`
-      ).replace(
-        new RegExp(`:${key}\\?`, "g"),
-        `:${key}--ESCAPED_PARAM_QUESTION`
-      ).replace(
-        new RegExp(`:${key}\\+`, "g"),
-        `:${key}--ESCAPED_PARAM_PLUS`
-      ).replace(
-        new RegExp(`:${key}(?!\\w)`, "g"),
-        `--ESCAPED_PARAM_COLON${key}`
-      );
-    }
-  }
-  value = value.replace(/(:|\\*|\\?|\\+|\\(|\\)|\\{|\\})/g, "\\$1").replace(/--ESCAPED_PARAM_PLUS/g, "+").replace(/--ESCAPED_PARAM_COLON/g, ":").replace(/--ESCAPED_PARAM_QUESTION/g, "?").replace(/--ESCAPED_PARAM_ASTERISK/g, "*");
-  return (0, import_path_to_regexp.compile)(`/${value}`, { validate: false })(indexes).slice(1);
-}
-function replaceSegments(segments, hasItemSegments, destination, isRedirect, internalParamNames) {
-  const namedSegments = segments.filter((name) => name !== UN_NAMED_SEGMENT);
-  const canNeedReplacing = destination.includes(":") && namedSegments.length > 0 || hasItemSegments.length > 0 || !isRedirect;
-  if (!canNeedReplacing) {
-    return destination;
-  }
-  let escapedDestination = destination;
-  const indexes = {};
-  segments.forEach((name, index) => {
-    indexes[name] = toSegmentDest(index);
-    escapedDestination = escapeSegment(escapedDestination, name);
-  });
-  hasItemSegments.forEach((name) => {
-    indexes[name] = "$" + name;
-    escapedDestination = escapeSegment(escapedDestination, name);
-  });
-  const parsedDestination = parseUrl(escapedDestination, true);
-  delete parsedDestination.href;
-  delete parsedDestination.path;
-  delete parsedDestination.search;
-  delete parsedDestination.host;
-  let { pathname, hash, query, hostname, ...rest } = parsedDestination;
-  pathname = unescapeSegments(pathname || "");
-  hash = unescapeSegments(hash || "");
-  hostname = unescapeSegments(hostname || "");
-  let destParams = /* @__PURE__ */ new Set();
-  const pathnameKeys = [];
-  const hashKeys = [];
-  const hostnameKeys = [];
-  try {
-    (0, import_path_to_regexp.pathToRegexp)(pathname, pathnameKeys);
-    (0, import_path_to_regexp.pathToRegexp)(hash || "", hashKeys);
-    (0, import_path_to_regexp.pathToRegexp)(hostname || "", hostnameKeys);
-  } catch (_) {
-  }
-  destParams = new Set(
-    [...pathnameKeys, ...hashKeys, ...hostnameKeys].map((key) => key.name).filter((val) => typeof val === "string")
-  );
-  pathname = safelyCompile(pathname, indexes, true);
-  hash = hash ? safelyCompile(hash, indexes, true) : null;
-  hostname = hostname ? safelyCompile(hostname, indexes, true) : null;
-  for (const [key, strOrArray] of Object.entries(query)) {
-    if (Array.isArray(strOrArray)) {
-      query[key] = strOrArray.map(
-        (str) => safelyCompile(unescapeSegments(str), indexes, true)
-      );
-    } else {
-      query[key] = safelyCompile(
-        unescapeSegments(strOrArray),
-        indexes,
-        true
-      );
-    }
-  }
-  const paramKeys = Object.keys(indexes);
-  const needsQueryUpdating = !isRedirect && !paramKeys.some(
-    (param) => !(internalParamNames && internalParamNames.includes(param)) && destParams.has(param)
-  );
-  if (needsQueryUpdating) {
-    for (const param of paramKeys) {
-      if (!(param in query) && param !== UN_NAMED_SEGMENT) {
-        query[param] = indexes[param];
-      }
-    }
-  }
-  destination = formatUrl({
-    ...rest,
-    hostname,
-    pathname,
-    query,
-    hash
-  });
-  return destination.replace(/%24/g, "$");
-}
-function convertRedirects(redirects, defaultStatus = 308) {
-  return redirects.map((r) => {
-    const { src, segments } = sourceToRegex(r.source);
-    const hasSegments = collectHasSegments(r.has);
-    normalizeHasKeys(r.has);
-    normalizeHasKeys(r.missing);
-    try {
-      const loc = replaceSegments(segments, hasSegments, r.destination, true);
-      let status;
-      if (typeof r.permanent === "boolean") {
-        status = r.permanent ? 308 : 307;
-      } else if (r.statusCode) {
-        status = r.statusCode;
-      } else {
-        status = defaultStatus;
-      }
-      const route = {
-        src,
-        headers: { Location: loc },
-        status
-      };
-      if (r.has) {
-        route.has = r.has;
-      }
-      if (r.missing) {
-        route.missing = r.missing;
-      }
-      return route;
-    } catch (e) {
-      throw new Error(`Failed to parse redirect: ${JSON.stringify(r)}`);
-    }
-  });
-}
-function convertRewrites(rewrites, internalParamNames) {
-  return rewrites.map((r) => {
-    const { src, segments } = sourceToRegex(r.source);
-    const hasSegments = collectHasSegments(r.has);
-    normalizeHasKeys(r.has);
-    normalizeHasKeys(r.missing);
-    try {
-      const dest = replaceSegments(
-        segments,
-        hasSegments,
-        r.destination,
-        false,
-        internalParamNames
-      );
-      const route = { src, dest, check: true };
-      if (r.has) {
-        route.has = r.has;
-      }
-      if (r.missing) {
-        route.missing = r.missing;
-      }
-      if (r.statusCode) {
-        route.status = r.statusCode;
-      }
-      return route;
-    } catch (e) {
-      throw new Error(`Failed to parse rewrite: ${JSON.stringify(r)}`);
-    }
-  });
-}
-function convertHeaders(headers) {
-  return headers.map((h) => {
-    const obj = {};
-    const { src, segments } = sourceToRegex(h.source);
-    const hasSegments = collectHasSegments(h.has);
-    normalizeHasKeys(h.has);
-    normalizeHasKeys(h.missing);
-    const namedSegments = segments.filter((name) => name !== UN_NAMED_SEGMENT);
-    const indexes = {};
-    segments.forEach((name, index) => {
-      indexes[name] = toSegmentDest(index);
-    });
-    hasSegments.forEach((name) => {
-      indexes[name] = "$" + name;
-    });
-    h.headers.forEach(({ key, value }) => {
-      if (namedSegments.length > 0 || hasSegments.length > 0) {
-        if (key.includes(":")) {
-          key = safelyCompile(key, indexes);
-        }
-        if (value.includes(":")) {
-          value = safelyCompile(value, indexes);
-        }
-      }
-      obj[key] = value;
-    });
-    const route = {
-      src,
-      headers: obj,
-      continue: true
-    };
-    if (h.has) {
-      route.has = h.has;
-    }
-    if (h.missing) {
-      route.missing = h.missing;
-    }
-    return route;
-  });
-}
-function convertTrailingSlash(enable, status = 308) {
-  const routes = [];
-  if (enable) {
-    routes.push({
-      src: "^\\/\\.well-known(?:\\/.*)?$"
-    });
-    routes.push({
-      src: "^/((?:[^/]+/)*[^/\\.]+)$",
-      headers: { Location: "/$1/" },
-      status
-    });
-    routes.push({
-      src: "^/((?:[^/]+/)*[^/]+\\.\\w+)/$",
-      headers: { Location: "/$1" },
-      status
-    });
-  } else {
-    routes.push({
-      src: "^/(.*)\\/$",
-      headers: { Location: "/$1" },
-      status
-    });
-  }
-  return routes;
-}
-export {
-  collectHasSegments,
-  convertHeaders,
-  convertRedirects,
-  convertRewrites,
-  convertTrailingSlash,
-  normalizeHasKeys,
-  safelyCompile,
-  sourceToRegex
-};