@qwik.dev/router 2.0.0-beta.37 → 2.0.0-beta.39

package/lib/chunks/head.qwik.mjs

@@ -1,6 +1,37 @@
 import { e as ensureSlash } from './pathname.mjs';
-import { v as deepFreeze } from './deepFreeze.qwik.mjs';
-import { withLocale } from '@qwik.dev/core';
+import { createContextId, isServer as isServer$1, implicit$FirstArg, isDev, createComputedQrl, inlinedQrl, _captures, withLocale } from '@qwik.dev/core';
+import * as qwikRouterConfig from '@qwik-router-config';
+import { _getAsyncLocalStorage, _getContextEvent, _resolveContextWithoutSequentialScope, _injectAsyncSignalValue, _UNINITIALIZED, _deserialize, _markSignalAsExternallyOwned, SerializerSymbol, _verifySerializable } from '@qwik.dev/core/internal';
+import { isServer } from '@qwik.dev/core/build';
+import { g as getLoaderName } from './request-path.mjs';
+import { R as RedirectMessage, S as ServerError, t as throwIfControlFlowSignal } from './server-error.mjs';
+
+let _asyncRequestStore;
+if (isServer) {
+  const AsyncLocalStorage = _getAsyncLocalStorage();
+  if (AsyncLocalStorage) {
+    _asyncRequestStore = new AsyncLocalStorage();
+  } else {
+    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");
+  }
+}
+
+const deepFreeze = (obj) => {
+  if (obj == null) {
+    return obj;
+  }
+  Object.getOwnPropertyNames(obj).forEach((prop) => {
+    const value = obj[prop];
+    if (value && typeof value === "object" && !Object.isFrozen(value)) {
+      try {
+        deepFreeze(value);
+      } catch {
+        return obj;
+      }
+    }
+  });
+  return Object.freeze(obj);
+};
 
 const MODULE_CACHE = /* @__PURE__ */ new WeakMap();
 const httpErrorLoader = () => import('./http-error.qwik.mjs');
@@ -38,6 +69,10 @@ function walkTrieKeys(root, keys) {
     layouts
   };
 }
