one 1.12.5 → 1.12.6

package/dist/cjs/server/workerHandler.native.js

@@ -0,0 +1,673 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var workerHandler_exports = {};
+__export(workerHandler_exports, {
+  createWorkerHandler: () => createWorkerHandler
+});
+module.exports = __toCommonJS(workerHandler_exports);
+var import_constants = require("../constants"),
+  import_createHandleRequest = require("../createHandleRequest"),
+  import_cleanUrl = require("../utils/cleanUrl"),
+  import_isResponse = require("../utils/isResponse"),
+  import_resolveResponse = require("../vite/resolveResponse"),
+  import_ssrLoaderData = require("./ssrLoaderData"),
+  import_staticHtmlFetcher = require("./staticHtmlFetcher");
+function _instanceof(left, right) {
+  return right != null && typeof Symbol < "u" && right[Symbol.hasInstance] ? !!right[Symbol.hasInstance](left) : left instanceof right;
+}
+function _type_of(obj) {
+  "@swc/helpers - typeof";
+
+  return obj && typeof Symbol < "u" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function createWorkerHandler(options) {
+  var _oneOptions_web,
+    {
+      oneOptions
+    } = options,
+    currentLazyRoutes = options.lazyRoutes,
+    compiledManifest = (0, import_createHandleRequest.compileManifest)(options.buildInfo.manifest),
+    routeToBuildInfo = options.buildInfo.routeToBuildInfo,
+    routeMap = options.buildInfo.routeMap,
+    currentPreloads = options.buildInfo.preloads,
+    currentCssPreloads = options.buildInfo.cssPreloads,
+    debugRouter = process.env.ONE_DEBUG_ROUTER,
+    redirects = (_oneOptions_web = oneOptions.web) === null || _oneOptions_web === void 0 ? void 0 : _oneOptions_web.redirects,
+    compiledRedirects = null;
+  redirects?.length && (compiledRedirects = redirects.map(function (r) {
+    var regexSource = r.source.replace(/:(\w+)/g, function (_, name) {
+      return `(?<${name}>[^/]+)`;
+    });
+    return {
+      regex: new RegExp(`^${regexSource}$`),
+      destination: r.destination,
+      permanent: r.permanent || !1
+    };
+  }));
+  var useStreaming = !process.env.ONE_BUFFERED_SSR,
+    htmlHeaders = {
+      "content-type": "text/html"
+    },
+    ssrHtmlHeaders = {
+      "content-type": "text/html",
+      "cache-control": "no-cache"
+    },
+    loaderCache = /* @__PURE__ */new Map(),
+    moduleImportCache = /* @__PURE__ */new Map(),
+    loaderCacheFnMap = /* @__PURE__ */new Map(),
+    pendingLoaderResults = /* @__PURE__ */new Map(),
+    render = null,
+    renderStream = null,
+    renderLoading = null,
+    renderGeneration = 0;
+  function ensureRenderLoaded() {
+    if (!render) {
+      if (renderLoading) return renderLoading;
+      var gen = ++renderGeneration;
+      return renderLoading = async function () {
+        var entry = await currentLazyRoutes.serverEntry();
+        gen === renderGeneration && (render = entry.default.render, renderStream = entry.default.renderStream || null);
+      }(), renderLoading;
+    }
+  }
+  function findNearestNotFoundPath(urlPath) {
+    for (var cur = urlPath; cur;) {
+      var parent = cur.lastIndexOf("/") > 0 ? cur.slice(0, cur.lastIndexOf("/")) : "";
+      if (routeMap[`${parent}/+not-found`]) return `${parent}/+not-found`;
+      if (!parent) break;
+      cur = parent;
+    }
+    return "/+not-found";
+  }
+  function make404LoaderJs(path, logReason) {
+    var nfPath = findNearestNotFoundPath(path);
+    return logReason && console.error(`[one] 404 loader for ${path}: ${logReason}`), `export function loader(){return{__oneError:404,__oneErrorMessage:'Not Found',__oneNotFoundPath:${JSON.stringify(nfPath)}}}`;
+  }
+  async function readStaticHtml(htmlPath) {
+    var fetchStaticHtml = (0, import_staticHtmlFetcher.getFetchStaticHtml)();
+    return fetchStaticHtml ? await fetchStaticHtml(htmlPath) : (debugRouter && console.warn(`[one/worker] no fetchStaticHtml set, cannot read ${htmlPath}`), null);
+  }
+  function resolveLoaderSync(lazyKey) {
+    var cacheKey = lazyKey || "",
+      cached = loaderCache.get(cacheKey);
+    return cached !== void 0 ? cached : async function () {
+      var _ref, routeExported;
+      if (moduleImportCache.has(cacheKey)) routeExported = moduleImportCache.get(cacheKey);else if (lazyKey && currentLazyRoutes.pages[lazyKey]) routeExported = await currentLazyRoutes.pages[lazyKey](), moduleImportCache.set(cacheKey, routeExported);else return console.warn(`[one/worker] no lazy route for ${cacheKey}`), loaderCache.set(cacheKey, null), null;
+      var loader = routeExported?.loader || null;
+      return loaderCache.set(cacheKey, loader), loaderCacheFnMap.set(cacheKey, (_ref = routeExported?.loaderCache) !== null && _ref !== void 0 ? _ref : null), loader;
+    }();
+  }
+  async function importAndRunLoader(routeId, lazyKey, loaderProps) {
+    if (!lazyKey) return {
+      loaderData: void 0,
+      routeId
+    };
+    var cacheMapKey = lazyKey,
+      loaderCacheFn = loaderCacheFnMap.get(cacheMapKey),
+      coalFullKey,
+      coalTtl = 0;
+    if (loaderCacheFn) {
+      var _ref,
+        cacheResult = loaderCacheFn(loaderProps?.params, loaderProps?.request),
+        cacheKey = typeof cacheResult == "string" ? cacheResult : cacheResult?.key;
+      if (coalTtl = typeof cacheResult == "string" ? 0 : (_ref = cacheResult?.ttl) !== null && _ref !== void 0 ? _ref : 0, cacheKey != null) {
+        coalFullKey = routeId + "\0" + cacheKey;
+        var existing = pendingLoaderResults.get(coalFullKey);
+        if (existing && (!existing.expires || Date.now() < existing.expires)) {
+          var loaderData = await existing.promise;
+          return {
+            loaderData,
+            routeId
+          };
+        }
+      }
+    }
+    try {
+      var loaderOrPromise = resolveLoaderSync(lazyKey),
+        loader = _instanceof(loaderOrPromise, Promise) ? await loaderOrPromise : loaderOrPromise;
+      if (!loader) return {
+        loaderData: void 0,
+        routeId
+      };
+      if (coalFullKey) {
+        var promise = loader(loaderProps),
+          entry = {
+            promise,
+            expires: 0
+          };
+        pendingLoaderResults.set(coalFullKey, entry), promise.then(function () {
+          entry.expires = coalTtl > 0 ? Date.now() + coalTtl : 0, coalTtl <= 0 && Promise.resolve().then(function () {
+            return pendingLoaderResults.delete(coalFullKey);
+          });
+        }, function () {
+          return pendingLoaderResults.delete(coalFullKey);
+        });
+        var loaderData1 = await promise;
+        return {
+          loaderData: loaderData1,
+          routeId
+        };
+      }
+      var loaderData2 = await loader(loaderProps);
+      return {
+        loaderData: loaderData2,
+        routeId
+      };
+    } catch (err) {
+      if ((0, import_isResponse.isResponse)(err)) throw err;
+      return err?.code === "ENOENT" ? {
+        loaderData: void 0,
+        routeId,
+        isEnoent: !0
+      } : (console.error(`[one] Error running loader for ${routeId}:`, err), {
+        loaderData: void 0,
+        routeId
+      });
+    }
+  }
+  var requestHandlers = {
+    async handleStaticFile() {
+      return null;
+    },
+    async handleAPI(param) {
+      var {
+        route
+      } = param;
+      return currentLazyRoutes.api[route.page] ? await currentLazyRoutes.api[route.page]() : (console.warn(`[one/worker] no lazy API route for ${route.page}`), null);
+    },
+    async loadMiddleware(route) {
+      return currentLazyRoutes.middlewares[route.contextKey] ? await currentLazyRoutes.middlewares[route.contextKey]() : (console.warn(`[one/worker] no lazy middleware for ${route.contextKey}`), null);
+    },
+    async handleLoader(param) {
+      var {
+          route,
+          loaderProps
+        } = param,
+        routeFile = route.routeFile || route.file,
+        loader;
+      try {
+        var loaderResult = resolveLoaderSync(routeFile);
+        loader = _instanceof(loaderResult, Promise) ? await loaderResult : loaderResult;
+      } catch (err) {
+        if (err?.code === "ERR_MODULE_NOT_FOUND") return null;
+        throw err;
+      }
+      if (!loader) return null;
+      var json;
+      try {
+        json = await loader(loaderProps);
+      } catch (err) {
+        if (err?.code === "ENOENT") return make404LoaderJs(loaderProps?.path || "/", `ENOENT ${err?.path || err}`);
+        throw err;
+      }
+      if ((0, import_isResponse.isResponse)(json)) throw json;
+      return `export function loader() { return ${JSON.stringify(json)} }`;
+    },
+    async handlePage(param) {
+      var {
+          route,
+          url,
+          loaderProps
+        } = param,
+        routeBuildInfo = routeToBuildInfo[route.file];
+      if (route.type === "ssr") {
+        if (!routeBuildInfo) throw console.error("Error in route", route), new Error(`No buildinfo found for ${url}, route: ${route.file}, in keys:
+  ${Object.keys(routeToBuildInfo).join(`
+  `)}`);
+        try {
+          var _globalThis___vxrnresetState,
+            _globalThis,
+            layoutRoutes = route.layouts || [],
+            layoutLoaderPromises = [],
+            noLoaderResults = [],
+            _iteratorNormalCompletion = !0,
+            _didIteratorError = !1,
+            _iteratorError = void 0;
+          try {
+            for (var _iterator = layoutRoutes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
+              var layout = _step.value,
+                cacheKey = layout.contextKey || "",
+                cachedLoader = loaderCache.get(cacheKey);
+              cachedLoader === null ? noLoaderResults.push({
+                loaderData: void 0,
+                routeId: layout.contextKey
+              }) : layoutLoaderPromises.push(importAndRunLoader(layout.contextKey, layout.contextKey, loaderProps));
+            }
+          } catch (err) {
+            _didIteratorError = !0, _iteratorError = err;
+          } finally {
+            try {
+              !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
+            } finally {
+              if (_didIteratorError) throw _iteratorError;
+            }
+          }
+          var pageLoaderPromise = importAndRunLoader(route.file, route.file, loaderProps),
+            layoutResults,
+            pageResult;
+          try {
+            if (layoutLoaderPromises.length === 0) layoutResults = noLoaderResults, pageResult = await pageLoaderPromise;else {
+              var [asyncLayoutResults, pr] = await Promise.all([Promise.all(layoutLoaderPromises), pageLoaderPromise]);
+              layoutResults = [...noLoaderResults, ...asyncLayoutResults], pageResult = pr;
+            }
+          } catch (err) {
+            if ((0, import_isResponse.isResponse)(err)) return err;
+            throw err;
+          }
+          if (pageResult.isEnoent) {
+            var nfPath = findNearestNotFoundPath(loaderProps?.path || "/"),
+              nfHtml = routeMap[nfPath];
+            if (nfHtml) {
+              var html = await readStaticHtml(nfHtml);
+              if (html) return new Response(html, {
+                headers: {
+                  "content-type": "text/html"
+                },
+                status: 404
+              });
+            }
+            return new Response("404 Not Found", {
+              status: 404
+            });
+          }
+          for (var matchPathname = loaderProps?.path || "/", matchParams = loaderProps?.params || {}, matches = new Array(layoutResults.length + 1), i = 0; i < layoutResults.length; i++) {
+            var result = layoutResults[i];
+            matches[i] = {
+              routeId: result.routeId,
+              pathname: matchPathname,
+              params: matchParams,
+              loaderData: result.loaderData
+            };
+          }
+          matches[layoutResults.length] = {
+            routeId: pageResult.routeId,
+            pathname: matchPathname,
+            params: matchParams,
+            loaderData: pageResult.loaderData
+          };
+          var loaderData = pageResult.loaderData,
+            _iteratorNormalCompletion1 = !0,
+            _didIteratorError1 = !1,
+            _iteratorError1 = void 0;
+          try {
+            for (var _loop = function () {
+                var layout2 = _step1.value,
+                  key = layout2.contextKey,
+                  loaderFn = loaderCache.get(key);
+                if (loaderFn) {
+                  var result2 = layoutResults.find(function (r) {
+                    return r.routeId === key;
+                  });
+                  result2 && (0, import_ssrLoaderData.setSSRLoaderData)(loaderFn, result2.loaderData);
+                }
+              }, _iterator1 = layoutRoutes[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = !0) _loop();
+          } catch (err) {
+            _didIteratorError1 = !0, _iteratorError1 = err;
+          } finally {
+            try {
+              !_iteratorNormalCompletion1 && _iterator1.return != null && _iterator1.return();
+            } finally {
+              if (_didIteratorError1) throw _iteratorError1;
+            }
+          }
+          var pageLoaderFn = loaderCache.get(route.file);
+          pageLoaderFn && (0, import_ssrLoaderData.setSSRLoaderData)(pageLoaderFn, pageResult.loaderData), (_globalThis___vxrnresetState = (_globalThis = globalThis).__vxrnresetState) === null || _globalThis___vxrnresetState === void 0 || _globalThis___vxrnresetState.call(_globalThis);
+          var renderProps = {
+              mode: route.type,
+              loaderData,
+              loaderProps,
+              path: loaderProps?.path || "/",
+              preloads: routeBuildInfo.criticalPreloads || routeBuildInfo.preloads,
+              deferredPreloads: routeBuildInfo.deferredPreloads,
+              css: routeBuildInfo.css,
+              cssContents: routeBuildInfo.cssContents,
+              matches
+            },
+            _rl = ensureRenderLoaded();
+          _rl && (await _rl);
+          var status = route.isNotFound ? 404 : 200,
+            responseHeaders = route.isNotFound ? htmlHeaders : ssrHtmlHeaders;
+          if (useStreaming) {
+            var stream = await renderStream(renderProps);
+            return new Response(stream, {
+              headers: responseHeaders,
+              status
+            });
+          }
+          var rendered = await render(renderProps);
+          return new Response(rendered, {
+            headers: responseHeaders,
+            status
+          });
+        } catch (err) {
+          var _ref;
+          return (0, import_isResponse.isResponse)(err) ? err : (console.error(`[one] Error rendering SSR route ${route.file}
+${(_ref = err?.stack) !== null && _ref !== void 0 ? _ref : err}
+url: ${url}`), null);
+        }
+      } else {
+        var layoutRoutes1 = route.layouts || [],
+          needsSpaShell = route.type === "spa" && layoutRoutes1.some(function (layout2) {
+            return layout2.layoutRenderMode === "ssg" || layout2.layoutRenderMode === "ssr";
+          });
+        if (needsSpaShell) try {
+          var _globalThis___vxrnresetState1,
+            _globalThis1,
+            layoutResults1 = await Promise.all(layoutRoutes1.map(function (layout2) {
+              return importAndRunLoader(layout2.contextKey, layout2.contextKey, loaderProps);
+            })),
+            matches1 = layoutResults1.map(function (result2) {
+              return {
+                routeId: result2.routeId,
+                pathname: loaderProps?.path || "/",
+                params: loaderProps?.params || {},
+                loaderData: result2.loaderData
+              };
+            });
+          (_globalThis___vxrnresetState1 = (_globalThis1 = globalThis).__vxrnresetState) === null || _globalThis___vxrnresetState1 === void 0 || _globalThis___vxrnresetState1.call(_globalThis1);
+          var _rl1 = ensureRenderLoaded();
+          _rl1 && (await _rl1);
+          var spaRouteBuildInfo = routeToBuildInfo[route.file],
+            rendered1 = await render({
+              mode: "spa-shell",
+              loaderData: void 0,
+              loaderProps,
+              path: loaderProps?.path || "/",
+              preloads: spaRouteBuildInfo?.criticalPreloads || spaRouteBuildInfo?.preloads,
+              deferredPreloads: spaRouteBuildInfo?.deferredPreloads,
+              css: spaRouteBuildInfo?.css,
+              cssContents: spaRouteBuildInfo?.cssContents,
+              matches: matches1
+            });
+          return new Response(rendered1, {
+            headers: htmlHeaders,
+            status: route.isNotFound ? 404 : 200
+          });
+        } catch (err) {
+          var _ref1;
+          if ((0, import_isResponse.isResponse)(err)) return err;
+          console.error(`[one] Error rendering spa-shell for ${route.file}
+${(_ref1 = err?.stack) !== null && _ref1 !== void 0 ? _ref1 : err}
+url: ${url}`);
+        }
+        var isDynamicRoute = Object.keys(route.routeKeys).length > 0,
+          routeCleanPath = route.urlCleanPath.replace(/\?/g, ""),
+          notFoundKey = route.isNotFound ? route.page.replace(/\[([^\]]+)\]/g, ":$1") : null,
+          htmlPath = notFoundKey ? routeMap[notFoundKey] : isDynamicRoute ? routeMap[routeCleanPath] || routeMap[url.pathname] : routeMap[url.pathname] || routeMap[routeBuildInfo?.cleanPath];
+        if (htmlPath) {
+          var html1 = await readStaticHtml(htmlPath);
+          if (html1) return new Response(html1, {
+            headers: htmlHeaders,
+            status: route.isNotFound ? 404 : 200
+          });
+        }
+        if (isDynamicRoute) {
+          var notFoundRoute = findNearestNotFoundPath(url.pathname),
+            notFoundHtmlPath = routeMap[notFoundRoute];
+          if (notFoundHtmlPath) {
+            var notFoundHtml = await readStaticHtml(notFoundHtmlPath);
+            if (notFoundHtml) {
+              var notFoundMarker = `<script>window.__one404=${JSON.stringify({
+                  originalPath: url.pathname,
+                  notFoundPath: notFoundRoute
+                })}</script>`,
+                injectedHtml = notFoundHtml.includes("</head>") ? notFoundHtml.replace("</head>", `${notFoundMarker}</head>`) : notFoundHtml.replace("<body", `${notFoundMarker}<body`);
+              return new Response(injectedHtml, {
+                headers: htmlHeaders,
+                status: 404
+              });
+            }
+          }
+          return new Response("404 Not Found", {
+            status: 404
+          });
+        }
+        return null;
+      }
+    }
+  };
+  function setCacheHeaders(response, route, isAPI) {
+    if (!response.headers.has("cache-control") && !response.headers.has("Cache-Control")) try {
+      isAPI ? response.headers.set("cache-control", "no-store") : route.type === "ssg" || route.type === "spa" ? response.headers.set("cache-control", "public, s-maxage=60, stale-while-revalidate=120") : response.headers.set("cache-control", "no-cache");
+    } catch {}
+    return response;
+  }
+  async function handleRequest(request) {
+    var url = (0, import_createHandleRequest.getURLfromRequestURL)(request),
+      pathname = url.pathname,
+      method = request.method;
+    if (compiledRedirects) {
+      var _iteratorNormalCompletion = !0,
+        _didIteratorError = !1,
+        _iteratorError = void 0;
+      try {
+        for (var _iterator = compiledRedirects[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
+          var redirect = _step.value,
+            match = redirect.regex.exec(pathname);
+          if (match) {
+            var destination = redirect.destination;
+            if (match.groups) {
+              var _iteratorNormalCompletion1 = !0,
+                _didIteratorError1 = !1,
+                _iteratorError1 = void 0;
+              try {
+                for (var _iterator1 = Object.entries(match.groups)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = !0) {
+                  var [name, value] = _step1.value;
+                  destination = destination.replace(`:${name}`, value);
+                }
+              } catch (err) {
+                _didIteratorError1 = !0, _iteratorError1 = err;
+              } finally {
+                try {
+                  !_iteratorNormalCompletion1 && _iterator1.return != null && _iterator1.return();
+                } finally {
+                  if (_didIteratorError1) throw _iteratorError1;
+                }
+              }
+            }
+            return debugRouter && console.info(`[one] \u21AA redirect ${pathname} \u2192 ${destination}`), new Response(null, {
+              status: redirect.permanent ? 301 : 302,
+              headers: {
+                location: new URL(destination, url.origin).toString()
+              }
+            });
+          }
+        }
+      } catch (err) {
+        _didIteratorError = !0, _iteratorError = err;
+      } finally {
+        try {
+          !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
+        } finally {
+          if (_didIteratorError) throw _iteratorError;
+        }
+      }
+    }
+    if (pathname.endsWith(import_constants.PRELOAD_JS_POSTFIX)) return currentPreloads[pathname] ? null : new Response("", {
+      headers: {
+        "Content-Type": "text/javascript"
+      }
+    });
+    if (pathname.endsWith(import_constants.CSS_PRELOAD_JS_POSTFIX)) return currentCssPreloads?.[pathname] ? null : new Response("export default Promise.resolve()", {
+      headers: {
+        "Content-Type": "text/javascript"
+      }
+    });
+    if (pathname.endsWith(import_constants.LOADER_JS_POSTFIX_UNCACHED)) {
+      var originalUrl = (0, import_cleanUrl.getPathFromLoaderPath)(pathname),
+        _iteratorNormalCompletion2 = !0,
+        _didIteratorError2 = !1,
+        _iteratorError2 = void 0;
+      try {
+        for (var _iterator2 = compiledManifest.pageRoutes[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = !0) {
+          var route = _step2.value;
+          if (route.file !== "" && route.compiledRegex.test(originalUrl)) {
+            if (route.type === "ssg" && Object.keys(route.routeKeys).length > 0 && !routeMap[originalUrl]) return new Response(make404LoaderJs(originalUrl, "ssg route not in routeMap"), {
+              headers: {
+                "Content-Type": "text/javascript"
+              }
+            });
+            var loaderRoute = {
+                ...route,
+                routeFile: route.file,
+                file: route.loaderServerPath || pathname
+              },
+              finalUrl = new URL(originalUrl, url.origin);
+            finalUrl.search = url.search;
+            var cleanedRequest = new Request(finalUrl, request);
+            try {
+              return await (0, import_createHandleRequest.resolveLoaderRoute)(requestHandlers, cleanedRequest, finalUrl, loaderRoute);
+            } catch (err) {
+              return err?.code === "ERR_MODULE_NOT_FOUND" ? new Response("export function loader() { return undefined }", {
+                headers: {
+                  "Content-Type": "text/javascript"
+                }
+              }) : (console.error(`Error running loader: ${err}`), null);
+            }
+          }
+        }
+      } catch (err) {
+        _didIteratorError2 = !0, _iteratorError2 = err;
+      } finally {
+        try {
+          !_iteratorNormalCompletion2 && _iterator2.return != null && _iterator2.return();
+        } finally {
+          if (_didIteratorError2) throw _iteratorError2;
+        }
+      }
+      return null;
+    }
+    if (pathname.endsWith(".js") || pathname.endsWith(".css")) return null;
+    var _iteratorNormalCompletion3 = !0,
+      _didIteratorError3 = !1,
+      _iteratorError3 = void 0;
+    try {
+      for (var _iterator3 = compiledManifest.apiRoutes[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = !0) {
+        var route1 = _step3.value;
+        if (route1.compiledRegex.test(pathname)) {
+          debugRouter && console.info(`[one] \u26A1 ${pathname} \u2192 matched API route: ${route1.page}`);
+          var response = await (0, import_createHandleRequest.resolveAPIRoute)(requestHandlers, request, url, route1);
+          return response && (0, import_isResponse.isResponse)(response) ? setCacheHeaders(response, route1, !0) : null;
+        }
+      }
+    } catch (err) {
+      _didIteratorError3 = !0, _iteratorError3 = err;
+    } finally {
+      try {
+        !_iteratorNormalCompletion3 && _iterator3.return != null && _iterator3.return();
+      } finally {
+        if (_didIteratorError3) throw _iteratorError3;
+      }
+    }
+    if (method === "GET") {
+      var _iteratorNormalCompletion4 = !0,
+        _didIteratorError4 = !1,
+        _iteratorError4 = void 0;
+      try {
+        for (var _loop = async function () {
+            var route2 = _step4.value,
+              _route_middlewares;
+            if (!route2.compiledRegex.test(pathname)) return "continue";
+            if (debugRouter && console.info(`[one] \u26A1 ${pathname} \u2192 matched page route: ${route2.page} (${route2.type})`), route2.type === "ssr" && !(!((_route_middlewares = route2.middlewares) === null || _route_middlewares === void 0) && _route_middlewares.length)) {
+              var params = {},
+                match2 = route2.compiledRegex.exec(pathname);
+              if (match2?.groups) {
+                var _iteratorNormalCompletion5 = !0,
+                  _didIteratorError5 = !1,
+                  _iteratorError5 = void 0;
+                try {
+                  for (var _iterator5 = Object.entries(match2.groups)[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = !0) {
+                    var [key, value2] = _step5.value;
+                    params[route2.routeKeys[key]] = value2;
+                  }
+                } catch (err) {
+                  _didIteratorError5 = !0, _iteratorError5 = err;
+                } finally {
+                  try {
+                    !_iteratorNormalCompletion5 && _iterator5.return != null && _iterator5.return();
+                  } finally {
+                    if (_didIteratorError5) throw _iteratorError5;
+                  }
+                }
+              }
+              var loaderProps = {
+                  path: pathname,
+                  search: url.search,
+                  request,
+                  params
+                },
+                response2 = await (0, import_resolveResponse.withRequestContext)(async function () {
+                  try {
+                    return await requestHandlers.handlePage({
+                      request,
+                      route: route2,
+                      url,
+                      loaderProps
+                    });
+                  } catch (err) {
+                    if ((0, import_isResponse.isResponse)(err)) return err;
+                    throw err;
+                  }
+                });
+              return response2 && (0, import_isResponse.isResponse)(response2) ? {
+                v: setCacheHeaders(response2, route2, !1)
+              } : {
+                v: null
+              };
+            }
+            try {
+              var response1 = await (0, import_createHandleRequest.resolvePageRoute)(requestHandlers, request, url, route2);
+              if (response1 && (0, import_isResponse.isResponse)(response1)) return {
+                v: setCacheHeaders(response1, route2, !1)
+              };
+            } catch (err) {
+              console.error(` [one] Error handling request: ${err.stack}`);
+            }
+            return {
+              v: null
+            };
+          }, _iterator4 = compiledManifest.pageRoutes[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = !0) {
+          var _ret = await _loop();
+          if (_type_of(_ret) === "object") return _ret.v;
+        }
+      } catch (err) {
+        _didIteratorError4 = !0, _iteratorError4 = err;
+      } finally {
+        try {
+          !_iteratorNormalCompletion4 && _iterator4.return != null && _iterator4.return();
+        } finally {
+          if (_didIteratorError4) throw _iteratorError4;
+        }
+      }
+    }
+    return null;
+  }
+  function updateRoutes(newBuildInfo, newLazyRoutes) {
+    compiledManifest = (0, import_createHandleRequest.compileManifest)(newBuildInfo.manifest), routeToBuildInfo = newBuildInfo.routeToBuildInfo, routeMap = newBuildInfo.routeMap, currentPreloads = newBuildInfo.preloads, currentCssPreloads = newBuildInfo.cssPreloads, newLazyRoutes && (currentLazyRoutes = newLazyRoutes), loaderCache.clear(), moduleImportCache.clear(), loaderCacheFnMap.clear(), pendingLoaderResults.clear(), render = null, renderStream = null, renderLoading = null;
+  }
+  return {
+    handleRequest,
+    updateRoutes
+  };
+}
+//# sourceMappingURL=workerHandler.native.js.map