@qwik.dev/router 2.0.0-beta.3 → 2.0.0-beta.30

package/lib/chunks/worker-thread.qwik.mjs

@@ -0,0 +1,2572 @@
+import { parentPort } from 'node:worker_threads';
+import { isDev, _UNINITIALIZED, _deserialize, _verifySerializable, _serialize } from '@qwik.dev/core/internal';
+import { withLocale, inlinedQrl } from '@qwik.dev/core';
+import { A as AbortMessage$1 } from './redirect-handler.mjs';
+import { isServer } from '@qwik.dev/core/build';
+import { d as deepFreeze } from './deepFreeze.qwik.mjs';
+
+const QACTION_KEY = "qaction";
+const QLOADER_KEY = "qloaders";
+const QFN_KEY = "qfunc";
+const QDATA_KEY = "qdata";
+const Q_ROUTE = "q:route";
+
+const mergeArray = (existingArr, newArr) => {
+  if (Array.isArray(newArr)) {
+    for (const newItem of newArr) {
+      if (typeof newItem.key === "string") {
+        const existingIndex = existingArr.findIndex((i) => i.key === newItem.key);
+        if (existingIndex > -1) {
+          existingArr[existingIndex] = newItem;
+          continue;
+        }
+      }
+      existingArr.push(newItem);
+    }
+  }
+};
+const resolveDocumentHead = (resolvedHead, updatedHead) => {
+  if (typeof updatedHead.title === "string") {
+    resolvedHead.title = updatedHead.title;
+  }
+  mergeArray(resolvedHead.meta, updatedHead.meta);
+  mergeArray(resolvedHead.links, updatedHead.links);
+  mergeArray(resolvedHead.styles, updatedHead.styles);
+  mergeArray(resolvedHead.scripts, updatedHead.scripts);
+  Object.assign(resolvedHead.frontmatter, updatedHead.frontmatter);
+};
+const createDocumentHead = (defaults) => ({
+  title: defaults?.title || "",
+  meta: [
+    ...defaults?.meta || []
+  ],
+  links: [
+    ...defaults?.links || []
+  ],
+  styles: [
+    ...defaults?.styles || []
+  ],
+  scripts: [
+    ...defaults?.scripts || []
+  ],
+  frontmatter: {
+    ...defaults?.frontmatter
+  }
+});
+const resolveRouteConfig = (resolveValue, routeLocation, contentModules, locale, status, defaults) => withLocale(locale, () => {
+  const head = createDocumentHead(defaults);
+  let eTag;
+  let cacheKey;
+  const fns = [];
+  for (let i = 0; i < contentModules.length; i++) {
+    const contentModule = contentModules[i];
+    if (!contentModule) {
+      continue;
+    }
+    const isLast = i === contentModules.length - 1;
+    let config;
+    if (contentModule.routeConfig) {
+      config = contentModule.routeConfig;
+    } else if (contentModule.head) {
+      const synthetic = {
+        head: void 0
+      };
+      const headExport = contentModule.head;
+      if (typeof headExport === "function") {
+        const mod = contentModule;
+        config = (props) => ({
+          head: headExport(props),
+          eTag: mod.eTag,
+          cacheKey: mod.cacheKey
+        });
+      } else {
+        synthetic.head = headExport;
+        const mod = contentModule;
+        if (mod.eTag !== void 0) {
+          synthetic.eTag = mod.eTag;
+        }
+        if (mod.cacheKey !== void 0) {
+          synthetic.cacheKey = mod.cacheKey;
+        }
+        config = synthetic;
+      }
+    } else {
+      const mod = contentModule;
+      if (mod.eTag !== void 0 || mod.cacheKey !== void 0) {
+        config = {
+          eTag: mod.eTag,
+          cacheKey: mod.cacheKey
+        };
+      }
+    }
+    if (!config) {
+      continue;
+    }
+    if (typeof config === "function") {
+      fns.unshift({
+        fn: config,
+        isLast
+      });
+    } else {
+      if (config.head) {
+        resolveDocumentHead(head, config.head);
+      }
+      if (config.eTag !== void 0) {
+        eTag = config.eTag;
+      }
+      if (config.cacheKey !== void 0) {
+        cacheKey = config.cacheKey;
+      }
+    }
+  }
+  if (fns.length) {
+    const headProps = {
+      head,
+      status,
+      withLocale: (fn) => fn(),
+      resolveValue,
+      ...routeLocation
+    };
+    for (const { fn } of fns) {
+      const result = fn(headProps);
+      if (result.head) {
+        resolveDocumentHead(head, result.head);
+      }
+      if (result.eTag !== void 0) {
+        eTag = result.eTag;
+      }
+      if (result.cacheKey !== void 0) {
+        cacheKey = result.cacheKey;
+      }
+    }
+  }
+  return {
+    head,
+    eTag,
+    cacheKey
+  };
+});
+
+const MODULE_CACHE = /* @__PURE__ */ new WeakMap();
+const httpErrorLoader = () => import('./http-error.qwik.mjs');
+function walkTrieKeys(root, keys) {
+  let node = root;
+  const layouts = [];
+  if (node._L) {
+    layouts.push(node._L);
+  }
+  for (const key of keys) {
+    let next = node[key];
+    if (!next && node._M) {
+      for (const group of node._M) {
+        next = group[key];
+        if (next) {
+          if (group._L) {
+            layouts.push(group._L);
+          }
+          break;
+        }
+      }
+    }
+    if (!next) {
+      return void 0;
+    }
+    node = next;
+    if (node._L) {
+      layouts.push(node._L);
+    }
+  }
+  return {
+    node,
+    layouts
+  };
+}
+function collectNodeMeta(node, groups, layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef) {
+  for (const g of groups) {
+    if (g._L) {
+      layouts.push(g._L);
+    }
+    if (g._E) {
+      errorLoaderRef.v = g._E;
+    }
+    if (g._4) {
+      notFoundLoaderRef.v = g._4;
+    }
+    if (g._N) {
+      menuLoaderRef.v = g._N;
+    }
+  }
+  if (node._L) {
+    layouts.push(node._L);
+  }
+  if (node._E) {
+    errorLoaderRef.v = node._E;
+  }
+  if (node._4) {
+    notFoundLoaderRef.v = node._4;
+  }
+  if (node._N) {
+    menuLoaderRef.v = node._N;
+  }
+}
+function tryWildcardMatch(node, part, partLower, parts, partIndex, params) {
+  let next = node._W;
+  if (next) {
+    const prefix = next._0;
+    const suffix = next._9;
+    if (prefix || suffix) {
+      const pre = prefix || "";
+      const suf = suffix || "";
+      if (partLower.length > pre.length + suf.length && (!pre || partLower.startsWith(pre.toLowerCase())) && (!suf || partLower.endsWith(suf.toLowerCase()))) {
+        const paramName = next._P;
+        const value = part.slice(pre.length, suf ? part.length - suf.length : void 0);
+        params[paramName] = value;
+        return {
+          next,
+          routePart: `${pre}[${paramName}]${suf}`,
+          done: false
+        };
+      }
+    } else {
+      const paramName = next._P;
+      params[paramName] = part;
+      return {
+        next,
+        routePart: `[${paramName}]`,
+        done: false
+      };
+    }
+  }
+  next = node._A;
+  if (next) {
+    const paramName = next._P;
+    const restValue = parts.slice(partIndex).join("/");
+    params[paramName] = restValue;
+    return {
+      next,
+      routePart: `[...${paramName}]`,
+      done: true
+    };
+  }
+  return void 0;
+}
+function findChild(node, part, partLower, parts, partIndex, params) {
+  const exact = node[partLower];
+  if (exact) {
+    return {
+      next: exact,
+      groups: [],
+      routePart: part,
+      done: false
+    };
+  }
+  if (node._M) {
+    for (const group of node._M) {
+      const groupResult = findChild(group, part, partLower, parts, partIndex, params);
+      if (groupResult) {
+        groupResult.groups.unshift(group);
+        return groupResult;
+      }
+    }
+  }
+  const wildcard = tryWildcardMatch(node, part, partLower, parts, partIndex, params);
+  if (wildcard) {
+    return {
+      ...wildcard,
+      groups: []
+    };
+  }
+  return void 0;
+}
+function findIndexNode(node) {
+  if (node._I || node._G) {
+    return {
+      target: node,
+      groups: []
+    };
+  }
+  if (node._M) {
+    for (const group of node._M) {
+      const result = findIndexNode(group);
+      if (result) {
+        if (result.target !== group) {
+          result.groups.unshift(group);
+        }
+        return result;
+      }
+    }
+  }
+  return void 0;
+}
+function resolveLoaders(root, node, gatheredLayouts) {
+  if (node._G) {
+    const keys = node._G.split("/").filter((p) => p.length > 0);
+    const target = walkTrieKeys(root, keys);
+    if (!target) {
+      return void 0;
+    }
+    let targetNode = target.node;
+    const targetLayouts = target.layouts;
+    if (!targetNode._I && !targetNode._G) {
+      const indexResult = findIndexNode(targetNode);
+      if (indexResult) {
+        for (const g of indexResult.groups) {
+          if (g._L) {
+            targetLayouts.push(g._L);
+          }
+        }
+        targetNode = indexResult.target;
+        if (targetNode._L) {
+          targetLayouts.push(targetNode._L);
+        }
+      }
+    }
+    return resolveLoaders(root, targetNode, targetLayouts);
+  }
+  const index = node._I;
+  if (!index) {
+    return void 0;
+  }
+  if (Array.isArray(index)) {
+    return index;
+  }
+  return [
+    ...gatheredLayouts,
+    index
+  ];
+}
+function findRestNode(node) {
+  if (node._A) {
+    return {
+      next: node._A,
+      groups: []
+    };
+  }
+  if (node._M) {
+    for (const group of node._M) {
+      const result = findRestNode(group);
+      if (result) {
+        result.groups.unshift(group);
+        return result;
+      }
+    }
+  }
+  return void 0;
+}
+function matchRouteTree(root = {}, pathname) {
+  let node = root;
+  const params = {};
+  const routeParts = [];
+  const layouts = [];
+  const errorLoaderRef = {
+    v: void 0
+  };
+  const notFoundLoaderRef = {
+    v: void 0
+  };
+  const menuLoaderRef = {
+    v: void 0
+  };
+  if (root._L) {
+    layouts.push(root._L);
+  }
+  if (root._E) {
+    errorLoaderRef.v = root._E;
+  }
+  if (root._4) {
+    notFoundLoaderRef.v = root._4;
+  }
+  if (root._N) {
+    menuLoaderRef.v = root._N;
+  }
+  let done = false;
+  let matched = true;
+  const parts = pathname.split("/").filter((p) => p.length > 0).map(decodeURIComponent);
+  let restFallback;
+  let i = 0;
+  const len = parts.length;
+  for (; !done && i < len; i++) {
+    const part = parts[i];
+    const partLower = part.toLowerCase();
+    const restInfo = findRestNode(node);
+    if (restInfo) {
+      restFallback = {
+        aNode: restInfo.next,
+        groups: restInfo.groups,
+        paramName: restInfo.next._P,
+        restValue: parts.slice(i).join("/"),
+        routeParts: [
+          ...routeParts
+        ],
+        params: {
+          ...params
+        },
+        layouts: [
+          ...layouts
+        ],
+        errorLoader: errorLoaderRef.v,
+        notFoundLoader: notFoundLoaderRef.v,
+        menuLoader: menuLoaderRef.v
+      };
+    }
+    const found = findChild(node, part, partLower, parts, i, params);
+    if (!found) {
+      matched = false;
+      break;
+    }
+    routeParts.push(found.routePart);
+    done = found.done;
+    node = found.next;
+    collectNodeMeta(node, found.groups, layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef);
+  }
+  if (matched && !done && i === len) {
+    if (!node._I && !node._G) {
+      const indexResult = findIndexNode(node);
+      if (indexResult) {
+        collectNodeMeta(indexResult.target, indexResult.groups, layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef);
+        node = indexResult.target;
+      }
+    }
+    if (!node._I && !node._G && node._A) {
+      const next = node._A;
+      const paramName = next._P;
+      params[paramName] = "";
+      routeParts.push(`[...${paramName}]`);
+      node = next;
+      if (node._L) {
+        layouts.push(node._L);
+      }
+      if (node._N) {
+        menuLoaderRef.v = node._N;
+      }
+    }
+    if (!node._I && !node._G) {
+      const restInfo = findRestNode(node);
+      if (restInfo) {
+        const next = restInfo.next;
+        const paramName = next._P;
+        params[paramName] = "";
+        routeParts.push(`[...${paramName}]`);
+        collectNodeMeta(next, restInfo.groups, layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef);
+        node = next;
+      }
+    }
+  }
+  const loaders = matched && (done || i >= len) ? resolveLoaders(root, node, layouts) : void 0;
+  if (!loaders && restFallback) {
+    const fb = restFallback;
+    const fbParams = {
+      ...fb.params,
+      [fb.paramName]: fb.restValue
+    };
+    const fbRouteParts = [
+      ...fb.routeParts,
+      `[...${fb.paramName}]`
+    ];
+    const fbLayouts = [
+      ...fb.layouts
+    ];
+    const fbErrorRef = {
+      v: fb.errorLoader
+    };
+    const fbNotFoundRef = {
+      v: fb.notFoundLoader
+    };
+    const fbMenuRef = {
+      v: fb.menuLoader
+    };
+    collectNodeMeta(fb.aNode, fb.groups, fbLayouts, fbErrorRef, fbNotFoundRef, fbMenuRef);
+    const fbLoaders = resolveLoaders(root, fb.aNode, fbLayouts);
+    if (fbLoaders) {
+      return {
+        loaders: fbLoaders,
+        params: fbParams,
+        routeParts: fbRouteParts,
+        notFound: false,
+        routeBundleNames: fb.aNode._B,
+        menuLoader: fbMenuRef.v,
+        errorLoader: fbErrorRef.v,
+        notFoundLoader: fbNotFoundRef.v
+      };
+    }
+    errorLoaderRef.v = fbErrorRef.v;
+    notFoundLoaderRef.v = fbNotFoundRef.v;
+    menuLoaderRef.v = fbMenuRef.v;
+  }
+  if (!loaders) {
+    const loader = notFoundLoaderRef.v || errorLoaderRef.v || httpErrorLoader;
+    return {
+      loaders: [
+        loader
+      ],
+      params,
+      routeParts,
+      notFound: true,
+      routeBundleNames: void 0,
+      menuLoader: menuLoaderRef.v,
+      errorLoader: errorLoaderRef.v,
+      notFoundLoader: notFoundLoaderRef.v
+    };
+  }
+  return {
+    loaders,
+    params,
+    routeParts,
+    notFound: false,
+    routeBundleNames: node._B,
+    menuLoader: menuLoaderRef.v,
+    errorLoader: errorLoaderRef.v,
+    notFoundLoader: notFoundLoaderRef.v
+  };
+}
+const loadModule = (moduleLoader, pendingLoads, moduleSetter, cacheModules) => {
+  if (typeof moduleLoader === "function") {
+    const loadedModule = MODULE_CACHE.get(moduleLoader);
+    if (loadedModule) {
+      moduleSetter(loadedModule);
+    } else {
+      const moduleOrPromise = moduleLoader();
+      if (typeof moduleOrPromise.then === "function") {
+        pendingLoads.push(moduleOrPromise.then((loadedModule2) => {
+          if (cacheModules !== false) {
+            MODULE_CACHE.set(moduleLoader, loadedModule2);
+          }
+          moduleSetter(loadedModule2);
+        }));
+      } else if (moduleOrPromise) {
+        moduleSetter(moduleOrPromise);
+      }
+    }
+  }
+};
+const loadRoute = async (routes, cacheModules, pathname, isInternal) => {
+  const result = matchRouteTree(routes, pathname);
+  const { loaders, params, routeParts, notFound, routeBundleNames, menuLoader, errorLoader, notFoundLoader } = result;
+  const routeName = "/" + routeParts.join("/");
+  const modules = new Array(loaders.length);
+  const pendingLoads = [];
+  loaders.forEach((moduleLoader, i) => {
+    loadModule(moduleLoader, pendingLoads, (routeModule) => modules[i] = routeModule, cacheModules);
+  });
+  let menu = void 0;
+  if (!isInternal) {
+    loadModule(menuLoader, pendingLoads, (menuModule) => menu = menuModule?.default, cacheModules);
+  }
+  if (notFound && notFoundLoader) {
+    let notFoundMod;
+    let errorMod;
+    loadModule(notFoundLoader, pendingLoads, (mod) => notFoundMod = mod, cacheModules);
+    loadModule(errorLoader || httpErrorLoader, pendingLoads, (mod) => errorMod = mod, cacheModules);
+    if (pendingLoads.length > 0) {
+      await Promise.all(pendingLoads);
+    }
+    const { createNotFoundWrapper } = await import('./not-found-wrapper.qwik.mjs');
+    const wrapperModule = createNotFoundWrapper(notFoundMod, errorMod);
+    return {
+      $routeName$: routeName,
+      $params$: params,
+      $mods$: [
+        wrapperModule
+      ],
+      $menu$: deepFreeze(menu),
+      $routeBundleNames$: routeBundleNames,
+      $notFound$: notFound,
+      $errorLoader$: errorLoader
+    };
+  }
+  if (pendingLoads.length > 0) {
+    await Promise.all(pendingLoads);
+  }
+  return {
+    $routeName$: routeName,
+    $params$: params,
+    $mods$: modules,
+    $menu$: deepFreeze(menu),
+    $routeBundleNames$: routeBundleNames,
+    $notFound$: notFound,
+    $errorLoader$: errorLoader
+  };
+};
+
+const isPromise = (value) => {
+  return value && typeof value.then === "function";
+};
+
+const MAX_CACHE_SIZE = typeof globalThis.__SSR_CACHE_SIZE__ === "number" ? globalThis.__SSR_CACHE_SIZE__ : 50;
+const ssrCache = /* @__PURE__ */ new Map();
+function resolveETag(eTagExport, headProps) {
+  if (eTagExport === void 0) {
+    return null;
+  }
+  if (typeof eTagExport === "function") {
+    return eTagExport(headProps);
+  }
+  return eTagExport;
+}
+function resolveCacheKey(cacheKeyExport, status, eTag, pathname) {
+  if (cacheKeyExport === true) {
+    return `${status}|${eTag}|${pathname}`;
+  }
+  if (typeof cacheKeyExport !== "function") {
+    return null;
+  }
+  return cacheKeyExport(status, eTag, pathname);
+}
+function getCachedHtml(key) {
+  const html = ssrCache.get(key);
+  if (html !== void 0) {
+    ssrCache.delete(key);
+    ssrCache.set(key, html);
+  }
+  return html;
+}
+function setCachedHtml(key, html) {
+  if (MAX_CACHE_SIZE <= 0) {
+    return;
+  }
+  if (ssrCache.size >= MAX_CACHE_SIZE) {
+    const firstKey = ssrCache.keys().next().value;
+    ssrCache.delete(firstKey);
+  }
+  ssrCache.set(key, html);
+}
+
+var HttpStatus = /* @__PURE__ */ (function(HttpStatus2) {
+  HttpStatus2[HttpStatus2["Continue"] = 100] = "Continue";
+  HttpStatus2[HttpStatus2["SwitchingProtocols"] = 101] = "SwitchingProtocols";
+  HttpStatus2[HttpStatus2["Processing"] = 102] = "Processing";
+  HttpStatus2[HttpStatus2["Ok"] = 200] = "Ok";
+  HttpStatus2[HttpStatus2["Created"] = 201] = "Created";
+  HttpStatus2[HttpStatus2["Accepted"] = 202] = "Accepted";
+  HttpStatus2[HttpStatus2["NonAuthoritativeInformation"] = 203] = "NonAuthoritativeInformation";
+  HttpStatus2[HttpStatus2["NoContent"] = 204] = "NoContent";
+  HttpStatus2[HttpStatus2["ResetContent"] = 205] = "ResetContent";
+  HttpStatus2[HttpStatus2["PartialContent"] = 206] = "PartialContent";
+  HttpStatus2[HttpStatus2["MultiStatus"] = 207] = "MultiStatus";
+  HttpStatus2[HttpStatus2["AlreadyReported"] = 208] = "AlreadyReported";
+  HttpStatus2[HttpStatus2["ImUsed"] = 226] = "ImUsed";
+  HttpStatus2[HttpStatus2["MultipleChoices"] = 300] = "MultipleChoices";
+  HttpStatus2[HttpStatus2["MovedPermanently"] = 301] = "MovedPermanently";
+  HttpStatus2[HttpStatus2["Found"] = 302] = "Found";
+  HttpStatus2[HttpStatus2["SeeOther"] = 303] = "SeeOther";
+  HttpStatus2[HttpStatus2["NotModified"] = 304] = "NotModified";
+  HttpStatus2[HttpStatus2["UseProxy"] = 305] = "UseProxy";
+  HttpStatus2[HttpStatus2["SwitchProxy"] = 306] = "SwitchProxy";
+  HttpStatus2[HttpStatus2["TemporaryRedirect"] = 307] = "TemporaryRedirect";
+  HttpStatus2[HttpStatus2["PermanentRedirect"] = 308] = "PermanentRedirect";
+  HttpStatus2[HttpStatus2["BadRequest"] = 400] = "BadRequest";
+  HttpStatus2[HttpStatus2["Unauthorized"] = 401] = "Unauthorized";
+  HttpStatus2[HttpStatus2["PaymentRequired"] = 402] = "PaymentRequired";
+  HttpStatus2[HttpStatus2["Forbidden"] = 403] = "Forbidden";
+  HttpStatus2[HttpStatus2["NotFound"] = 404] = "NotFound";
+  HttpStatus2[HttpStatus2["MethodNotAllowed"] = 405] = "MethodNotAllowed";
+  HttpStatus2[HttpStatus2["NotAcceptable"] = 406] = "NotAcceptable";
+  HttpStatus2[HttpStatus2["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired";
+  HttpStatus2[HttpStatus2["RequestTimeout"] = 408] = "RequestTimeout";
+  HttpStatus2[HttpStatus2["Conflict"] = 409] = "Conflict";
+  HttpStatus2[HttpStatus2["Gone"] = 410] = "Gone";
+  HttpStatus2[HttpStatus2["LengthRequired"] = 411] = "LengthRequired";
+  HttpStatus2[HttpStatus2["PreconditionFailed"] = 412] = "PreconditionFailed";
+  HttpStatus2[HttpStatus2["PayloadTooLarge"] = 413] = "PayloadTooLarge";
+  HttpStatus2[HttpStatus2["UriTooLong"] = 414] = "UriTooLong";
+  HttpStatus2[HttpStatus2["UnsupportedMediaType"] = 415] = "UnsupportedMediaType";
+  HttpStatus2[HttpStatus2["RangeNotSatisfiable"] = 416] = "RangeNotSatisfiable";
+  HttpStatus2[HttpStatus2["ExpectationFailed"] = 417] = "ExpectationFailed";
+  HttpStatus2[HttpStatus2["IAmATeapot"] = 418] = "IAmATeapot";
+  HttpStatus2[HttpStatus2["MisdirectedRequest"] = 421] = "MisdirectedRequest";
+  HttpStatus2[HttpStatus2["UnprocessableEntity"] = 422] = "UnprocessableEntity";
+  HttpStatus2[HttpStatus2["Locked"] = 423] = "Locked";
+  HttpStatus2[HttpStatus2["FailedDependency"] = 424] = "FailedDependency";
+  HttpStatus2[HttpStatus2["UpgradeRequired"] = 426] = "UpgradeRequired";
+  HttpStatus2[HttpStatus2["PreconditionRequired"] = 428] = "PreconditionRequired";
+  HttpStatus2[HttpStatus2["TooManyRequests"] = 429] = "TooManyRequests";
+  HttpStatus2[HttpStatus2["RequestHeaderFieldsTooLarge"] = 431] = "RequestHeaderFieldsTooLarge";
+  HttpStatus2[HttpStatus2["UnavailableForLegalReasons"] = 451] = "UnavailableForLegalReasons";
+  HttpStatus2[HttpStatus2["InternalServerError"] = 500] = "InternalServerError";
+  HttpStatus2[HttpStatus2["NotImplemented"] = 501] = "NotImplemented";
+  HttpStatus2[HttpStatus2["BadGateway"] = 502] = "BadGateway";
+  HttpStatus2[HttpStatus2["ServiceUnavailable"] = 503] = "ServiceUnavailable";
+  HttpStatus2[HttpStatus2["GatewayTimeout"] = 504] = "GatewayTimeout";
+  HttpStatus2[HttpStatus2["HttpVersionNotSupported"] = 505] = "HttpVersionNotSupported";
+  HttpStatus2[HttpStatus2["VariantAlsoNegotiates"] = 506] = "VariantAlsoNegotiates";
+  HttpStatus2[HttpStatus2["InsufficientStorage"] = 507] = "InsufficientStorage";
+  HttpStatus2[HttpStatus2["LoopDetected"] = 508] = "LoopDetected";
+  HttpStatus2[HttpStatus2["NotExtended"] = 510] = "NotExtended";
+  HttpStatus2[HttpStatus2["NetworkAuthenticationRequired"] = 511] = "NetworkAuthenticationRequired";
+  return HttpStatus2;
+})({});
+
+const RequestEvLoaders = /* @__PURE__ */ Symbol("RequestEvLoaders");
+const RequestEvMode = /* @__PURE__ */ Symbol("RequestEvMode");
+const RequestEvRoute = /* @__PURE__ */ Symbol("RequestEvRoute");
+const RequestEvLoaderSerializationStrategyMap = /* @__PURE__ */ Symbol("RequestEvLoaderSerializationStrategyMap");
+const RequestRouteName = "@routeName";
+const RequestEvSharedActionId = "@actionId";
+const RequestEvSharedActionFormData = "@actionFormData";
+const RequestEvSharedNonce = "@nonce";
+const RequestEvIsRewrite = "@rewrite";
+const RequestEvShareServerTiming = "@serverTiming";
+const RequestEvETagCacheKey = "@eTagCacheKey";
+const RequestEvHttpStatusMessage = "@httpStatusMessage";
+const RequestEvShareQData = "qData";
+function getRequestLoaders(requestEv) {
+  return requestEv[RequestEvLoaders];
+}
+function getRequestLoaderSerializationStrategyMap(requestEv) {
+  return requestEv[RequestEvLoaderSerializationStrategyMap];
+}
+function getRequestRoute(requestEv) {
+  return requestEv[RequestEvRoute];
+}
+function getRequestMode(requestEv) {
+  return requestEv[RequestEvMode];
+}
+const ABORT_INDEX = Number.MAX_SAFE_INTEGER;
+const isDangerousKey = (k) => k === "__proto__" || k === "constructor" || k === "prototype";
+const isArrayIndexKey = (k) => /^(0|[1-9]\d*)$/.test(k);
+const getArrayPaths = (formData) => {
+  const arrayCandidates = /* @__PURE__ */ new Map();
+  for (const [name] of formData) {
+    const keys = name.split(".");
+    let hasDangerousKey = false;
+    for (const key of keys) {
+      if (isDangerousKey(key)) {
+        hasDangerousKey = true;
+        break;
+      }
+    }
+    if (hasDangerousKey) {
+      continue;
+    }
+    let path = "";
+    for (let i = 0; i < keys.length - 1; i++) {
+      const key = keys[i];
+      if (key.endsWith("[]")) {
+        break;
+      }
+      path = path ? `${path}.${key}` : key;
+      if (!arrayCandidates.has(path)) {
+        arrayCandidates.set(path, true);
+      }
+      if (!isArrayIndexKey(keys[i + 1])) {
+        arrayCandidates.set(path, false);
+      }
+    }
+  }
+  return new Set(Array.from(arrayCandidates.entries()).filter(([, isArrayPath]) => isArrayPath).map(([path]) => path));
+};
+const formToObj = (formData) => {
+  const values = /* @__PURE__ */ Object.create(null);
+  const arrayPaths = getArrayPaths(formData);
+  for (const [name, value] of formData) {
+    const keys = name.split(".");
+    let hasDangerousKey = false;
+    for (let i = 0; i < keys.length; i++) {
+      if (isDangerousKey(keys[i])) {
+        hasDangerousKey = true;
+        break;
+      }
+    }
+    if (hasDangerousKey) {
+      continue;
+    }
+    let object = values;
+    let path = "";
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      if (key.endsWith("[]")) {
+        const arrayKey = key.slice(0, -2);
+        if (isDangerousKey(arrayKey)) {
+          break;
+        }
+        const existingValue = object[arrayKey];
+        if (existingValue !== void 0 && !Array.isArray(existingValue)) {
+          break;
+        }
+        object[arrayKey] = existingValue || [];
+        object[arrayKey].push(value);
+        break;
+      }
+      if (Array.isArray(object) && !isArrayIndexKey(key)) {
+        break;
+      }
+      if (i < keys.length - 1) {
+        path = path ? `${path}.${key}` : key;
+        const nextValue = object[key];
+        if (nextValue !== void 0) {
+          object = nextValue;
+          continue;
+        }
+        object = object[key] = arrayPaths.has(path) ? [] : /* @__PURE__ */ Object.create(null);
+      } else {
+        object[key] = value;
+      }
+    }
+  }
+  return values;
+};
+const parseRequest = async (deps, { request, method, query }, sharedMap) => {
+  const type = deps.getContentType(request.headers);
+  if (type === "application/x-www-form-urlencoded" || type === "multipart/form-data") {
+    const formData = await request.formData();
+    sharedMap.set(RequestEvSharedActionFormData, formData);
+    return formToObj(formData);
+  } else if (type === "application/json") {
+    const data = await request.json();
+    return data;
+  } else if (type === "application/qwik-json") {
+    if (method === "GET" && query.has(deps.QDATA_KEY)) {
+      const data = query.get(deps.QDATA_KEY);
+      if (data) {
+        try {
+          return _deserialize(decodeURIComponent(data));
+        } catch {
+        }
+      }
+    }
+    return _deserialize(await request.text());
+  }
+  return void 0;
+};
+function createRequestEventWithDeps(deps, serverRequestEv, loadedRoute, requestHandlers, basePathname, resolved) {
+  const { request, platform, env } = serverRequestEv;
+  const sharedMap = /* @__PURE__ */ new Map();
+  const cookie = new deps.Cookie(request.headers.get("cookie"));
+  const headers = new Headers();
+  const url = new URL(request.url);
+  const { pathname, isInternal } = deps.getRouteMatchPathname(url.pathname);
+  if (isInternal) {
+    url.pathname = pathname;
+    sharedMap.set(deps.IsQData, true);
+  }
+  let routeModuleIndex = -1;
+  let writableStream = null;
+  let requestData = void 0;
+  let locale = serverRequestEv.locale;
+  let status = loadedRoute?.$notFound$ ? 404 : 200;
+  const next = async () => {
+    routeModuleIndex++;
+    while (routeModuleIndex < requestHandlers.length) {
+      const moduleRequestHandler = requestHandlers[routeModuleIndex];
+      const result = moduleRequestHandler(requestEv);
+      if (deps.isPromise(result)) {
+        await result;
+      }
+      routeModuleIndex++;
+    }
+  };
+  const resetRoute = (_loadedRoute, _requestHandlers, _url = url) => {
+    loadedRoute = _loadedRoute;
+    status = loadedRoute?.$notFound$ ? 404 : 200;
+    requestHandlers = _requestHandlers;
+    url.pathname = _url.pathname;
+    url.search = _url.search;
+    routeModuleIndex = -1;
+  };
+  const check = () => {
+    if (writableStream !== null) {
+      throw new Error("Response already sent");
+    }
+  };
+  const send = (statusOrResponse, body) => {
+    check();
+    if (typeof statusOrResponse === "number") {
+      status = statusOrResponse;
+      const writableStream2 = requestEv.getWritableStream();
+      const writer = writableStream2.getWriter();
+      writer.write(typeof body === "string" ? deps.encoder.encode(body) : body);
+      writer.close();
+    } else {
+      status = statusOrResponse.status;
+      statusOrResponse.headers.forEach((value, key) => {
+        if (key.toLowerCase() === "set-cookie") {
+          return;
+        }
+        headers.append(key, value);
+      });
+      statusOrResponse.headers.getSetCookie().forEach((ck) => {
+        const index = ck.indexOf("=");
+        if (index === -1) {
+          return;
+        }
+        const key = ck.slice(0, index).trim();
+        const value = ck.slice(index + 1).trim();
+        cookie.set(key, value);
+      });
+      if (statusOrResponse.body) {
+        const writableStream2 = requestEv.getWritableStream();
+        statusOrResponse.body.pipeTo(writableStream2);
+      } else {
+        requestEv.getWritableStream().getWriter().close();
+      }
+    }
+    return exit();
+  };
+  const exit = (message = new deps.AbortMessage()) => {
+    routeModuleIndex = ABORT_INDEX;
+    return message;
+  };
+  const loaders = {};
+  const requestEv = {
+    [RequestEvLoaders]: loaders,
+    [RequestEvLoaderSerializationStrategyMap]: /* @__PURE__ */ new Map(),
+    [RequestEvMode]: serverRequestEv.mode,
+    get [RequestEvRoute]() {
+      return loadedRoute;
+    },
+    cookie,
+    headers,
+    env,
+    method: request.method,
+    signal: request.signal,
+    originalUrl: new URL(url),
+    get params() {
+      return loadedRoute?.$params$ ?? {};
+    },
+    get pathname() {
+      return url.pathname;
+    },
+    platform,
+    get query() {
+      return url.searchParams;
+    },
+    request,
+    url,
+    basePathname,
+    sharedMap,
+    get headersSent() {
+      return writableStream !== null;
+    },
+    get exited() {
+      return routeModuleIndex >= ABORT_INDEX;
+    },
+    get clientConn() {
+      return serverRequestEv.getClientConn();
+    },
+    next,
+    resetRoute,
+    exit,
+    cacheControl: (cacheControl, target = "Cache-Control") => {
+      check();
+      headers.set(target, deps.createCacheControl(cacheControl));
+    },
+    resolveValue: async (loaderOrAction) => {
+      const id = loaderOrAction.__id;
+      if (loaderOrAction.__brand === "server_loader") {
+        if (!(id in loaders)) {
+          throw new Error("You can not get the returned data of a loader that has not been executed for this request.");
+        }
+        if (loaders[id] === _UNINITIALIZED) {
+          await deps.getRouteLoaderPromise(loaderOrAction, loaders, requestEv[RequestEvLoaderSerializationStrategyMap], requestEv);
+        }
+      }
+      return loaders[id];
+    },
+    status: (statusCode) => {
+      if (typeof statusCode === "number") {
+        check();
+        status = statusCode;
+        return statusCode;
+      }
+      return status;
+    },
+    locale: (_locale) => {
+      if (typeof _locale === "string") {
+        locale = _locale;
+      }
+      return locale || "";
+    },
+    error: (statusCode, message) => {
+      status = statusCode;
+      headers.delete("Cache-Control");
+      return new deps.ServerError(statusCode, message);
+    },
+    redirect: (statusCode, url2) => {
+      check();
+      status = statusCode;
+      if (url2) {
+        if (
+          // //test.com
+          /^\/\//.test(url2) || // /test//path
+          /([^:])\/\/+/.test(url2)
+        ) {
+          const fixedURL = url2.replace(/^\/\/+/, "/").replace(/([^:])\/\/+/g, "$1/");
+          console.warn(`Redirect URL ${url2} is invalid, fixing to ${fixedURL}`);
+          url2 = fixedURL;
+        }
+        headers.set("Location", url2);
+      }
+      headers.delete("Cache-Control");
+      if (statusCode > 301) {
+        headers.set("Cache-Control", "no-store");
+      }
+      return exit(new deps.RedirectMessage());
+    },
+    rewrite: (pathname2) => {
+      check();
+      if (pathname2.startsWith("http")) {
+        throw new deps.ServerError(400, isDev ? "Rewrite does not support absolute urls" : "Bad Request");
+      }
+      sharedMap.set(RequestEvIsRewrite, true);
+      return exit(new deps.RewriteMessage(pathname2.replace(/\/+/g, "/")));
+    },
+    defer: (returnData) => {
+      return typeof returnData === "function" ? returnData : () => returnData;
+    },
+    fail: (statusCode, data) => {
+      check();
+      status = statusCode;
+      headers.delete("Cache-Control");
+      return {
+        failed: true,
+        ...data
+      };
+    },
+    text: (statusCode, text) => {
+      headers.set("Content-Type", "text/plain; charset=utf-8");
+      return send(statusCode, text);
+    },
+    html: (statusCode, html) => {
+      headers.set("Content-Type", "text/html; charset=utf-8");
+      return send(statusCode, html);
+    },
+    parseBody: async () => {
+      if (requestData !== void 0) {
+        return requestData;
+      }
+      return requestData = parseRequest(deps, requestEv, sharedMap);
+    },
+    json: (statusCode, data) => {
+      headers.set("Content-Type", "application/json; charset=utf-8");
+      return send(statusCode, JSON.stringify(data));
+    },
+    send,
+    isDirty: () => {
+      return writableStream !== null;
+    },
+    getWritableStream: () => {
+      if (writableStream === null) {
+        if (isDev) {
+          const serverTiming = sharedMap.get(RequestEvShareServerTiming);
+          if (serverTiming) {
+            headers.set("Server-Timing", serverTiming.map(([name, duration]) => `${name};dur=${duration}`).join(","));
+          }
+        }
+        writableStream = serverRequestEv.getWritableStream(status, headers, cookie, resolved, requestEv);
+      }
+      return writableStream;
+    }
+  };
+  return requestEv;
+}
+
+function verifySerializable(data, qrl) {
+  try {
+    _verifySerializable(data, void 0);
+  } catch (e) {
+    if (e instanceof Error && qrl.dev) {
+      e.loc = qrl.dev;
+    }
+    throw e;
+  }
+}
+function now() {
+  return typeof performance !== "undefined" ? performance.now() : 0;
+}
+async function measure(requestEv, name, fn) {
+  const start = now();
+  try {
+    return await fn();
+  } finally {
+    const duration = now() - start;
+    let measurements = requestEv.sharedMap.get("@serverTiming");
+    if (!measurements) {
+      requestEv.sharedMap.set("@serverTiming", measurements = []);
+    }
+    measurements.push([
+      name,
+      duration
+    ]);
+  }
+}
+async function runValidators(requestEv, validators, data) {
+  let lastResult = {
+    success: true,
+    data
+  };
+  if (validators) {
+    for (const validator of validators) {
+      if (isDev) {
+        lastResult = await measure(requestEv, `validator$`, () => validator.validate(requestEv, data));
+      } else {
+        lastResult = await validator.validate(requestEv, data);
+      }
+      if (!lastResult.success) {
+        return lastResult;
+      } else {
+        data = lastResult.data;
+      }
+    }
+  }
+  return lastResult;
+}
+async function getRouteLoaderPromise(loader, loaders, loadersSerializationStrategy, requestEv) {
+  const loaderId = loader.__id;
+  loaders[loaderId] = runValidators(
+    requestEv,
+    loader.__validators,
+    void 0
+    // data
+  ).then((res) => {
+    if (res.success) {
+      if (isDev) {
+        return measure(requestEv, loader.__qrl.getHash(), () => loader.__qrl.call(requestEv, requestEv));
+      } else {
+        return loader.__qrl.call(requestEv, requestEv);
+      }
+    } else {
+      return requestEv.fail(res.status ?? 500, res.error);
+    }
+  }).then((resolvedLoader) => {
+    if (typeof resolvedLoader === "function") {
+      loaders[loaderId] = resolvedLoader();
+    } else {
+      if (isDev) {
+        verifySerializable(resolvedLoader, loader.__qrl);
+      }
+      loaders[loaderId] = resolvedLoader;
+    }
+    return resolvedLoader;
+  });
+  loadersSerializationStrategy.set(loaderId, loader.__serializationStrategy);
+  return loaders[loaderId];
+}
+
+const IsQData = "@isQData";
+const QDATA_JSON = "/q-data.json";
+function getRouteMatchPathname(pathname) {
+  const isInternal = pathname.endsWith(QDATA_JSON);
+  if (isInternal) {
+    const trimEnd = pathname.length - QDATA_JSON.length + (globalThis.__NO_TRAILING_SLASH__ ? 0 : 1);
+    pathname = pathname.slice(0, trimEnd);
+    if (pathname === "") {
+      pathname = "/";
+    }
+  }
+  return {
+    pathname,
+    isInternal
+  };
+}
+
+const encoder = /* @__PURE__ */ new TextEncoder();
+function getContentType(headers) {
+  return (headers.get("content-type")?.split(/[;,]/, 1)[0].trim() ?? "").toLowerCase();
+}
+function isContentType(headers, ...types) {
+  const type = getContentType(headers);
+  for (let i = 0; i < types.length; i++) {
+    if (types[i].toLowerCase() === type) {
+      return true;
+    }
+  }
+  return false;
+}
+
+class AbortMessage {
+}
+class RedirectMessage extends AbortMessage {
+}
+
+function createResolveRequestHandlers(deps) {
+  const resolveRequestHandlers = (serverPlugins, route, method, checkOrigin, renderHandler, isInternal) => {
+    const routeLoaders = [];
+    const routeActions = [];
+    const requestHandlers = [];
+    const isPageRoute = !!(route && isLastModulePageRoute(route.$mods$));
+    if (isInternal) {
+      requestHandlers.push(handleQDataRedirect);
+    }
+    if (isPageRoute) {
+      requestHandlers.push(serverErrorMiddleware(route, renderHandler));
+    }
+    if (serverPlugins) {
+      _resolveRequestHandlers(routeLoaders, routeActions, requestHandlers, serverPlugins, isPageRoute, method);
+    }
+    if (route) {
+      const routeModules = route.$mods$;
+      _resolveRequestHandlers(routeLoaders, routeActions, requestHandlers, routeModules, isPageRoute, method);
+      const routeName = route.$routeName$;
+      if (checkOrigin && (method === "POST" || method === "PUT" || method === "PATCH" || method === "DELETE")) {
+        if (checkOrigin === "lax-proto") {
+          requestHandlers.unshift(csrfLaxProtoCheckMiddleware);
+        } else {
+          requestHandlers.unshift(csrfCheckMiddleware);
+        }
+      }
+      if (isPageRoute) {
+        if (method === "POST" || method === "GET") {
+          requestHandlers.push(runServerFunction);
+        }
+        requestHandlers.push(fixTrailingSlash);
+        if (isInternal) {
+          requestHandlers.push(renderQData);
+        }
+      }
+      if (isPageRoute) {
+        requestHandlers.push((ev) => {
+          ev.sharedMap.set(deps.RequestRouteName, routeName);
+        });
+        requestHandlers.push(actionsMiddleware(routeActions));
+        requestHandlers.push(loadersMiddleware(routeLoaders));
+        requestHandlers.push(eTagMiddleware(route));
+        requestHandlers.push(renderHandler);
+      }
+    }
+    return requestHandlers;
+  };
+  const _resolveRequestHandlers = (routeLoaders, routeActions, requestHandlers, routeModules, collectActions, method) => {
+    for (const routeModule of routeModules) {
+      if (typeof routeModule.onRequest === "function") {
+        requestHandlers.push(routeModule.onRequest);
+      } else if (Array.isArray(routeModule.onRequest)) {
+        requestHandlers.push(...routeModule.onRequest);
+      }
+      let methodReqHandler;
+      switch (method) {
+        case "GET": {
+          methodReqHandler = routeModule.onGet;
+          break;
+        }
+        case "POST": {
+          methodReqHandler = routeModule.onPost;
+          break;
+        }
+        case "PUT": {
+          methodReqHandler = routeModule.onPut;
+          break;
+        }
+        case "PATCH": {
+          methodReqHandler = routeModule.onPatch;
+          break;
+        }
+        case "DELETE": {
+          methodReqHandler = routeModule.onDelete;
+          break;
+        }
+        case "OPTIONS": {
+          methodReqHandler = routeModule.onOptions;
+          break;
+        }
+        case "HEAD": {
+          methodReqHandler = routeModule.onHead;
+          break;
+        }
+      }
+      if (typeof methodReqHandler === "function") {
+        requestHandlers.push(methodReqHandler);
+      } else if (Array.isArray(methodReqHandler)) {
+        requestHandlers.push(...methodReqHandler);
+      }
+      if (collectActions) {
+        for (const module of Object.values(routeModule)) {
+          if (typeof module === "function") {
+            if (module.__brand === "server_loader") {
+              routeLoaders.push(module);
+            } else if (module.__brand === "server_action") {
+              routeActions.push(module);
+            }
+          }
+        }
+      }
+    }
+  };
+  const checkBrand = (obj, brand) => {
+    return obj && typeof obj === "function" && obj.__brand === brand;
+  };
+  function actionsMiddleware(routeActions) {
+    return async (requestEvent) => {
+      const requestEv = requestEvent;
+      if (requestEv.headersSent) {
+        requestEv.exit();
+        return;
+      }
+      const { method } = requestEv;
+      const loaders = deps.getRequestLoaders(requestEv);
+      if (isDev && method === "GET") {
+        if (requestEv.query.has(deps.QACTION_KEY)) {
+          console.warn('Seems like you are submitting a Qwik Action via GET request. Qwik Actions should be submitted via POST request.\nMake sure your <form> has method="POST" attribute, like this: <form method="POST">');
+        }
+      }
+      if (method === "POST") {
+        const selectedActionId = requestEv.query.get(deps.QACTION_KEY);
+        if (selectedActionId) {
+          const serverActionsMap = globalThis._qwikActionsMap;
+          const action = routeActions.find((action2) => action2.__id === selectedActionId) ?? serverActionsMap?.get(selectedActionId);
+          if (action) {
+            requestEv.sharedMap.set(deps.RequestEvSharedActionId, selectedActionId);
+            const data = await requestEv.parseBody();
+            if (!data || typeof data !== "object") {
+              throw new Error(`Expected request data for the action id ${selectedActionId} to be an object`);
+            }
+            const result = await runValidators(requestEv, action.__validators, data);
+            if (!result.success) {
+              loaders[selectedActionId] = requestEv.fail(result.status ?? 500, result.error);
+            } else {
+              const actionResolved = isDev ? await measure(requestEv, action.__qrl.getHash(), () => action.__qrl.call(requestEv, result.data, requestEv)) : await action.__qrl.call(requestEv, result.data, requestEv);
+              if (isDev) {
+                verifySerializable(actionResolved, action.__qrl);
+              }
+              loaders[selectedActionId] = actionResolved;
+            }
+          }
+        }
+      }
+    };
+  }
+  function loadersMiddleware(routeLoaders) {
+    return async (requestEvent) => {
+      const requestEv = requestEvent;
+      if (requestEv.headersSent) {
+        requestEv.exit();
+        return;
+      }
+      const loaders = deps.getRequestLoaders(requestEv);
+      const loadersSerializationStrategy = deps.getRequestLoaderSerializationStrategyMap(requestEv);
+      if (routeLoaders.length > 0) {
+        const resolvedLoadersPromises = routeLoaders.map((loader) => deps.getRouteLoaderPromise(loader, loaders, loadersSerializationStrategy, requestEv));
+        await Promise.all(resolvedLoadersPromises);
+      }
+    };
+  }
+  function eTagMiddleware(route) {
+    return (requestEv) => {
+      if (requestEv.headersSent) {
+        return;
+      }
+      if (requestEv.method !== "GET" || requestEv.sharedMap.has(deps.IsQData)) {
+        return;
+      }
+      const mods = route.$mods$;
+      const hasETag = mods.some((m) => {
+        if (!m) {
+          return false;
+        }
+        if (m.routeConfig) {
+          return typeof m.routeConfig === "function" || m.routeConfig.eTag !== void 0;
+        }
+        return m.eTag !== void 0;
+      });
+      if (!hasETag) {
+        return;
+      }
+      const loaders = deps.getRequestLoaders(requestEv);
+      const getData = (loaderOrAction) => {
+        const id = loaderOrAction.__id;
+        if (loaderOrAction.__brand === "server_loader" && !(id in loaders)) {
+          throw new Error("Loader not executed for this request.");
+        }
+        if (loaders[id] instanceof Promise) {
+          throw new Error("Loaders returning a promise cannot be resolved for the eTag function.");
+        }
+        return loaders[id];
+      };
+      const routeLocation = {
+        params: requestEv.params,
+        url: requestEv.url,
+        isNavigating: false,
+        prevUrl: void 0
+      };
+      const status = requestEv.status();
+      const config = deps.resolveRouteConfig(getData, routeLocation, mods, "", status);
+      const headProps = {
+        head: config.head,
+        status,
+        withLocale: (fn) => fn(),
+        resolveValue: getData,
+        ...routeLocation
+      };
+      const eTag = deps.resolveETag(config.eTag, headProps);
+      if (!eTag) {
+        return;
+      }
+      requestEv.headers.set("ETag", eTag);
+      const ifNoneMatch = requestEv.request.headers.get("If-None-Match");
+      if (ifNoneMatch && (ifNoneMatch === eTag || ifNoneMatch === `W/${eTag}` || `W/${ifNoneMatch}` === eTag)) {
+        requestEv.status(304);
+        requestEv.send(304, "");
+        return;
+      }
+      if (deps.MAX_CACHE_SIZE <= 0) {
+        return;
+      }
+      const cacheKey = deps.resolveCacheKey(config.cacheKey, status, eTag, requestEv.url.pathname);
+      if (!cacheKey) {
+        return;
+      }
+      const cachedHtml = deps.getCachedHtml(cacheKey);
+      if (cachedHtml) {
+        requestEv.headers.set("Content-Type", "text/html; charset=utf-8");
+        requestEv.headers.set("X-SSR-Cache", "HIT");
+        requestEv.send(status, cachedHtml);
+        return;
+      }
+      requestEv.sharedMap.set(deps.RequestEvETagCacheKey, cacheKey);
+    };
+  }
+  function serverErrorMiddleware(route, renderHandler) {
+    return async (requestEv) => {
+      try {
+        await requestEv.next();
+      } catch (e) {
+        if (!(e instanceof deps.ServerError) || requestEv.headersSent) {
+          throw e;
+        }
+        if (requestEv.sharedMap.has(deps.IsQData)) {
+          throw e;
+        }
+        const accept = requestEv.request.headers.get("Accept");
+        if (accept && !accept.includes("text/html")) {
+          throw e;
+        }
+        const status = e.status;
+        requestEv.status(status);
+        const errorLoader = route.$errorLoader$;
+        const errorModule = errorLoader ? await errorLoader() : await deps.loadHttpError();
+        route.$mods$ = [
+          errorModule
+        ];
+        requestEv.sharedMap.set(deps.RequestEvHttpStatusMessage, typeof e.data === "string" ? e.data : "Server Error");
+        await renderHandler(requestEv);
+      }
+    };
+  }
+  async function runValidators(requestEv, validators, data) {
+    let lastResult = {
+      success: true,
+      data
+    };
+    if (validators) {
+      for (const validator of validators) {
+        if (isDev) {
+          lastResult = await measure(requestEv, `validator$`, () => validator.validate(requestEv, data));
+        } else {
+          lastResult = await validator.validate(requestEv, data);
+        }
+        if (!lastResult.success) {
+          return lastResult;
+        } else {
+          data = lastResult.data;
+        }
+      }
+    }
+    return lastResult;
+  }
+  function isAsyncIterator(obj) {
+    return obj ? typeof obj === "object" && Symbol.asyncIterator in obj : false;
+  }
+  async function runServerFunction(ev) {
+    const serverFnHash = ev.query.get(deps.QFN_KEY);
+    if (serverFnHash && ev.request.headers.get("X-QRL") === serverFnHash && ev.request.headers.get("Content-Type") === "application/qwik-json") {
+      ev.exit();
+      const data = await ev.parseBody();
+      if (!Array.isArray(data) || !(Array.isArray(data[0]) || data[0] === void 0)) {
+        throw ev.error(500, "Invalid request");
+      }
+      const qrl = inlinedQrl(null, serverFnHash, data.slice(1));
+      let result;
+      try {
+        if (isDev) {
+          result = await measure(ev, `server_${serverFnHash}`, () => qrl.apply(ev, data[0]));
+        } else {
+          result = await qrl.apply(ev, data[0]);
+        }
+      } catch (err) {
+        if (err instanceof deps.ServerError) {
+          throw ev.error(err.status, err.data);
+        }
+        console.error(`Server function ${serverFnHash} failed:`, err);
+        throw ev.error(500, "Invalid request");
+      }
+      if (isAsyncIterator(result)) {
+        ev.headers.set("Content-Type", "text/qwik-json-stream");
+        const writable = ev.getWritableStream();
+        const stream = writable.getWriter();
+        for await (const item of result) {
+          if (isDev) {
+            verifySerializable(item, qrl);
+          }
+          const message = await _serialize(item);
+          if (ev.signal.aborted) {
+            break;
+          }
+          await stream.write(deps.encoder.encode(`${message}
+`));
+        }
+        stream.close();
+      } else {
+        verifySerializable(result, qrl);
+        ev.headers.set("Content-Type", "application/qwik-json");
+        const message = await _serialize(result);
+        ev.send(200, message);
+      }
+      return;
+    }
+  }
+  function fixTrailingSlash(ev) {
+    const { basePathname, originalUrl, sharedMap } = ev;
+    const { pathname, search } = originalUrl;
+    const isQData = sharedMap.has(deps.IsQData);
+    if (!pathname.startsWith("/") || pathname.startsWith("//")) {
+      return;
+    }
+    if (!isQData && pathname !== basePathname && !pathname.endsWith(".html")) {
+      if (!globalThis.__NO_TRAILING_SLASH__) {
+        if (!pathname.endsWith("/")) {
+          throw ev.redirect(deps.HttpStatus.MovedPermanently, pathname + "/" + search);
+        }
+      } else {
+        if (pathname.endsWith("/")) {
+          throw ev.redirect(deps.HttpStatus.MovedPermanently, pathname.slice(0, pathname.length - 1) + search);
+        }
+      }
+    }
+  }
+  function verifySerializable(data, qrl) {
+    try {
+      _verifySerializable(data, void 0);
+    } catch (e) {
+      if (e instanceof Error && qrl.dev) {
+        e.loc = qrl.dev;
+      }
+      throw e;
+    }
+  }
+  const isQrl = (value) => {
+    return typeof value === "function" && typeof value.getSymbol === "function";
+  };
+  function isLastModulePageRoute(routeModules) {
+    const lastRouteModule = routeModules[routeModules.length - 1];
+    return lastRouteModule && typeof lastRouteModule.default === "function";
+  }
+  function getPathname(url) {
+    url = new URL(url);
+    if (url.pathname.endsWith(deps.QDATA_JSON)) {
+      url.pathname = url.pathname.slice(0, -deps.QDATA_JSON.length);
+    }
+    if (!globalThis.__NO_TRAILING_SLASH__) {
+      if (!url.pathname.endsWith("/")) {
+        url.pathname += "/";
+      }
+    } else {
+      if (url.pathname.endsWith("/")) {
+        url.pathname = url.pathname.slice(0, -1);
+      }
+    }
+    const search = url.search.slice(1).replaceAll(/&?q(action|data|func|loaders)=[^&]+/g, "");
+    return `${url.pathname}${search ? `?${search}` : ""}${url.hash}`;
+  }
+  function csrfLaxProtoCheckMiddleware(requestEv) {
+    checkCSRF(requestEv, "lax-proto");
+  }
+  function csrfCheckMiddleware(requestEv) {
+    checkCSRF(requestEv);
+  }
+  function checkCSRF(requestEv, laxProto) {
+    const contentType = requestEv.request.headers.get("content-type");
+    const isSimpleRequest = !contentType || deps.isContentType(requestEv.request.headers, "application/x-www-form-urlencoded", "multipart/form-data", "text/plain");
+    if (isSimpleRequest) {
+      const inputOrigin = requestEv.request.headers.get("origin");
+      const origin = requestEv.url.origin;
+      let forbidden = inputOrigin !== origin;
+      if (forbidden && laxProto && inputOrigin?.replace(/^http(s)?/g, "") === origin.replace(/^http(s)?/g, "")) {
+        forbidden = false;
+      }
+      if (forbidden) {
+        throw requestEv.error(403, `CSRF check failed. Cross-site ${requestEv.method} form submissions are forbidden.
+The request origin "${inputOrigin}" does not match the server origin "${origin}".`);
+      }
+    }
+  }
+  function renderQwikMiddleware(render) {
+    return async (requestEv) => {
+      if (requestEv.headersSent) {
+        return;
+      }
+      if (requestEv.sharedMap.has(deps.IsQData)) {
+        return;
+      }
+      const responseHeaders = requestEv.headers;
+      if (!responseHeaders.has("Content-Type")) {
+        responseHeaders.set("Content-Type", "text/html; charset=utf-8");
+      }
+      const eTagCacheKey = requestEv.sharedMap.get(deps.RequestEvETagCacheKey);
+      const { readable, writable } = new TextEncoderStream();
+      const writableStream = requestEv.getWritableStream();
+      let cacheChunks;
+      let pipeSource = readable;
+      if (eTagCacheKey) {
+        cacheChunks = [];
+        const capture = new TransformStream({
+          transform(chunk, controller) {
+            cacheChunks.push(chunk);
+            controller.enqueue(chunk);
+          }
+        });
+        pipeSource = readable.pipeThrough(capture);
+      }
+      const pipe = pipeSource.pipeTo(writableStream, {
+        preventClose: true
+      });
+      const stream = writable.getWriter();
+      const status = requestEv.status();
+      try {
+        const isStatic = deps.getRequestMode(requestEv) === "static";
+        const serverData = deps.getQwikRouterServerData(requestEv);
+        const result = await render({
+          base: requestEv.basePathname + "build/",
+          stream,
+          serverData,
+          containerAttributes: {
+            ["q:render"]: isStatic ? "static" : "",
+            ...serverData.containerAttributes
+          }
+        });
+        const qData = {
+          loaders: deps.getRequestLoaders(requestEv),
+          action: requestEv.sharedMap.get(deps.RequestEvSharedActionId),
+          status: status !== 200 ? status : 200,
+          href: getPathname(requestEv.url)
+        };
+        if (typeof result.html === "string") {
+          await stream.write(result.html);
+        }
+        requestEv.sharedMap.set(deps.RequestEvShareQData, qData);
+      } finally {
+        await stream.ready;
+        await stream.close();
+        await pipe;
+      }
+      if (eTagCacheKey && cacheChunks && cacheChunks.length > 0) {
+        const totalLength = cacheChunks.reduce((sum, chunk) => sum + chunk.length, 0);
+        const combined = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of cacheChunks) {
+          combined.set(chunk, offset);
+          offset += chunk.length;
+        }
+        deps.setCachedHtml(eTagCacheKey, new TextDecoder().decode(combined));
+      }
+      await writableStream.close();
+    };
+  }
+  async function handleQDataRedirect(requestEv) {
+    try {
+      await requestEv.next();
+    } catch (err) {
+      if (!(err instanceof deps.RedirectMessage)) {
+        throw err;
+      }
+    }
+    if (requestEv.headersSent) {
+      return;
+    }
+    const status = requestEv.status();
+    const location = requestEv.headers.get("Location");
+    const isRedirect = status >= 301 && status <= 308 && location;
+    if (isRedirect) {
+      const adaptedLocation = makeQDataPath(location);
+      if (adaptedLocation) {
+        requestEv.headers.set("Location", adaptedLocation);
+        requestEv.getWritableStream().close();
+        return;
+      } else {
+        requestEv.status(200);
+        requestEv.headers.delete("Location");
+      }
+    }
+  }
+  async function renderQData(requestEv) {
+    await requestEv.next();
+    if (requestEv.headersSent || requestEv.exited) {
+      return;
+    }
+    const status = requestEv.status();
+    const redirectLocation = requestEv.headers.get("Location");
+    requestEv.headers.set("Content-Type", "application/json; charset=utf-8");
+    let loaders = deps.getRequestLoaders(requestEv);
+    const selectedLoaderIds = requestEv.query.getAll(deps.QLOADER_KEY);
+    const hasCustomLoaders = selectedLoaderIds.length > 0;
+    if (hasCustomLoaders) {
+      const selectedLoaders = {};
+      for (const loaderId of selectedLoaderIds) {
+        const loader = loaders[loaderId];
+        selectedLoaders[loaderId] = loader;
+      }
+      loaders = selectedLoaders;
+    }
+    const qData = hasCustomLoaders ? {
+      loaders,
+      status: status !== 200 ? status : 200,
+      href: getPathname(requestEv.url)
+    } : {
+      loaders,
+      action: requestEv.sharedMap.get(deps.RequestEvSharedActionId),
+      status: status !== 200 ? status : 200,
+      href: getPathname(requestEv.url),
+      redirect: redirectLocation ?? void 0,
+      isRewrite: requestEv.sharedMap.get(deps.RequestEvIsRewrite)
+    };
+    const writer = requestEv.getWritableStream().getWriter();
+    const data = await _serialize(qData);
+    writer.write(deps.encoder.encode(data));
+    requestEv.sharedMap.set(deps.RequestEvShareQData, qData);
+    writer.close();
+  }
+  function makeQDataPath(href) {
+    if (href.startsWith("/")) {
+      if (!href.includes(deps.QDATA_JSON)) {
+        const url = new URL(href, "http://localhost");
+        const pathname = url.pathname.endsWith("/") ? url.pathname.slice(0, -1) : url.pathname;
+        return pathname + deps.QDATA_JSON + url.search;
+      }
+      return href;
+    } else {
+      return void 0;
+    }
+  }
+  function now() {
+    return typeof performance !== "undefined" ? performance.now() : 0;
+  }
+  async function measure(requestEv, name, fn) {
+    const start = now();
+    try {
+      return await fn();
+    } finally {
+      const duration = now() - start;
+      let measurements = requestEv.sharedMap.get(deps.RequestEvShareServerTiming);
+      if (!measurements) {
+        requestEv.sharedMap.set(deps.RequestEvShareServerTiming, measurements = []);
+      }
+      measurements.push([
+        name,
+        duration
+      ]);
+    }
+  }
+  return {
+    actionsMiddleware,
+    checkBrand,
+    checkCSRF,
+    fixTrailingSlash,
+    getPathname,
+    isLastModulePageRoute,
+    isQrl,
+    loadersMiddleware,
+    measure,
+    renderQwikMiddleware,
+    resolveRequestHandlers,
+    verifySerializable
+  };
+}
+
+class ServerError extends Error {
+  status;
+  data;
+  constructor(status, data) {
+    super(typeof data === "string" ? data : void 0), this.status = status, this.data = data;
+  }
+}
+
+function getQwikRouterServerDataWithDeps(deps, requestEv) {
+  const { params, request, status, locale, originalUrl } = requestEv;
+  const requestHeaders = {};
+  request.headers.forEach((value, key) => requestHeaders[key] = value);
+  const action = requestEv.sharedMap.get(deps.RequestEvSharedActionId);
+  const formData = requestEv.sharedMap.get(deps.RequestEvSharedActionFormData);
+  const routeName = requestEv.sharedMap.get(deps.RequestRouteName);
+  const nonce = requestEv.sharedMap.get(deps.RequestEvSharedNonce);
+  const headers = requestEv.request.headers;
+  const reconstructedUrl = new URL(originalUrl.pathname + originalUrl.search, originalUrl);
+  const host = headers.get("X-Forwarded-Host");
+  const protocol = headers.get("X-Forwarded-Proto");
+  if (host) {
+    reconstructedUrl.port = "";
+    reconstructedUrl.host = host;
+  }
+  if (protocol) {
+    reconstructedUrl.protocol = protocol;
+  }
+  const loaders = deps.getRequestLoaders(requestEv);
+  const loadersSerializationStrategy = deps.getRequestLoaderSerializationStrategyMap(requestEv);
+  return {
+    url: reconstructedUrl.href,
+    requestHeaders,
+    locale: locale(),
+    nonce,
+    containerAttributes: {
+      [deps.Q_ROUTE]: routeName
+    },
+    qwikrouter: {
+      routeName,
+      ev: requestEv,
+      params: {
+        ...params
+      },
+      loadedRoute: deps.getRequestRoute(requestEv),
+      response: {
+        status: status(),
+        statusMessage: requestEv.sharedMap.get(deps.RequestEvHttpStatusMessage),
+        loaders,
+        loadersSerializationStrategy,
+        action,
+        formData
+      }
+    }
+  };
+}
+
+const responsePageDeps = {
+  Q_ROUTE,
+  RequestEvHttpStatusMessage,
+  RequestEvSharedActionFormData,
+  RequestEvSharedActionId,
+  RequestEvSharedNonce,
+  RequestRouteName,
+  getRequestLoaders,
+  getRequestLoaderSerializationStrategyMap,
+  getRequestRoute
+};
+function getQwikRouterServerData(...args) {
+  return getQwikRouterServerDataWithDeps(responsePageDeps, ...args);
+}
+
+const requestHandlers = createResolveRequestHandlers({
+  QACTION_KEY,
+  QFN_KEY,
+  QLOADER_KEY,
+  QDATA_JSON,
+  IsQData,
+  RequestEvETagCacheKey,
+  RequestEvHttpStatusMessage,
+  RequestEvIsRewrite,
+  RequestEvShareQData,
+  RequestEvShareServerTiming,
+  RequestEvSharedActionId,
+  RequestRouteName,
+  RedirectMessage,
+  ServerError,
+  HttpStatus,
+  encoder,
+  isContentType,
+  getCachedHtml,
+  getQwikRouterServerData,
+  getRequestLoaderSerializationStrategyMap,
+  getRequestLoaders,
+  getRequestMode,
+  getRouteLoaderPromise,
+  loadHttpError: () => import('./http-error.qwik.mjs'),
+  MAX_CACHE_SIZE,
+  resolveCacheKey,
+  resolveETag,
+  resolveRouteConfig,
+  setCachedHtml
+});
+const { renderQwikMiddleware, resolveRequestHandlers} = requestHandlers;
+
+function createCacheControl(cacheControl) {
+  const controls = [];
+  if (cacheControl === "day") {
+    cacheControl = 60 * 60 * 24;
+  } else if (cacheControl === "week") {
+    cacheControl = 60 * 60 * 24 * 7;
+  } else if (cacheControl === "month") {
+    cacheControl = 60 * 60 * 24 * 30;
+  } else if (cacheControl === "year") {
+    cacheControl = 60 * 60 * 24 * 365;
+  } else if (cacheControl === "private") {
+    cacheControl = {
+      private: true,
+      noCache: true
+    };
+  } else if (cacheControl === "immutable") {
+    cacheControl = {
+      public: true,
+      immutable: true,
+      maxAge: 60 * 60 * 24 * 365
+    };
+  } else if (cacheControl === "no-cache") {
+    cacheControl = {
+      noCache: true
+    };
+  }
+  if (typeof cacheControl === "number") {
+    cacheControl = {
+      maxAge: cacheControl,
+      sMaxAge: cacheControl
+    };
+  }
+  if (cacheControl.immutable) {
+    controls.push("immutable");
+  }
+  if (cacheControl.maxAge) {
+    controls.push(`max-age=${cacheControl.maxAge}`);
+  }
+  if (cacheControl.sMaxAge) {
+    controls.push(`s-maxage=${cacheControl.sMaxAge}`);
+  }
+  if (cacheControl.noStore) {
+    controls.push("no-store");
+  }
+  if (cacheControl.noCache) {
+    controls.push("no-cache");
+  }
+  if (cacheControl.private) {
+    controls.push("private");
+  }
+  if (cacheControl.public) {
+    controls.push("public");
+  }
+  if (cacheControl.staleWhileRevalidate) {
+    controls.push(`stale-while-revalidate=${cacheControl.staleWhileRevalidate}`);
+  }
+  if (cacheControl.staleIfError) {
+    controls.push(`stale-if-error=${cacheControl.staleIfError}`);
+  }
+  return controls.join(", ");
+}
+
+const SAMESITE = {
+  lax: "Lax",
+  Lax: "Lax",
+  None: "None",
+  none: "None",
+  strict: "Strict",
+  Strict: "Strict"
+};
+const UNIT = {
+  seconds: 1,
+  minutes: 1 * 60,
+  hours: 1 * 60 * 60,
+  days: 1 * 60 * 60 * 24,
+  weeks: 1 * 60 * 60 * 24 * 7
+};
+function tryDecodeUriComponent(str) {
+  try {
+    return decodeURIComponent(str);
+  } catch {
+    return str;
+  }
+}
+const parseCookieString = (cookieString) => {
+  const cookie = {};
+  if (typeof cookieString === "string" && cookieString !== "") {
+    const cookieSegments = cookieString.split(";");
+    for (const cookieSegment of cookieSegments) {
+      const separatorIndex = cookieSegment.indexOf("=");
+      if (separatorIndex !== -1) {
+        cookie[tryDecodeUriComponent(cookieSegment.slice(0, separatorIndex).trim())] = tryDecodeUriComponent(cookieSegment.slice(separatorIndex + 1).trim());
+      }
+    }
+  }
+  return cookie;
+};
+function resolveSameSite(sameSite) {
+  if (sameSite === true) {
+    return "Strict";
+  }
+  if (sameSite === false) {
+    return "None";
+  }
+  if (sameSite) {
+    return SAMESITE[sameSite];
+  }
+  return void 0;
+}
+const createSetCookieValue = (cookieName, cookieValue, options) => {
+  const c = [
+    `${cookieName}=${cookieValue}`
+  ];
+  if (typeof options.domain === "string") {
+    c.push(`Domain=${options.domain}`);
+  }
+  if (typeof options.maxAge === "number") {
+    c.push(`Max-Age=${options.maxAge}`);
+  } else if (Array.isArray(options.maxAge)) {
+    c.push(`Max-Age=${options.maxAge[0] * UNIT[options.maxAge[1]]}`);
+  } else if (typeof options.expires === "number" || typeof options.expires == "string") {
+    c.push(`Expires=${options.expires}`);
+  } else if (options.expires instanceof Date) {
+    c.push(`Expires=${options.expires.toUTCString()}`);
+  }
+  if (options.httpOnly) {
+    c.push("HttpOnly");
+  }
+  if (typeof options.path === "string") {
+    c.push(`Path=${options.path}`);
+  }
+  const sameSite = resolveSameSite(options.sameSite);
+  if (sameSite) {
+    c.push(`SameSite=${sameSite}`);
+  }
+  if (options.secure) {
+    c.push("Secure");
+  }
+  return c.join("; ");
+};
+const REQ_COOKIE = /* @__PURE__ */ Symbol("request-cookies");
+const RES_COOKIE = /* @__PURE__ */ Symbol("response-cookies");
+const LIVE_COOKIE = /* @__PURE__ */ Symbol("live-cookies");
+class Cookie {
+  [REQ_COOKIE];
+  [RES_COOKIE] = {};
+  [LIVE_COOKIE] = {};
+  appendCounter = 0;
+  constructor(cookieString) {
+    this[REQ_COOKIE] = parseCookieString(cookieString);
+    this[LIVE_COOKIE] = {
+      ...this[REQ_COOKIE]
+    };
+  }
+  get(cookieName, live = true) {
+    const value = this[live ? LIVE_COOKIE : REQ_COOKIE][cookieName];
+    if (!value) {
+      return null;
+    }
+    return {
+      value,
+      json() {
+        return JSON.parse(value);
+      },
+      number() {
+        return Number(value);
+      }
+    };
+  }
+  getAll(live = true) {
+    return Object.keys(this[live ? LIVE_COOKIE : REQ_COOKIE]).reduce((cookies, cookieName) => {
+      cookies[cookieName] = this.get(cookieName);
+      return cookies;
+    }, {});
+  }
+  has(cookieName, live = true) {
+    return !!this[live ? LIVE_COOKIE : REQ_COOKIE][cookieName];
+  }
+  set(cookieName, cookieValue, options = {}) {
+    this[LIVE_COOKIE][cookieName] = typeof cookieValue === "string" ? cookieValue : JSON.stringify(cookieValue);
+    const resolvedValue = typeof cookieValue === "string" ? cookieValue : encodeURIComponent(JSON.stringify(cookieValue));
+    this[RES_COOKIE][cookieName] = createSetCookieValue(cookieName, resolvedValue, options);
+  }
+  append(cookieName, cookieValue, options = {}) {
+    this[LIVE_COOKIE][cookieName] = typeof cookieValue === "string" ? cookieValue : JSON.stringify(cookieValue);
+    const resolvedValue = typeof cookieValue === "string" ? cookieValue : encodeURIComponent(JSON.stringify(cookieValue));
+    this[RES_COOKIE][++this.appendCounter] = createSetCookieValue(cookieName, resolvedValue, options);
+  }
+  delete(name, options) {
+    this.set(name, "deleted", {
+      ...options,
+      maxAge: 0
+    });
+    this[LIVE_COOKIE][name] = null;
+  }
+  headers() {
+    return Object.values(this[RES_COOKIE]);
+  }
+}
+
+class RewriteMessage extends AbortMessage$1 {
+  pathname;
+  constructor(pathname) {
+    super(), this.pathname = pathname;
+  }
+}
+
+const requestEventDeps = {
+  QDATA_KEY,
+  isPromise,
+  createCacheControl,
+  Cookie,
+  AbortMessage,
+  RedirectMessage,
+  RewriteMessage,
+  ServerError,
+  getRouteLoaderPromise,
+  getRouteMatchPathname,
+  IsQData,
+  encoder,
+  getContentType
+};
+function createRequestEvent(...args) {
+  return createRequestEventWithDeps(requestEventDeps, ...args);
+}
+
+let _asyncRequestStore;
+if (isServer) {
+  import('node:async_hooks').then((module) => {
+    _asyncRequestStore = new module.AsyncLocalStorage();
+  }).catch((err) => {
+    console.warn("\n=====================\n  Qwik Router Warning:\n    AsyncLocalStorage is not available, continuing without it.\n    This impacts concurrent async server calls, where they lose access to the ServerRequestEv object.\n=====================\n\n", err);
+  });
+}
+
+const ESCAPE_HTML = /[&<>]/g;
+const escapeHtml = (s) => {
+  return s.replace(ESCAPE_HTML, (c) => {
+    switch (c) {
+      case "&":
+        return "&amp;";
+      case "<":
+        return "&lt;";
+      case ">":
+        return "&gt;";
+      default:
+        return "";
+    }
+  });
+};
+const COLOR_400 = "#006ce9";
+const COLOR_500 = "#713fc2";
+function minimalHtmlResponse(status, message) {
+  if (typeof status !== "number") {
+    status = 500;
+  }
+  if (typeof message === "string") {
+    message = escapeHtml(message);
+  } else {
+    message = "";
+  }
+  const width = typeof message === "string" ? "600px" : "300px";
+  const color = status >= 500 ? COLOR_500 : COLOR_400;
+  return `
+<head>
+  <meta charset="utf-8">
+  <meta http-equiv="Status" content="${status}">
+  <title>${status} ${message}</title>
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  <style>
+    body { color: ${color}; background-color: #fafafa; padding: 30px; font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, Roboto, sans-serif; }
+    p { max-width: ${width}; margin: 60px auto 30px auto; background: white; border-radius: 4px; box-shadow: 0px 0px 50px -20px ${color}; overflow: hidden; }
+    strong { display: inline-block; padding: 15px; background: ${color}; color: white; }
+    span { display: inline-block; padding: 15px; }
+  </style>
+</head>
+<body><p><strong>${status}</strong> <span>${message}</span></p></body>
+`;
+}
+function getErrorHtml(status, e) {
+  let message = "Server Error";
+  if (e != null) {
+    if (typeof e.message === "string") {
+      message = e.message;
+    } else {
+      message = String(e);
+    }
+  }
+  return `<html>` + minimalHtmlResponse(status, message) + `</html>`;
+}
+
+async function runNextWithDeps(requestEv, rebuildRouteInfo, resolve, deps) {
+  try {
+    const isValidURL = (url) => new URL(url.pathname + url.search, url);
+    isValidURL(requestEv.originalUrl);
+  } catch {
+    const status = 404;
+    const message = "Resource Not Found";
+    requestEv.status(status);
+    requestEv.html(status, deps.getErrorHtml(status, message));
+    return new deps.ServerError(status, message);
+  }
+  let rewriteAttempt = 1;
+  async function runOnce() {
+    try {
+      await requestEv.next();
+    } catch (e) {
+      if (e instanceof deps.RedirectMessage) {
+        const stream = requestEv.getWritableStream();
+        await stream.close();
+        return e;
+      } else if (e instanceof deps.RewriteMessage) {
+        if (rewriteAttempt > 50) {
+          return new Error(`Infinite rewrite loop`);
+        }
+        rewriteAttempt += 1;
+        const url = new URL(requestEv.url);
+        url.pathname = e.pathname;
+        const { loadedRoute, requestHandlers } = await rebuildRouteInfo(url);
+        requestEv.resetRoute(loadedRoute, requestHandlers, url);
+        return await runOnce();
+      } else if (e instanceof deps.AbortMessage) {
+        return;
+      } else if (e instanceof deps.ServerError && !requestEv.headersSent) {
+        const status = e.status;
+        const accept = requestEv.request.headers.get("Accept");
+        if (accept && !accept.includes("text/html")) {
+          requestEv.headers.set("Content-Type", "application/qwik-json");
+          requestEv.send(status, await _serialize(e.data));
+        } else {
+          requestEv.html(status, deps.getErrorHtml(status, e.data));
+        }
+        return e;
+      }
+      if (!isDev) {
+        try {
+          if (!requestEv.headersSent) {
+            requestEv.headers.set("content-type", "text/html; charset=utf-8");
+            requestEv.cacheControl({
+              noCache: true
+            });
+            requestEv.status(500);
+          }
+          const stream = requestEv.getWritableStream();
+          if (!stream.locked) {
+            const writer = stream.getWriter();
+            await writer.write(deps.encoder.encode(deps.getErrorHtml(500, "Internal Server Error")));
+            await writer.close();
+          }
+        } catch {
+          console.error("Unable to render error page");
+        }
+      }
+      return e instanceof Error || typeof e === "object" && e !== null ? e : new Error(String(e));
+    }
+  }
+  try {
+    return await runOnce();
+  } finally {
+    if (!requestEv.isDirty()) {
+      resolve(null);
+    }
+  }
+}
+function runQwikRouterWithDeps(serverRequestEv, loadedRoute, requestHandlers, rebuildRouteInfo, basePathname, deps) {
+  let resolve;
+  const responsePromise = new Promise((r) => resolve = r);
+  const requestEv = deps.createRequestEvent(serverRequestEv, loadedRoute, requestHandlers, basePathname, resolve);
+  return {
+    response: responsePromise,
+    requestEv,
+    completion: deps.asyncRequestStore ? deps.asyncRequestStore.run(requestEv, runNextWithDeps, requestEv, rebuildRouteInfo, resolve, deps) : runNextWithDeps(requestEv, rebuildRouteInfo, resolve, deps)
+  };
+}
+
+function runQwikRouter(serverRequestEv, loadedRoute, requestHandlers, rebuildRouteInfo, basePathname = "/") {
+  return runQwikRouterWithDeps(serverRequestEv, loadedRoute, requestHandlers, rebuildRouteInfo, basePathname, {
+    AbortMessage,
+    RedirectMessage,
+    RewriteMessage,
+    ServerError,
+    asyncRequestStore: _asyncRequestStore,
+    createRequestEvent,
+    encoder,
+    getErrorHtml
+  });
+}
+
+const staticWorkerThreadDeps = {
+  RequestEvShareQData,
+  loadRoute,
+  renderQwikMiddleware,
+  resolveRequestHandlers,
+  getRouteMatchPathname,
+  runQwikRouter
+};
+const createNoopWritableStream = () => new WritableStream();
+async function loadSerialize() {
+  const { _serialize: serialize } = await import('@qwik.dev/core/internal');
+  return serialize;
+}
+function isRedirectMessage(value) {
+  return typeof value === "object" && value !== null && value.constructor?.name === "RedirectMessage";
+}
+async function requestHandlerForSsg(serverRequestEv, opts, deps) {
+  const { render, checkOrigin, qwikRouterConfig } = opts;
+  if (!qwikRouterConfig) {
+    throw new Error("qwikRouterConfig is required.");
+  }
+  const { pathname, isInternal } = deps.getRouteMatchPathname(serverRequestEv.url.pathname);
+  if (pathname === "/.well-known" || pathname.startsWith("/.well-known/")) {
+    return null;
+  }
+  const { routes, serverPlugins, cacheModules } = qwikRouterConfig;
+  const loadedRoute = await deps.loadRoute(routes, cacheModules, pathname, isInternal);
+  const requestHandlers = deps.resolveRequestHandlers(serverPlugins, loadedRoute, serverRequestEv.request.method, checkOrigin ?? true, deps.renderQwikMiddleware(render), isInternal);
+  if (qwikRouterConfig.fallthrough && loadedRoute.$notFound$) {
+    return null;
+  }
+  const rebuildRouteInfo = async (url) => {
+    const { pathname: pathname2 } = deps.getRouteMatchPathname(url.pathname);
+    const loadedRoute2 = await deps.loadRoute(routes, cacheModules, pathname2, isInternal);
+    const requestHandlers2 = deps.resolveRequestHandlers(serverPlugins, loadedRoute2, serverRequestEv.request.method, checkOrigin ?? true, deps.renderQwikMiddleware(render), isInternal);
+    return {
+      loadedRoute: loadedRoute2,
+      requestHandlers: requestHandlers2
+    };
+  };
+  return deps.runQwikRouter(serverRequestEv, loadedRoute, requestHandlers, rebuildRouteInfo, qwikRouterConfig.basePathname);
+}
+async function workerRender(sys, opts, staticRoute, pendingPromises, callback, deps) {
+  const url = new URL(staticRoute.pathname, opts.origin);
+  const result = {
+    type: "render",
+    pathname: staticRoute.pathname,
+    url: url.href,
+    ok: false,
+    error: null,
+    filePath: null,
+    contentType: null,
+    resourceType: null
+  };
+  try {
+    let routeWriter = null;
+    let closeResolved;
+    const closePromise = new Promise((closePromiseResolve) => {
+      closeResolved = closePromiseResolve;
+    });
+    const request = new Request(url);
+    const requestCtx = {
+      mode: "static",
+      locale: void 0,
+      url,
+      request,
+      env: {
+        get(key) {
+          return sys.getEnv(key);
+        }
+      },
+      platform: sys.platform,
+      getClientConn: () => {
+        return {};
+      },
+      getWritableStream: (status, headers, _, _r, requestEv) => {
+        result.ok = status >= 200 && status < 300;
+        if (!result.ok) {
+          return createNoopWritableStream();
+        }
+        result.contentType = (headers.get("Content-Type") || "").toLowerCase();
+        const isHtml = result.contentType.includes("text/html");
+        const is404ErrorPage = url.pathname.endsWith("/404.html");
+        const routeFilePath = sys.getRouteFilePath(url.pathname, isHtml);
+        if (is404ErrorPage) {
+          result.resourceType = "404";
+        } else if (isHtml) {
+          result.resourceType = "page";
+        }
+        const hasRouteWriter = isHtml ? opts.emitHtml !== false : true;
+        const writeQDataEnabled = isHtml && opts.emitData !== false;
+        const stream = new WritableStream({
+          async start() {
+            try {
+              if (hasRouteWriter || writeQDataEnabled) {
+                await sys.ensureDir(routeFilePath);
+              }
+              if (hasRouteWriter) {
+                routeWriter = sys.createWriteStream(routeFilePath);
+                routeWriter.on("error", (e) => {
+                  console.error(e);
+                  routeWriter = null;
+                  result.error = {
+                    message: e.message,
+                    stack: e.stack
+                  };
+                });
+              }
+            } catch (e) {
+              console.error("Error during stream start", staticRoute.pathname, e);
+              routeWriter = null;
+              result.error = {
+                message: String(e),
+                stack: e.stack || ""
+              };
+            }
+          },
+          write(chunk) {
+            try {
+              if (routeWriter) {
+                routeWriter.write(Buffer.from(chunk.buffer));
+              }
+            } catch (e) {
+              console.error("Error during stream write", staticRoute.pathname, e);
+              routeWriter = null;
+              result.error = {
+                message: String(e),
+                stack: e.stack || ""
+              };
+            }
+          },
+          async close() {
+            const writePromises = [];
+            try {
+              if (writeQDataEnabled) {
+                const qData = requestEv.sharedMap.get(deps.RequestEvShareQData);
+                if (qData && !is404ErrorPage) {
+                  const qDataFilePath = sys.getDataFilePath(url.pathname);
+                  const dataWriter = sys.createWriteStream(qDataFilePath);
+                  dataWriter.on("error", (e) => {
+                    console.error(e);
+                    result.error = {
+                      message: e.message,
+                      stack: e.stack
+                    };
+                  });
+                  const serialized = await deps.serialize(qData);
+                  dataWriter.write(serialized);
+                  writePromises.push(new Promise((resolve) => {
+                    result.filePath = routeFilePath;
+                    dataWriter.end(resolve);
+                  }));
+                }
+              }
+              if (routeWriter) {
+                writePromises.push(new Promise((resolve) => {
+                  result.filePath = routeFilePath;
+                  routeWriter.end(resolve);
+                }).finally(closeResolved));
+              }
+              if (writePromises.length > 0) {
+                await Promise.all(writePromises);
+              }
+            } catch (e) {
+              console.error("Error during stream close", staticRoute.pathname, e);
+              routeWriter = null;
+              result.error = {
+                message: String(e),
+                stack: e.stack || ""
+              };
+            }
+          }
+        });
+        return stream;
+      }
+    };
+    const promise = requestHandlerForSsg(requestCtx, opts, deps).then((rsp) => {
+      if (rsp != null) {
+        return rsp.completion.then((r) => {
+          if (routeWriter) {
+            return closePromise.then(() => r);
+          }
+          return r;
+        });
+      }
+    }).then((e) => {
+      if (e !== void 0) {
+        if (isRedirectMessage(e)) {
+          return;
+        }
+        if (e instanceof Error) {
+          result.error = {
+            message: e.message,
+            stack: e.stack
+          };
+        } else {
+          result.error = {
+            message: String(e),
+            stack: void 0
+          };
+        }
+        console.error("Error during request handling", staticRoute.pathname, e);
+      }
+    }).catch((e) => {
+      console.error("Unhandled error during request handling", staticRoute.pathname, e);
+      result.error = {
+        message: String(e),
+        stack: e.stack || ""
+      };
+    }).finally(() => {
+      pendingPromises.delete(promise);
+      callback(result);
+    });
+    pendingPromises.add(promise);
+  } catch (e) {
+    console.error("Error during render", staticRoute.pathname, e);
+    if (e instanceof Error) {
+      result.error = {
+        message: e.message,
+        stack: e.stack
+      };
+    } else {
+      result.error = {
+        message: String(e),
+        stack: void 0
+      };
+    }
+    callback(result);
+  }
+}
+async function workerThread(sys) {
+  delete globalThis.__qwik;
+  const opts = sys.getOptions();
+  const pendingPromises = /* @__PURE__ */ new Set();
+  const deps = {
+    ...staticWorkerThreadDeps,
+    serialize: await loadSerialize()
+  };
+  process.on("uncaughtException", (e) => {
+    console.error("Worker uncaught exception (suppressed):", e.message);
+  });
+  process.on("unhandledRejection", (e) => {
+    console.error("Worker unhandled rejection (suppressed):", e instanceof Error ? e.message : e);
+  });
+  const onMessage = async (msg) => {
+    switch (msg.type) {
+      case "render": {
+        return new Promise((resolve) => {
+          workerRender(sys, opts, msg, pendingPromises, resolve, deps).catch((e) => {
+            console.error("Error during render", msg.pathname, e);
+            resolve({
+              type: "render",
+              pathname: msg.pathname,
+              url: "",
+              ok: false,
+              error: {
+                message: e instanceof Error ? e.message : String(e),
+                stack: e instanceof Error ? e.stack : void 0
+              },
+              filePath: null,
+              contentType: null,
+              resourceType: null
+            });
+          });
+        });
+      }
+      case "close": {
+        if (pendingPromises.size) {
+          const promises = Array.from(pendingPromises);
+          pendingPromises.clear();
+          await Promise.all(promises);
+        }
+        return {
+          type: "close"
+        };
+      }
+    }
+  };
+  parentPort?.on("message", async (msg) => {
+    try {
+      parentPort?.postMessage(await onMessage(msg));
+    } catch (e) {
+      if (msg.type === "render") {
+        const error = e instanceof Error ? e : new Error(String(e));
+        parentPort?.postMessage({
+          type: "render",
+          pathname: msg.pathname,
+          url: "",
+          ok: false,
+          error: {
+            message: error.message,
+            stack: error.stack
+          },
+          filePath: null,
+          contentType: null,
+          resourceType: null
+        });
+      } else {
+        console.error("Worker message handler error", e);
+      }
+    }
+    if (msg.type === "close") {
+      parentPort?.close();
+    }
+  });
+}
+
+export { workerThread };