+const boundaryChain = (ref) => ref.v ? Array.isArray(ref.v) ? ref.v : [
+  ...ref.layouts,
+  ref.v
+] : void 0;
 function collectNodeMeta(node, groups, layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef, loaderHashes, loaderPathsByHash, matchedPathname = "/") {
   for (let j = 0; j < groups.length; j++) {
     const g = groups[j];
@@ -55,9 +90,15 @@ function collectNodeMeta(node, groups, layouts, errorLoaderRef, notFoundLoaderRe
     }
     if (g._E) {
       errorLoaderRef.v = g._E;
+      errorLoaderRef.layouts = [
+        ...layouts
+      ];
     }
     if (g._4) {
       notFoundLoaderRef.v = g._4;
+      notFoundLoaderRef.layouts = [
+        ...layouts
+      ];
     }
     if (g._N) {
       menuLoaderRef.v = g._N;
@@ -77,9 +118,15 @@ function collectNodeMeta(node, groups, layouts, errorLoaderRef, notFoundLoaderRe
   }
   if (node._E) {
     errorLoaderRef.v = node._E;
+    errorLoaderRef.layouts = [
+      ...layouts
+    ];
   }
   if (node._4) {
     notFoundLoaderRef.v = node._4;
+    notFoundLoaderRef.layouts = [
+      ...layouts
+    ];
   }
   if (node._N) {
     menuLoaderRef.v = node._N;
@@ -162,27 +209,34 @@ function findChild(node, part, partLower, parts, partIndex) {
   }
   return void 0;
 }
-function findIndexNode(node) {
-  if (node._I || node._G != null) {
+function descendGroups(node, hit) {
+  const value = hit(node);
+  if (value !== void 0) {
     return {
-      target: node,
+      value,
+      node,
       groups: []
     };
   }
   if (node._M) {
     for (let j = 0; j < node._M.length; j++) {
       const group = node._M[j];
-      const result = findIndexNode(group);
+      const result = descendGroups(group, hit);
       if (result) {
-        if (result.target !== group) {
-          result.groups.unshift(group);
-        }
+        result.groups.unshift(group);
         return result;
       }
     }
   }
   return void 0;
 }
+function findIndexNode(node) {
+  const r = descendGroups(node, (n) => n._I || n._G != null ? n : void 0);
+  return r ? {
+    target: r.node,
+    groups: r.groups.filter((g) => g !== r.node)
+  } : void 0;
+}
 function resolveLoaders(root, node, gatheredLayouts) {
   if (node._G != null) {
     const keys = node._G.split("/").filter((p) => p.length > 0);
@@ -222,23 +276,29 @@ function resolveLoaders(root, node, gatheredLayouts) {
   ];
 }
 function findRestNode(node) {
-  if (node._A) {
-    return {
-      next: node._A,
-      groups: []
-    };
+  const r = descendGroups(node, (n) => n._A);
+  return r ? {
+    next: r.value,
+    groups: r.groups
+  } : void 0;
+}
+function findGroupBoundary(node, layouts, kind) {
+  const r = descendGroups(node, (n) => n[kind]);
+  if (!r) {
+    return void 0;
   }
-  if (node._M) {
-    for (let j = 0; j < node._M.length; j++) {
-      const group = node._M[j];
-      const result = findRestNode(group);
-      if (result) {
-        result.groups.unshift(group);
-        return result;
-      }
+  const groupLayouts = [
+    ...layouts
+  ];
+  for (const g of r.groups) {
+    if (g._L) {
+      groupLayouts.push(g._L);
     }
   }
-  return void 0;
+  return {
+    v: r.value,
+    layouts: groupLayouts
+  };
 }
 function matchRouteTree(root = {}, pathname) {
   let node = root;
@@ -248,32 +308,23 @@ function matchRouteTree(root = {}, pathname) {
   const loaderHashes = [];
   const loaderPathsByHash = {};
   const errorLoaderRef = {
-    v: void 0
+    v: void 0,
+    layouts: []
   };
   const notFoundLoaderRef = {
-    v: void 0
+    v: void 0,
+    layouts: []
   };
   const menuLoaderRef = {
     v: void 0
   };
-  if (root._L) {
-    layouts.push(root._L);
-  }
-  if (root._R) {
-    loaderHashes.push(...root._R);
-    for (let i2 = 0; i2 < root._R.length; i2++) {
-      const hash = root._R[i2];
-      loaderPathsByHash[hash] = "/";
-    }
-  }
-  if (root._E) {
-    errorLoaderRef.v = root._E;
-  }
-  if (root._4) {
-    notFoundLoaderRef.v = root._4;
-  }
-  if (root._N) {
-    menuLoaderRef.v = root._N;
+  const groupNodes = [];
+  collectNodeMeta(root, [], layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef, loaderHashes, loaderPathsByHash);
+  if (root._M) {
+    groupNodes.push({
+      node: root,
+      depth: layouts.length
+    });
   }
   let done = false;
   let matched = true;
@@ -309,7 +360,9 @@ function matchRouteTree(root = {}, pathname) {
           ...loaderPathsByHash
         },
         errorLoader: errorLoaderRef.v,
+        errorLayouts: errorLoaderRef.layouts,
         notFoundLoader: notFoundLoaderRef.v,
+        notFoundLayouts: notFoundLoaderRef.layouts,
         menuLoader: menuLoaderRef.v
       };
     }
@@ -321,6 +374,12 @@ function matchRouteTree(root = {}, pathname) {
     node = found.next;
     const matchedPathname = `/${parts.slice(0, found.done ? len : i + 1).join("/")}/`;
     collectNodeMeta(node, found.groups, layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef, loaderHashes, loaderPathsByHash, matchedPathname);
+    if (node._M) {
+      groupNodes.push({
+        node,
+        depth: layouts.length
+      });
+    }
   }
   if (matched && !done && i === len) {
     if (!node._I && node._G == null) {
@@ -330,19 +389,6 @@ function matchRouteTree(root = {}, pathname) {
         node = indexResult.target;
       }
     }
-    if (!node._I && node._G == null && 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 == null) {
       const restInfo = findRestNode(node);
       if (restInfo) {
@@ -373,10 +419,12 @@ function matchRouteTree(root = {}, pathname) {
       ...fb.loaderPathsByHash
     };
     const fbErrorRef = {
-      v: fb.errorLoader
+      v: fb.errorLoader,
+      layouts: fb.errorLayouts
     };
     const fbNotFoundRef = {
-      v: fb.notFoundLoader
+      v: fb.notFoundLoader,
+      layouts: fb.notFoundLayouts
     };
     const fbMenuRef = {
       v: fb.menuLoader
@@ -394,19 +442,46 @@ function matchRouteTree(root = {}, pathname) {
         loaderHashes: fbLoaderHashes.length > 0 ? fbLoaderHashes : void 0,
         loaderPathsByHash: Object.keys(fbLoaderPathsByHash).length > 0 ? fbLoaderPathsByHash : void 0,
         menuLoader: fbMenuRef.v,
-        errorLoader: fbErrorRef.v,
-        notFoundLoader: fbNotFoundRef.v
+        errorLoader: boundaryChain(fbErrorRef)
       };
     }
     errorLoaderRef.v = fbErrorRef.v;
+    errorLoaderRef.layouts = fbErrorRef.layouts;
     notFoundLoaderRef.v = fbNotFoundRef.v;
+    notFoundLoaderRef.layouts = fbNotFoundRef.layouts;
     menuLoaderRef.v = fbMenuRef.v;
   }
   if (!loaders) {
-    const loader = notFoundLoaderRef.v || errorLoaderRef.v || httpErrorLoader;
+    const recover = (kind) => {
+      for (let k = groupNodes.length - 1; k >= 0; k--) {
+        const found = findGroupBoundary(groupNodes[k].node, layouts.slice(0, groupNodes[k].depth), kind);
+        if (found) {
+          return found;
+        }
+      }
+      return void 0;
+    };
+    if (!notFoundLoaderRef.v) {
+      const g = recover("_4");
+      if (g) {
+        notFoundLoaderRef.v = g.v;
+        notFoundLoaderRef.layouts = g.layouts;
+      }
+    }
+    if (!errorLoaderRef.v) {
+      const g = recover("_E");
+      if (g) {
+        errorLoaderRef.v = g.v;
+        errorLoaderRef.layouts = g.layouts;
+      }
+    }
+    const ref = notFoundLoaderRef.v ? notFoundLoaderRef : errorLoaderRef.v ? errorLoaderRef : null;
+    const boundary = ref?.v ?? httpErrorLoader;
+    const boundaryLayouts = ref ? ref.layouts : layouts;
     return {
-      loaders: [
-        loader
+      loaders: Array.isArray(boundary) ? boundary : [
+        ...boundaryLayouts,
+        boundary
       ],
       params,
       routeParts,
@@ -415,8 +490,7 @@ function matchRouteTree(root = {}, pathname) {
       loaderHashes: void 0,
       loaderPathsByHash: void 0,
       menuLoader: menuLoaderRef.v,
-      errorLoader: errorLoaderRef.v,
-      notFoundLoader: notFoundLoaderRef.v
+      errorLoader: boundaryChain(errorLoaderRef)
     };
   }
   if (node._R) {
@@ -436,8 +510,7 @@ function matchRouteTree(root = {}, pathname) {
     loaderHashes: loaderHashes.length > 0 ? loaderHashes : void 0,
     loaderPathsByHash: Object.keys(loaderPathsByHash).length > 0 ? loaderPathsByHash : void 0,
     menuLoader: menuLoaderRef.v,
-    errorLoader: errorLoaderRef.v,
-    notFoundLoader: notFoundLoaderRef.v
+    errorLoader: boundaryChain(errorLoaderRef)
   };
 }
 const loadModule = (moduleLoader, pendingLoads, moduleSetter, cacheModules) => {
@@ -462,7 +535,7 @@ const loadModule = (moduleLoader, pendingLoads, moduleSetter, cacheModules) => {
 };
 const loadRoute = async (routes, cacheModules, pathname) => {
   const result = matchRouteTree(routes, pathname);
-  const { loaders, params, routeParts, notFound, routeBundleNames, loaderHashes, loaderPathsByHash, menuLoader, errorLoader, notFoundLoader } = result;
+  const { loaders, params, routeParts, notFound, routeBundleNames, loaderHashes, loaderPathsByHash, menuLoader, errorLoader } = result;
   const routeName = "/" + routeParts.join("/");
   const modules = new Array(loaders.length);
   const pendingLoads = [];
@@ -472,30 +545,6 @@ const loadRoute = async (routes, cacheModules, pathname) => {
   }
   let menu = void 0;
   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,
-      $loaders$: loaderHashes,
-      $loaderPaths$: loaderPathsByHash
-    };
-  }
   if (pendingLoads.length > 0) {
     await Promise.all(pendingLoads);
   }
@@ -512,6 +561,678 @@ const loadRoute = async (routes, cacheModules, pathname) => {
   };
 };
 
+const QACTION_KEY = "qaction";
+const QFN_KEY = "qfunc";
+const QDATA_KEY = "qdata";
+const Q_ROUTE = "q:route";
+const DEFAULT_LOADERS_SERIALIZATION_STRATEGY = globalThis.__DEFAULT_LOADERS_SERIALIZATION_STRATEGY__ || "never";
+
+const RouteStateContext = /* @__PURE__ */ createContextId("qr-s");
+const RouteLoaderCtxContext = /* @__PURE__ */ createContextId("qr-lc");
+const ContentContext = /* @__PURE__ */ createContextId("qr-c");
+const ContentInternalContext = /* @__PURE__ */ createContextId("qr-ic");
+const DocumentHeadContext = /* @__PURE__ */ createContextId("qr-h");
+const RouteLocationContext = /* @__PURE__ */ createContextId("qr-l");
+const RouteNavigateContext = /* @__PURE__ */ createContextId("qr-n");
+const RouteActionContext = /* @__PURE__ */ createContextId("qr-a");
+const RoutePreventNavigateContext = /* @__PURE__ */ createContextId("qr-p");
+const HttpStatusContext = /* @__PURE__ */ createContextId("qr-hs");
+
+const REQUEST_ROUTE_LOADER_STATE = "@routeLoaderState";
+const REQUEST_LOADER_PATHS_STORE = "@loaderPathsStore";
+const REQUEST_ROUTE_LOADERS = "@routeLoaders";
+const REQUEST_ROUTE_LOADER_PROMISES = "@routeLoaderPromises";
+const REQUEST_ROUTE_LOADER_EVENTS = "@routeLoaderEvents";
+const REQUEST_ROUTE_LOADER_ROOT_EVENT = "@routeLoaderRootEvent";
+const ROUTE_LOADER_VALUE_PREFIX = "__qwik_route_loader_value__";
+const FULLPATH_HEADER = "X-Qwik-fullpath";
+const ROUTE_PATH_HEADER = "X-Qwik-route-path";
+const navFetchCache = /* @__PURE__ */ new Map();
+const clearNavFetchCache = () => navFetchCache.clear();
+const isRedirectStatus = (status) => status >= 300 && status < 400;
+const wrapWithAbort = (promise, signal) => {
+  if (signal.aborted) {
+    return Promise.reject(signal.reason);
+  }
+  return new Promise((resolve, reject) => {
+    const abort = () => reject(signal.reason);
+    signal.addEventListener("abort", abort, {
+      once: true
+    });
+    promise.finally(() => signal.removeEventListener("abort", abort)).then(resolve, reject);
+  });
+};
+const getRouteLoaderValueStateKey = (loaderId) => `${ROUTE_LOADER_VALUE_PREFIX}${loaderId}`;
+const isRequestEvent = (value) => !!value && typeof value === "object" && Object.prototype.hasOwnProperty.call(value, "sharedMap") && Object.prototype.hasOwnProperty.call(value, "cookie");
+const isLoaderInternal = (value) => typeof value === "function" && value.__brand === "server_loader";
+const fetchRouteLoaderData = async (loaderId, routePath, manifestHash, opts) => {
+  if (!routePath) {
+    return void 0;
+  }
+  let resolvedPath = routePath;
+  const basePath = opts?.basePath ?? "/";
+  if (basePath !== "/" && !resolvedPath.startsWith(basePath)) {
+    resolvedPath = basePath + resolvedPath.slice(1);
+  }
+  const pathBase = ensureSlash(resolvedPath);
+  const pageUrl = opts?.pageUrl;
+  const search = pageUrl?.search ?? "";
+  const url = `${pathBase}${getLoaderName(loaderId, manifestHash)}${search}`;
+  const headers = {};
+  if (pageUrl && pageUrl.pathname !== pathBase) {
+    if (!globalThis.__STRICT_LOADERS__) {
+      headers[FULLPATH_HEADER] = pageUrl.pathname;
+    } else if (isDev) {
+      headers[ROUTE_PATH_HEADER] = pageUrl.pathname;
+    }
+  }
+  const cacheKey = `${url}
+${headers[FULLPATH_HEADER] ?? ""}`;
+  if (!opts?.ignoreCache) {
+    const entry = navFetchCache.get(cacheKey);
+    if (entry) {
+      return opts?.signal ? wrapWithAbort(entry, opts.signal) : entry;
+    }
+  }
+  const request = async () => {
+    const response = await fetch(url, {
+      signal: opts?.signal,
+      cache: opts?.ignoreCache ? "reload" : "default",
+      headers
+    });
+    if (response.redirected) {
+      return {
+        r: response.url
+      };
+    }
+    if (isRedirectStatus(response.status)) {
+      const location1 = response.headers.get("Location");
+      if (location1) {
+        return {
+          r: location1
+        };
+      }
+    }
+    if (!response.ok) {
+      return void 0;
+    }
+    return {
+      raw: await response.text()
+    };
+  };
+  if (opts?.ignoreCache) {
+    return request();
+  }
+  if (opts?.signal) {
+    return request().then((value) => {
+      if (value !== void 0 && !navFetchCache.has(cacheKey)) {
+        navFetchCache.set(cacheKey, Promise.resolve(value));
+      }
+      return value;
+    });
+  }
+  const promise = request().then((value) => {
+    if (value === void 0) {
+      navFetchCache.delete(cacheKey);
+    }
+    return value;
+  }, (err) => {
+    navFetchCache.delete(cacheKey);
+    throw err;
+  });
+  navFetchCache.set(cacheKey, promise);
+  return promise;
+};
+const filterSearchParams = (params, allowed) => {
+  const filtered = new URLSearchParams();
+  for (let i = 0; i < allowed.length; i++) {
+    const name = allowed[i];
+    const values = params.getAll(name);
+    for (let j = 0; j < values.length; j++) {
+      filtered.append(name, values[j]);
+    }
+  }
+  filtered.sort();
+  return filtered.toString() ? `?${filtered.toString()}` : "";
+};
+const getLoaderOptions = (rest) => {
+  let id;
+  let serializationStrategy = DEFAULT_LOADERS_SERIALIZATION_STRATEGY;
+  let cacheControl;
+  let eTag;
+  let cacheKey;
+  let search;
+  let blockSSR = true;
+  const validators = [];
+  if (rest.length === 1) {
+    const options = rest[0];
+    if (options && typeof options === "object") {
+      if ("validate" in options) {
+        validators.push(options);
+      } else {
+        if (options.id) {
+          id = options.id;
+        }
+        if (options.serializationStrategy) {
+          serializationStrategy = options.serializationStrategy;
+        }
+        if (options.validation) {
+          validators.push(...options.validation);
+        }
+        if ("cacheControl" in options) {
+          cacheControl = options.cacheControl;
+        }
+        if ("eTag" in options) {
+          eTag = options.eTag;
+        }
+        if ("cacheKey" in options) {
+          cacheKey = options.cacheKey;
+        }
+        if (options.search) {
+          search = options.search;
+        } else if (globalThis.__STRICT_LOADERS__) {
+          search = [];
+        }
+        if (options.blockSSR === false) {
+          if (!__EXPERIMENTAL__.blockSSR) {
+            throw new Error('`blockSSR: false` is an experimental feature and is not enabled. Please enable the feature flag by adding `experimental: ["blockSSR"]` to your qwikVite plugin options.');
+          }
+          blockSSR = false;
+        }
+      }
+    }
+  } else if (rest.length > 1) {
+    validators.push(...rest.filter(Boolean));
+  }
+  return {
+    id,
+    validators: validators.reverse(),
+    serializationStrategy,
+    cacheControl,
+    eTag,
+    cacheKey,
+    search,
+    blockSSR
+  };
+};
+const getRequestEvent = (thisArg) => {
+  if (!isServer$1) {
+    throw new Error("getRequestEvent() can only be used on the server.");
+  }
+  return _asyncRequestStore?.getStore() || [
+    thisArg,
+    _getContextEvent()
+  ].find(isRequestEvent);
+};
+const REQUEST_ROUTE_LOADER_VALUES = "@routeLoaderValues";
+function getRouteLoaderValues(requestEv) {
+  let values = requestEv.sharedMap.get(REQUEST_ROUTE_LOADER_VALUES);
+  if (!values) {
+    values = {};
+    requestEv.sharedMap.set(REQUEST_ROUTE_LOADER_VALUES, values);
+  }
+  return values;
+}
+function getRouteLoaderPromises(requestEv) {
+  let promises = requestEv.sharedMap.get(REQUEST_ROUTE_LOADER_PROMISES);
+  if (!promises) {
+    promises = {};
+    requestEv.sharedMap.set(REQUEST_ROUTE_LOADER_PROMISES, promises);
+  }
+  return promises;
+}
+function clearRouteLoaderData(requestEv) {
+  requestEv.sharedMap.delete(REQUEST_ROUTE_LOADER_STATE);
+  requestEv.sharedMap.delete(REQUEST_ROUTE_LOADER_VALUES);
+  requestEv.sharedMap.delete(REQUEST_ROUTE_LOADER_PROMISES);
+  requestEv.sharedMap.delete(REQUEST_ROUTE_LOADER_EVENTS);
+  requestEv.sharedMap.delete(REQUEST_ROUTE_LOADER_ROOT_EVENT);
+  requestEv.sharedMap.delete(REQUEST_ROUTE_LOADERS);
+}
+function setRouteLoaders(requestEv, loaders) {
+  requestEv.sharedMap.set(REQUEST_ROUTE_LOADERS, loaders);
+}
+function getRouteLoaders(requestEv) {
+  return requestEv.sharedMap.get(REQUEST_ROUTE_LOADERS) ?? [];
+}
+function getRouteLoaderCtx(requestEv) {
+  let ctx = requestEv.sharedMap.get(REQUEST_LOADER_PATHS_STORE);
+  if (!ctx) {
+    ctx = {
+      loaderPaths: {}
+    };
+    requestEv.sharedMap.set(REQUEST_LOADER_PATHS_STORE, ctx);
+  }
+  return ctx;
+}
+const updateRouteLoaderPaths = (ctx, loaderPaths, pageUrl) => {
+  if (!isServer$1) {
+    ctx.pagePathname = pageUrl.pathname;
+    ctx.pageSearch = pageUrl.search;
+    if (isDev) {
+      ctx.devRouteLoaderPaths = {};
+    }
+  }
+  if (loaderPaths) {
+    for (const key in loaderPaths) {
+      ctx.loaderPaths[key] = loaderPaths[key];
+      if (!isServer$1 && isDev) {
+        ctx.devRouteLoaderPaths[key] = true;
+      }
+    }
+  }
+};
+const getModuleRouteLoaders = (mods) => {
+  const routeLoaders = [];
+  const seen = /* @__PURE__ */ new Map();
+  for (let i = 0; i < mods.length; i++) {
+    const mod = mods[i];
+    if (!mod) {
+      continue;
+    }
+    for (const key in mod) {
+      const value = mod[key];
+      if (isLoaderInternal(value)) {
+        const existing = seen.get(value.__id);
+        if (existing) {
+          if (isDev && existing !== value) {
+            console.warn(`Two route loaders share the same id "${value.__id}". Only the first will run; the others are ignored. If they are created by a shared wrapper around routeLoader$, give each loader a distinct \`id\` option.`);
+          }
+          continue;
+        }
+        seen.set(value.__id, value);
+        routeLoaders.push(value);
+      }
+    }
+  }
+  return routeLoaders;
+};
+const immutableLoaderIds = /* @__PURE__ */ new Set();
+const isImmutableLoader = (loaderId) => immutableLoaderIds.has(loaderId);
+const invalidateNavRouteLoaders = (state) => {
+  for (const id in state) {
+    if (!id.startsWith(ROUTE_LOADER_VALUE_PREFIX) && !immutableLoaderIds.has(id)) {
+      state[id].invalidate();
+    }
+  }
+};
+const setLoaderSignalValue = (signal, value) => {
+  _injectAsyncSignalValue(signal, value);
+};
+const matchesRouteLoaderId = (loader, loaderId) => {
+  return typeof loaderId === "string" && (loader.__id === loaderId || isDev && loader.__qrl.getHash() === loaderId);
+};
+const resolveRouteLoaderByHash = (routeLoaders, loaderId) => {
+  return routeLoaders.find((loader) => matchesRouteLoaderId(loader, loaderId));
+};
+const getLoaderRequestEvent = (loader, requestEv) => {
+  let rootRequestEv = requestEv.sharedMap.get(REQUEST_ROUTE_LOADER_ROOT_EVENT);
+  if (!rootRequestEv) {
+    rootRequestEv = requestEv;
+    requestEv.sharedMap.set(REQUEST_ROUTE_LOADER_ROOT_EVENT, rootRequestEv);
+  }
+  const url = new URL(rootRequestEv.url);
+  const pathname = globalThis.__STRICT_LOADERS__ ? getRouteLoaderCtx(rootRequestEv).loaderPaths[loader.__id] || rootRequestEv.url.pathname : rootRequestEv.url.pathname;
+  const filteredSearch = loader.__search ? filterSearchParams(url.searchParams, loader.__search) : rootRequestEv.url.search;
+  if (pathname === rootRequestEv.url.pathname && filteredSearch === rootRequestEv.url.search) {
+    return rootRequestEv;
+  }
+  let events = rootRequestEv.sharedMap.get(REQUEST_ROUTE_LOADER_EVENTS);
+  if (!events) {
+    events = /* @__PURE__ */ new Map();
+    rootRequestEv.sharedMap.set(REQUEST_ROUTE_LOADER_EVENTS, events);
+  }
+  const eventKey = `${pathname}
+${filteredSearch}`;
+  let loaderRequestEv = events.get(eventKey);
+  if (!loaderRequestEv) {
+    url.pathname = pathname;
+    url.search = filteredSearch;
+    const request = new Request(url, rootRequestEv.request);
+    loaderRequestEv = Object.create(rootRequestEv, {
+      originalUrl: {
+        value: new URL(url),
+        enumerable: true
+      },
+      params: {
+        value: {},
+        enumerable: true
+      },
+      pathname: {
+        get: () => url.pathname,
+        enumerable: true
+      },
+      query: {
+        get: () => url.searchParams,
+        enumerable: true
+      },
+      request: {
+        value: request,
+        enumerable: true
+      },
+      url: {
+        value: url,
+        enumerable: true
+      }
+    });
+    events.set(eventKey, loaderRequestEv);
+  }
+  return loaderRequestEv;
+};
+const detachResponseFromEvent = (requestEv) => {
+  let status = 200;
+  const headers = new Headers();
+  return Object.create(requestEv, {
+    headers: {
+      value: headers,
+      enumerable: true
+    },
+    status: {
+      value: (statusCode) => {
+        if (typeof statusCode === "number") {
+          status = statusCode;
+        }
+        return status;
+      },
+      enumerable: true
+    },
+    error: {
+      value: (statusCode, message) => {
+        status = statusCode;
+        return new ServerError(statusCode, message);
+      },
+      enumerable: true
+    },
+    redirect: {
+      value: (statusCode, url) => {
+        status = statusCode;
+        if (url) {
+          headers.set("Location", url);
+        }
+        return new RedirectMessage();
+      },
+      enumerable: true
+    },
+    fail: {
+      value: (statusCode, data) => {
+        status = statusCode;
+        return {
+          failed: true,
+          ...data
+        };
+      },
+      enumerable: true
+    },
+    // A background loader cannot set the page's cache headers.
+    cacheControl: {
+      value: () => {
+      },
+      enumerable: true
+    }
+  });
+};
+async function runValidators(requestEv, validators, data) {
+  let lastResult = {
+    success: true,
+    data
+  };
+  if (validators) {
+    for (let i = 0; i < validators.length; i++) {
+      const validator = validators[i];
+      lastResult = await validator.validate(requestEv, data);
+      if (!lastResult.success) {
+        return lastResult;
+      }
+      data = lastResult.data;
+    }
+  }
+  return lastResult;
+}
+function verifySerializable(data, qrl) {
+  try {
+    _verifySerializable(data, void 0);
+  } catch (error) {
+    if (error instanceof Error && qrl.dev) {
+      error.loc = qrl.dev;
+    }
+    throw error;
+  }
+}
+const getRouteLoaderData = async (loaderQrl, validators, requestEv) => {
+  const loaderRequestEv = requestEv;
+  const result = await runValidators(requestEv, validators, void 0);
+  if (!result.success) {
+    return loaderRequestEv.fail(result.status ?? 500, result.error);
+  }
+  const resolved = await loaderQrl.call(loaderRequestEv, loaderRequestEv);
+  const value = typeof resolved === "function" ? resolved() : resolved;
+  throwIfControlFlowSignal(value);
+  if (isDev) {
+    verifySerializable(value, loaderQrl);
+  }
+  return value;
+};
+const loadRouteLoaderByQrl = (loaderId, loaderQrl, validators, requestEv) => {
+  const values = getRouteLoaderValues(requestEv);
+  if (loaderId in values) {
+    return Promise.resolve(values[loaderId]);
+  }
+  const promises = getRouteLoaderPromises(requestEv);
+  let promise = promises[loaderId];
+  if (!promise) {
+    promise = getRouteLoaderData(loaderQrl, validators, requestEv).then((value) => {
+      values[loaderId] = value;
+      return value;
+    }, (err) => {
+      delete promises[loaderId];
+      throw err;
+    });
+    promises[loaderId] = promise;
+  }
+  return promise;
+};
+class ServerRouteLoaderCapture {
+  hash;
+  qrl;
+  validators;
+  blockSSR;
+  constructor(hash, qrl, validators, blockSSR) {
+    this.hash = hash;
+    this.qrl = qrl;
+    this.validators = validators;
+    this.blockSSR = blockSSR;
+  }
+  load() {
+    const requestEv = getRequestEvent();
+    if (!requestEv) {
+      throw new Error("Unable to determine the current RequestEvent.");
+    }
+    const values = getRouteLoaderValues(requestEv);
+    if (this.hash in values) {
+      return values[this.hash];
+    }
+    const ev = this.blockSSR ? requestEv : detachResponseFromEvent(requestEv);
+    return loadRouteLoaderByQrl(this.hash, this.qrl, this.validators, ev);
+  }
+  [SerializerSymbol]() {
+    return this.hash;
+  }
+}
+const createRouteLoaderSignal = (loader, routeLoaderCtx, state) => {
+  const id = loader.__id;
+  const stateValues = state;
+  const resumeValueKey = getRouteLoaderValueStateKey(id);
+  const capture = isServer$1 ? new ServerRouteLoaderCapture(id, loader.__qrl, loader.__validators, loader.__blockSSR) : id;
+  const searchFilter = loader.__search;
+  const lastFetch = {};
+  const signal = createComputedQrl(/* @__PURE__ */ inlinedQrl(async (ctx) => {
+    const capture2 = _captures[0], id2 = _captures[1], lastFetch2 = _captures[2], resumeValueKey2 = _captures[3], routeLoaderCtx2 = _captures[4], searchFilter2 = _captures[5], stateValues2 = _captures[6];
+    const hasInjectedValue = !!ctx.info && typeof ctx.info === "object" && "__v" in ctx.info;
+    const trackedRoutePath = ctx.track(routeLoaderCtx2.loaderPaths, id2);
+    const trackedPagePathname = ctx.track(routeLoaderCtx2, "pagePathname");
+    const trackedPageSearch = ctx.track(routeLoaderCtx2, "pageSearch");
+    if (hasInjectedValue) {
+      const value = ctx.info.__v;
+      if (!isServer$1 && resumeValueKey2 in stateValues2) {
+        stateValues2[resumeValueKey2] = value;
+      }
+      lastFetch2.raw = void 0;
+      return value;
+    }
+    if (isServer$1) {
+      return capture2.load();
+    }
+    const pagePathname = trackedPagePathname || location.pathname;
+    const pageSearch = trackedPageSearch || location.search;
+    const pageUrl = new URL(pagePathname + pageSearch, location.href);
+    const mHash = routeLoaderCtx2.manifestHash || "dev";
+    const basePath = qwikRouterConfig.basePathname ?? "/";
+    const needsResumeFetch = stateValues2[resumeValueKey2] === _UNINITIALIZED;
+    const fetchRoutePath = trackedRoutePath || (needsResumeFetch ? pageUrl.pathname : void 0);
+    if (!fetchRoutePath) {
+      return ctx.previous;
+    }
+    let fetchUrl = pageUrl;
+    if (searchFilter2) {
+      fetchUrl = new URL(pageUrl.href);
+      fetchUrl.search = filterSearchParams(pageUrl.searchParams, searchFilter2);
+    }
+    const result = await fetchRouteLoaderData(id2, fetchRoutePath, mHash, {
+      pageUrl: fetchUrl,
+      basePath,
+      ignoreCache: ctx.info === true,
+      signal: ctx.abortSignal
+    });
+    if (!result) {
+      throw new Error(`Loader ${id2} returned empty response`);
+    }
+    let response;
+    if (result.raw === void 0) {
+      response = result;
+    } else {
+      if (result.raw === lastFetch2.raw && ctx.previous !== void 0) {
+        return ctx.previous;
+      }
+      response = await _deserialize(result.raw);
+      if (!response) {
+        throw new Error(`Loader ${id2} returned empty response`);
+      }
+    }
+    if (response.r) {
+      const goto = routeLoaderCtx2.goto;
+      if (goto) {
+        goto(response.r, {
+          replaceState: true
+        });
+      } else {
+        location.href = response.r;
+      }
+      return ctx.previous;
+    }
+    if (response.e) {
+      throw response.e;
+    }
+    lastFetch2.raw = result.raw;
+    if (needsResumeFetch) {
+      stateValues2[resumeValueKey2] = response.d;
+    }
+    return response.d;
+  }, "createRouteLoaderSignal_signal_createComputed_4s4ZDCYhDOA", [
+    capture,
+    id,
+    lastFetch,
+    resumeValueKey,
+    routeLoaderCtx,
+    searchFilter,
+    stateValues
+  ]), {
+    serializationStrategy: loader.__serializationStrategy
+  });
+  _markSignalAsExternallyOwned(signal);
+  return signal;
+};
+const ensureRouteLoaderSignal = (loader, state, routeLoaderCtx) => {
+  if (loader.__cacheControl === "immutable") {
+    immutableLoaderIds.add(loader.__id);
+  }
+  if (isServer$1 && loader.__serializationStrategy === "never") {
+    state[getRouteLoaderValueStateKey(loader.__id)] = _UNINITIALIZED;
+  }
+  return state[loader.__id] ||= createRouteLoaderSignal(loader, routeLoaderCtx, state);
+};
+const ensureRouteLoaderSignals = (mods, state, routeLoaderCtx) => {
+  const loaders = getModuleRouteLoaders(mods);
+  for (let i = 0; i < loaders.length; i++) {
+    const loader = loaders[i];
+    if (isDev && !isServer$1) {
+      const devCtx = routeLoaderCtx;
+      if (devCtx.pagePathname && !devCtx.devRouteLoaderPaths?.[loader.__id]) {
+        devCtx.loaderPaths[loader.__id] = devCtx.pagePathname;
+      }
+    }
+    ensureRouteLoaderSignal(loader, state, routeLoaderCtx);
+  }
+  return loaders;
+};
+const loadRouteLoader = (loader, requestEv) => {
+  const loaderEv = getLoaderRequestEvent(loader, requestEv);
+  return loadRouteLoaderByQrl(
+    loader.__id,
+    loader.__qrl,
+    loader.__validators,
+    // A background (blockSSR:false) loader must not touch the page response.
+    loader.__blockSSR ? loaderEv : detachResponseFromEvent(loaderEv)
+  );
+};
+const getRouteLoaderResponse = async (loaderQrl, validators, requestEv) => {
+  try {
+    const value = await getRouteLoaderData(loaderQrl, validators, requestEv);
+    return {
+      d: value
+    };
+  } catch (err) {
+    if (err instanceof RedirectMessage) {
+      const location1 = requestEv.headers.get("Location") || "/";
+      requestEv.headers.delete("Location");
+      return {
+        r: location1
+      };
+    }
+    if (err instanceof ServerError) {
+      return {
+        e: err
+      };
+    }
+    throw err;
+  }
+};
+const routeLoaderQrl = (loaderQrl, ...rest) => {
+  const { id, validators, serializationStrategy, cacheControl, eTag, cacheKey, search, blockSSR } = getLoaderOptions(rest);
+  function loader() {
+    const state = _resolveContextWithoutSequentialScope(RouteStateContext);
+    let signal = state[loader.__id];
+    if (!signal) {
+      const routeLoaderCtx = _resolveContextWithoutSequentialScope(RouteLoaderCtxContext);
+      signal = ensureRouteLoaderSignal(loader, state, routeLoaderCtx);
+    }
+    void signal.promise();
+    return signal;
+  }
+  loader.__brand = "server_loader";
+  loader.__qrl = loaderQrl;
+  loader.__validators = validators;
+  loader.__id = id ?? loaderQrl.getHash();
+  loader.__serializationStrategy = serializationStrategy;
+  loader.__cacheControl = cacheControl;
+  loader.__eTag = eTag;
+  loader.__cacheKey = cacheKey;
+  loader.__search = search;
+  loader.__blockSSR = blockSSR;
+  Object.freeze(loader);
+  return loader;
+};
+const routeLoader$ = /* @__PURE__ */ implicit$FirstArg(routeLoaderQrl);
+
 const toPath = (url) => url.pathname + url.search + url.hash;
 const toUrl = (url, baseUrl) => new URL(url, baseUrl.href);
 const isSameOrigin = (a, b) => a.origin === b.origin;
@@ -701,4 +1422,4 @@ const resolveHead = (actionData, loaderState, routeLocation, contentModules, loc
   return resolveRouteConfig(getData, routeLocation, contentModules, locale, actionData?.status ?? 200, defaults).head;
 };
 
-export { toUrl as a, isSameOrigin as b, createDocumentHead as c, resolveRouteConfig as d, isPromise as e, getClientNavPath as g, isSamePath as i, loadRoute as l, resolveHead as r, shouldPreload as s, toPath as t };
+export { QFN_KEY as A, QDATA_KEY as B, ContentContext as C, DocumentHeadContext as D, routeLoader$ as E, FULLPATH_HEADER as F, routeLoaderQrl as G, HttpStatusContext as H, getRouteLoaders as I, getRouteLoaderValues as J, loadRouteLoader as K, isPromise as L, getLoaderRequestEvent as M, resolveRouteLoaderByHash as N, getRouteLoaderResponse as O, getRouteLoaderCtx as P, QACTION_KEY as Q, ROUTE_PATH_HEADER as R, setRouteLoaders as S, resolveRouteConfig as T, clearRouteLoaderData as U, matchesRouteLoaderId as V, _asyncRequestStore as _, getClientNavPath as a, isSameOrigin as b, setLoaderSignalValue as c, createDocumentHead as d, ensureRouteLoaderSignals as e, fetchRouteLoaderData as f, getModuleRouteLoaders as g, ContentInternalContext as h, isSamePath as i, RouteLocationContext as j, RouteNavigateContext as k, loadRoute as l, RouteStateContext as m, RouteLoaderCtxContext as n, RouteActionContext as o, RoutePreventNavigateContext as p, invalidateNavRouteLoaders as q, isImmutableLoader as r, shouldPreload as s, toPath as t, updateRouteLoaderPaths as u, clearNavFetchCache as v, resolveHead as w, Q_ROUTE as x, toUrl as y, getRequestEvent as z };