@qwik.dev/router 2.0.0-beta.36 → 2.0.0-beta.38

package/lib/chunks/head.qwik.mjs

@@ -0,0 +1,1425 @@
+import { e as ensureSlash } from './pathname.mjs';
+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, _markSignalAsExternallyOwned, _deserialize, 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');
+function walkTrieKeys(root, keys) {
+  let node = root;
+  const layouts = [];
+  if (node._L) {
+    layouts.push(node._L);
+  }
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    let next = node[key];
+    if (!next && node._M) {
+      for (let j = 0; j < node._M.length; j++) {
+        const group = node._M[j];
+        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
+  };
+}
+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];
+    if (g._L) {
+      layouts.push(g._L);
+    }
+    if (g._R && loaderHashes) {
+      loaderHashes.push(...g._R);
+      if (loaderPathsByHash) {
+        for (let i = 0; i < g._R.length; i++) {
+          const hash = g._R[i];
+          loaderPathsByHash[hash] = matchedPathname;
+        }
+      }
+    }
+    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;
+    }
+  }
+  if (node._L) {
+    layouts.push(node._L);
+  }
+  if (node._R && loaderHashes) {
+    loaderHashes.push(...node._R);
+    if (loaderPathsByHash) {
+      for (let i = 0; i < node._R.length; i++) {
+        const hash = node._R[i];
+        loaderPathsByHash[hash] = matchedPathname;
+      }
+    }
+  }
+  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;
+  }
+}
+function tryWildcardMatch(node, part, partLower, parts, partIndex) {
+  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);
+        return {
+          next,
+          routePart: `${pre}[${paramName}]${suf}`,
+          done: false,
+          kind: 1,
+          paramName,
+          paramValue: value
+        };
+      }
+    } else {
+      const paramName = next._P;
+      return {
+        next,
+        routePart: `[${paramName}]`,
+        done: false,
+        kind: 1,
+        paramName,
+        paramValue: part
+      };
+    }
+  }
+  next = node._A;
+  if (next) {
+    const paramName = next._P;
+    const restValue = parts.slice(partIndex).join("/");
+    return {
+      next,
+      routePart: `[...${paramName}]`,
+      done: true,
+      kind: 2,
+      paramName,
+      paramValue: restValue
+    };
+  }
+  return void 0;
+}
+function findChild(node, part, partLower, parts, partIndex) {
+  const exact = node[partLower];
+  if (exact) {
+    return {
+      next: exact,
+      groups: [],
+      routePart: part,
+      done: false,
+      kind: 0
+    };
+  }
+  if (node._M) {
+    for (let j = 0; j < node._M.length; j++) {
+      const group = node._M[j];
+      const groupResult = findChild(group, part, partLower, parts, partIndex);
+      if (groupResult) {
+        groupResult.groups.unshift(group);
+        return groupResult;
+      }
+    }
+  }
+  const wildcard = tryWildcardMatch(node, part, partLower, parts, partIndex);
+  if (wildcard) {
+    return {
+      ...wildcard,
+      groups: []
+    };
+  }
+  return void 0;
+}
+function descendGroups(node, hit) {
+  const value = hit(node);
+  if (value !== void 0) {
+    return {
+      value,
+      node,
+      groups: []
+    };
+  }
+  if (node._M) {
+    for (let j = 0; j < node._M.length; j++) {
+      const group = node._M[j];
+      const result = descendGroups(group, hit);
+      if (result) {
+        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);
+    const target = walkTrieKeys(root, keys);
+    if (!target) {
+      return void 0;
+    }
+    let targetNode = target.node;
+    const targetLayouts = target.layouts;
+    if (!targetNode._I && targetNode._G == null) {
+      const indexResult = findIndexNode(targetNode);
+      if (indexResult) {
+        for (let j = 0; j < indexResult.groups.length; j++) {
+          const g = indexResult.groups[j];
+          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) {
+  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;
+  }
+  const groupLayouts = [
+    ...layouts
+  ];
+  for (const g of r.groups) {
+    if (g._L) {
+      groupLayouts.push(g._L);
+    }
+  }
+  return {
+    v: r.value,
+    layouts: groupLayouts
+  };
+}
+function matchRouteTree(root = {}, pathname) {
+  let node = root;
+  const params = {};
+  const routeParts = [];
+  const layouts = [];
+  const loaderHashes = [];
+  const loaderPathsByHash = {};
+  const errorLoaderRef = {
+    v: void 0,
+    layouts: []
+  };
+  const notFoundLoaderRef = {
+    v: void 0,
+    layouts: []
+  };
+  const menuLoaderRef = {
+    v: void 0
+  };
+  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;
+  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 found = findChild(node, part, partLower, parts, i);
+    if (!found) {
+      matched = false;
+      break;
+    }
+    const restInfo = found.kind === 1 ? findRestNode(node) : void 0;
+    if (restInfo) {
+      restFallback = {
+        aNode: restInfo.next,
+        groups: restInfo.groups,
+        paramName: restInfo.next._P,
+        restValue: parts.slice(i).join("/"),
+        routeParts: [
+          ...routeParts
+        ],
+        params: {
+          ...params
+        },
+        layouts: [
+          ...layouts
+        ],
+        loaderPathsByHash: {
+          ...loaderPathsByHash
+        },
+        errorLoader: errorLoaderRef.v,
+        errorLayouts: errorLoaderRef.layouts,
+        notFoundLoader: notFoundLoaderRef.v,
+        notFoundLayouts: notFoundLoaderRef.layouts,
+        menuLoader: menuLoaderRef.v
+      };
+    }
+    if (found.paramName) {
+      params[found.paramName] = found.paramValue;
+    }
+    routeParts.push(found.routePart);
+    done = found.done;
+    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) {
+      const indexResult = findIndexNode(node);
+      if (indexResult) {
+        collectNodeMeta(indexResult.target, indexResult.groups, layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef, loaderHashes, loaderPathsByHash, pathname);
+        node = indexResult.target;
+      }
+    }
+    if (!node._I && node._G == null) {
+      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, loaderHashes, loaderPathsByHash, pathname);
+        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 fbLoaderPathsByHash = {
+      ...fb.loaderPathsByHash
+    };
+    const fbErrorRef = {
+      v: fb.errorLoader,
+      layouts: fb.errorLayouts
+    };
+    const fbNotFoundRef = {
+      v: fb.notFoundLoader,
+      layouts: fb.notFoundLayouts
+    };
+    const fbMenuRef = {
+      v: fb.menuLoader
+    };
+    const fbLoaderHashes = [];
+    collectNodeMeta(fb.aNode, fb.groups, fbLayouts, fbErrorRef, fbNotFoundRef, fbMenuRef, fbLoaderHashes, fbLoaderPathsByHash, pathname);
+    const fbLoaders = resolveLoaders(root, fb.aNode, fbLayouts);
+    if (fbLoaders) {
+      return {
+        loaders: fbLoaders,
+        params: fbParams,
+        routeParts: fbRouteParts,
+        notFound: false,
+        routeBundleNames: fb.aNode._B,
+        loaderHashes: fbLoaderHashes.length > 0 ? fbLoaderHashes : void 0,
+        loaderPathsByHash: Object.keys(fbLoaderPathsByHash).length > 0 ? fbLoaderPathsByHash : void 0,
+        menuLoader: fbMenuRef.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 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: Array.isArray(boundary) ? boundary : [
+        ...boundaryLayouts,
+        boundary
+      ],
+      params,
+      routeParts,
+      notFound: true,
+      routeBundleNames: void 0,
+      loaderHashes: void 0,
+      loaderPathsByHash: void 0,
+      menuLoader: menuLoaderRef.v,
+      errorLoader: boundaryChain(errorLoaderRef)
+    };
+  }
+  if (node._R) {
+    loaderHashes.push(...node._R);
+    const matchedPathname = ensureSlash(pathname);
+    for (let i2 = 0; i2 < node._R.length; i2++) {
+      const hash = node._R[i2];
+      loaderPathsByHash[hash] = matchedPathname;
+    }
+  }
+  return {
+    loaders,
+    params,
+    routeParts,
+    notFound: false,
+    routeBundleNames: node._B,
+    loaderHashes: loaderHashes.length > 0 ? loaderHashes : void 0,
+    loaderPathsByHash: Object.keys(loaderPathsByHash).length > 0 ? loaderPathsByHash : void 0,
+    menuLoader: menuLoaderRef.v,
+    errorLoader: boundaryChain(errorLoaderRef)
+  };
+}
+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) => {
+  const result = matchRouteTree(routes, pathname);
+  const { loaders, params, routeParts, notFound, routeBundleNames, loaderHashes, loaderPathsByHash, menuLoader, errorLoader } = result;
+  const routeName = "/" + routeParts.join("/");
+  const modules = new Array(loaders.length);
+  const pendingLoads = [];
+  for (let i = 0; i < loaders.length; i++) {
+    const moduleLoader = loaders[i];
+    loadModule(moduleLoader, pendingLoads, (routeModule) => modules[i] = routeModule, cacheModules);
+  }
+  let menu = void 0;
+  loadModule(menuLoader, pendingLoads, (menuModule) => menu = menuModule?.default, cacheModules);
+  if (pendingLoads.length > 0) {
+    await Promise.all(pendingLoads);
+  }
+  return {
+    $routeName$: routeName,
+    $params$: params,
+    $mods$: modules,
+    $menu$: deepFreeze(menu),
+    $routeBundleNames$: routeBundleNames,
+    $notFound$: notFound,
+    $errorLoader$: errorLoader,
+    $loaders$: loaderHashes,
+    $loaderPaths$: loaderPathsByHash
+  };
+};
+
+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_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 LOADER_FETCH_CACHE_TTL = 5e3;
+const LOADER_FETCH_CACHE_MAX = 128;
+const fetchCache = /* @__PURE__ */ new Map();
+const perfNow = () => globalThis.performance?.now() ?? Date.now();
+const isRedirectStatus = (status) => status >= 300 && status < 400;
+const setCache = (key, entry) => {
+  fetchCache.set(key, entry);
+  if (fetchCache.size > LOADER_FETCH_CACHE_MAX) {
+    const oldestKey = fetchCache.keys().next().value;
+    if (oldestKey !== void 0) {
+      fetchCache.delete(oldestKey);
+    }
+  }
+};
+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 = fetchCache.get(cacheKey);
+    if (entry) {
+      if (entry.promise) {
+        return opts?.signal ? wrapWithAbort(entry.promise, opts.signal) : entry.promise;
+      }
+      if (entry.expires > perfNow()) {
+        return entry.value;
+      }
+      fetchCache.delete(cacheKey);
+    }
+  }
+  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;
+    }
+    const text = await response.text();
+    return await _deserialize(text) ?? void 0;
+  };
+  if (opts?.ignoreCache) {
+    return request();
+  }
+  if (opts?.signal) {
+    return request().then((value) => {
+      if (value !== void 0 && !fetchCache.has(cacheKey)) {
+        setCache(cacheKey, {
+          value,
+          expires: perfNow() + LOADER_FETCH_CACHE_TTL
+        });
+      }
+      return value;
+    });
+  }
+  const promise = request().then((value) => {
+    if (value === void 0) {
+      fetchCache.delete(cacheKey);
+    } else {
+      setCache(cacheKey, {
+        value,
+        expires: perfNow() + LOADER_FETCH_CACHE_TTL
+      });
+    }
+    return value;
+  }, (err) => {
+    fetchCache.delete(cacheKey);
+    throw err;
+  });
+  setCache(cacheKey, {
+    promise,
+    expires: perfNow() + LOADER_FETCH_CACHE_TTL
+  });
+  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 expires;
+  let poll;
+  let eTag;
+  let cacheKey;
+  let search;
+  let allowStale = true;
+  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 ("expires" in options) {
+          expires = options.expires;
+        }
+        if ("poll" in options) {
+          poll = options.poll;
+        }
+        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.allowStale === false) {
+          allowStale = false;
+        }
+        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,
+    expires,
+    poll,
+    eTag,
+    cacheKey,
+    search,
+    allowStale,
+    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 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 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;
+    loaderRequestEv = Object.create(rootRequestEv, {
+      pathname: {
+        get: () => url.pathname,
+        enumerable: true
+      },
+      query: {
+        get: () => url.searchParams,
+        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;
+      }
+      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) {
+      const filteredSearch = filterSearchParams(pageUrl.searchParams, searchFilter2);
+      if (ctx.previous !== void 0 && filteredSearch === lastFetch2.filteredSearch && fetchRoutePath === lastFetch2.routePath) {
+        return ctx.previous;
+      }
+      lastFetch2.filteredSearch = filteredSearch;
+      lastFetch2.routePath = fetchRoutePath;
+      fetchUrl = new URL(pageUrl.href);
+      fetchUrl.search = filteredSearch;
+    }
+    const response = await fetchRouteLoaderData(id2, fetchRoutePath, mHash, {
+      pageUrl: fetchUrl,
+      basePath,
+      ignoreCache: ctx.info === true,
+      signal: ctx.abortSignal
+    });
+    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;
+    }
+    if (needsResumeFetch) {
+      stateValues2[resumeValueKey2] = response.d;
+    }
+    return response.d;
+  }, "createRouteLoaderSignal_signal_createComputed_4s4ZDCYhDOA", [
+    capture,
+    id,
+    lastFetch,
+    resumeValueKey,
+    routeLoaderCtx,
+    searchFilter,
+    stateValues
+  ]), {
+    serializationStrategy: loader.__serializationStrategy,
+    expires: loader.__expires,
+    poll: loader.__poll,
+    allowStale: loader.__allowStale
+  });
+  _markSignalAsExternallyOwned(signal);
+  return signal;
+};
+const ensureRouteLoaderSignal = (loader, state, routeLoaderCtx) => {
+  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, expires, poll, eTag, cacheKey, search, allowStale, 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.__expires = expires ?? 12e4;
+  loader.__poll = poll ?? false;
+  loader.__eTag = eTag;
+  loader.__cacheKey = cacheKey;
+  loader.__search = search;
+  loader.__allowStale = allowStale;
+  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;
+const isSamePathname = ({ pathname: a }, { pathname: b }) => {
+  const lDiff = Math.abs(a.length - b.length);
+  return lDiff === 0 ? a === b : lDiff === 1 && ensureSlash(a) === ensureSlash(b);
+};
+const isSameSearchQuery = (a, b) => a.search === b.search;
+const isSamePath = (a, b) => isSameSearchQuery(a, b) && isSamePathname(a, b);
+const getClientNavPath = (props, baseUrl) => {
+  const href = props.href;
+  if (typeof href === "string" && typeof props.target !== "string" && !props.reload) {
+    try {
+      const linkUrl = toUrl(href.trim(), baseUrl.url);
+      const currentUrl = toUrl("", baseUrl.url);
+      if (isSameOrigin(linkUrl, currentUrl)) {
+        return toPath(linkUrl);
+      }
+    } catch (e) {
+      console.error(e);
+    }
+  } else if (props.reload) {
+    return toPath(toUrl("", baseUrl.url));
+  }
+  return null;
+};
+const shouldPreload = (clientNavPath, currentLoc) => {
+  if (clientNavPath) {
+    const prefetchUrl = toUrl(clientNavPath, currentLoc.url);
+    const currentUrl = toUrl("", currentLoc.url);
+    return !isSamePathname(prefetchUrl, currentUrl);
+  }
+  return false;
+};
+const isPromise = (value) => {
+  return value && typeof value.then === "function";
+};
+
+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, manifestHash) => ({
+  title: defaults?.title || "",
+  meta: [
+    ...defaults?.meta || []
+  ],
+  links: [
+    ...defaults?.links || []
+  ],
+  styles: [
+    ...defaults?.styles || []
+  ],
+  scripts: [
+    ...defaults?.scripts || []
+  ],
+  frontmatter: {
+    ...defaults?.frontmatter
+  },
+  manifestHash: manifestHash || "dev"
+});
+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 resolveHead = (actionData, loaderState, routeLocation, contentModules, locale, defaults) => {
+  const getData = (loaderOrAction) => {
+    const id = loaderOrAction.__id;
+    const signal = loaderState?.[id];
+    if (signal) {
+      return signal.value;
+    }
+    if (actionData?.action === id) {
+      return actionData.actionResult;
+    }
+    return void 0;
+  };
+  return resolveRouteConfig(getData, routeLocation, contentModules, locale, actionData?.status ?? 200, defaults).head;
+};
+
+export { getRouteLoaders as A, getRouteLoaderValues as B, ContentContext as C, DocumentHeadContext as D, loadRouteLoader as E, FULLPATH_HEADER as F, isPromise as G, HttpStatusContext as H, getLoaderRequestEvent as I, resolveRouteLoaderByHash as J, getRouteLoaderResponse as K, getRouteLoaderCtx as L, setRouteLoaders as M, resolveRouteConfig as N, matchesRouteLoaderId as O, QACTION_KEY as Q, ROUTE_PATH_HEADER as R, _asyncRequestStore as _, isSameOrigin as a, setLoaderSignalValue as b, createDocumentHead as c, ContentInternalContext as d, ensureRouteLoaderSignals as e, fetchRouteLoaderData as f, getClientNavPath as g, RouteLocationContext as h, isSamePath as i, RouteNavigateContext as j, RouteStateContext as k, loadRoute as l, RouteLoaderCtxContext as m, RouteActionContext as n, RoutePreventNavigateContext as o, Q_ROUTE as p, toUrl as q, resolveHead as r, shouldPreload as s, toPath as t, updateRouteLoaderPaths as u, getRequestEvent as v, QFN_KEY as w, QDATA_KEY as x, routeLoader$ as y, routeLoaderQrl as z };