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

package/lib/chunks/routing.qwik.mjs

@@ -0,0 +1,820 @@
+import { createAsyncQrl, inlinedQrl, _captures, isBrowser, withLocale } from '@qwik.dev/core';
+import { _deserialize, _UNINITIALIZED } from '@qwik.dev/core/internal';
+import { p } from '@qwik.dev/core/preloader';
+import { d as deepFreeze } from './deepFreeze.qwik.mjs';
+
+const CLIENT_DATA_CACHE = /* @__PURE__ */ new Map();
+const QACTION_KEY = "qaction";
+const QLOADER_KEY = "qloaders";
+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 MAX_Q_DATA_RETRY_COUNT = 3;
+const getFetchOptions = (action, noCache) => {
+  const actionData = action?.data;
+  if (!actionData) {
+    if (noCache) {
+      return {
+        cache: "no-cache",
+        headers: {
+          "Cache-Control": "no-cache",
+          Pragma: "no-cache"
+        }
+      };
+    }
+    return void 0;
+  }
+  if (actionData instanceof FormData) {
+    return {
+      method: "POST",
+      body: actionData
+    };
+  } else {
+    return {
+      method: "POST",
+      body: JSON.stringify(actionData),
+      headers: {
+        "Content-Type": "application/json; charset=UTF-8"
+      }
+    };
+  }
+};
+const loadClientData = async (url, opts, retryCount = 0) => {
+  const pagePathname = url.pathname;
+  const pageSearch = url.search;
+  const clientDataPath = getClientDataPath(pagePathname, pageSearch, {
+    actionId: opts?.action?.id,
+    loaderIds: opts?.loaderIds
+  });
+  let qData;
+  if (!opts?.action) {
+    qData = CLIENT_DATA_CACHE.get(clientDataPath);
+  }
+  if (opts?.preloadRouteBundles !== false) {
+    preloadRouteBundles(pagePathname, 0.8);
+  }
+  let resolveFn;
+  if (!qData) {
+    const fetchOptions = getFetchOptions(opts?.action, opts?.clearCache);
+    if (opts?.action) {
+      opts.action.data = void 0;
+    }
+    qData = fetch(clientDataPath, fetchOptions).then((rsp) => {
+      if (rsp.status === 404 && opts?.loaderIds && retryCount < MAX_Q_DATA_RETRY_COUNT) {
+        opts.loaderIds = void 0;
+        return loadClientData(url, opts, retryCount + 1);
+      }
+      if (rsp.redirected) {
+        const redirectedURL = new URL(rsp.url);
+        const isQData = redirectedURL.pathname.endsWith("/q-data.json");
+        if (!isQData || redirectedURL.origin !== location.origin) {
+          if (!opts?.isPrefetch) {
+            location.href = redirectedURL.href;
+          }
+          return;
+        }
+      }
+      if ((rsp.headers.get("content-type") || "").includes("json")) {
+        return rsp.text().then((text) => {
+          const clientData = _deserialize(text);
+          if (!clientData) {
+            location.href = url.href;
+            return;
+          }
+          if (opts?.clearCache) {
+            CLIENT_DATA_CACHE.delete(clientDataPath);
+          }
+          if (clientData.redirect) {
+            location.href = clientData.redirect;
+          } else if (opts?.action) {
+            const { action } = opts;
+            const actionData = clientData.loaders[action.id];
+            resolveFn = () => {
+              action.resolve({
+                status: rsp.status,
+                result: actionData
+              });
+            };
+          }
+          return clientData;
+        });
+      } else {
+        if (opts?.isPrefetch !== true) {
+          location.href = url.href;
+        }
+        return void 0;
+      }
+    });
+    if (!opts?.action) {
+      CLIENT_DATA_CACHE.set(clientDataPath, qData);
+    }
+  }
+  return qData.then((v) => {
+    if (!v) {
+      CLIENT_DATA_CACHE.delete(clientDataPath);
+    }
+    resolveFn && resolveFn();
+    return v;
+  });
+};
+
+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 withSlash = (path) => path.endsWith("/") ? path : path + "/";
+const isSamePathname = ({ pathname: a }, { pathname: b }) => {
+  const lDiff = Math.abs(a.length - b.length);
+  return lDiff === 0 ? a === b : lDiff === 1 && withSlash(a) === withSlash(b);
+};
+const isSameSearchQuery = (a, b) => a.search === b.search;
+const isSamePath = (a, b) => isSameSearchQuery(a, b) && isSamePathname(a, b);
+const getClientDataPath = (pathname, pageSearch, options) => {
+  let search = pageSearch ?? "";
+  if (options?.actionId) {
+    search += (search ? "&" : "?") + QACTION_KEY + "=" + encodeURIComponent(options.actionId);
+  }
+  if (options?.loaderIds) {
+    for (const loaderId of options.loaderIds) {
+      search += (search ? "&" : "?") + QLOADER_KEY + "=" + encodeURIComponent(loaderId);
+    }
+  }
+  return pathname + (pathname.endsWith("/") ? "" : "/") + "q-data.json" + search;
+};
+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 createLoaderSignal = (loadersObject, loaderId, url, serializationStrategy, container) => {
+  return createAsyncQrl(/* @__PURE__ */ inlinedQrl(async () => {
+    const loaderId2 = _captures[0], loadersObject2 = _captures[1], url2 = _captures[2];
+    if (isBrowser && loadersObject2[loaderId2] === _UNINITIALIZED) {
+      const data = await loadClientData(url2, {
+        loaderIds: [
+          loaderId2
+        ]
+      });
+      loadersObject2[loaderId2] = data?.loaders[loaderId2] ?? _UNINITIALIZED;
+    }
+    return loadersObject2[loaderId2];
+  }, "createLoaderSignal_createAsync_CFLMoh8rnzw", [
+    loaderId,
+    loadersObject,
+    url
+  ]), {
+    container,
+    serializationStrategy
+  });
+};
+
+const newScrollState = () => {
+  return {
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0
+  };
+};
+const clientNavigate = (win, navType, fromURL, toURL, replaceState = false) => {
+  if (navType !== "popstate") {
+    const samePath = isSamePath(fromURL, toURL);
+    const sameHash = fromURL.hash === toURL.hash;
+    if (!samePath || !sameHash) {
+      const newState = {
+        _qRouterScroll: newScrollState()
+      };
+      if (replaceState) {
+        win.history.replaceState(newState, "", toPath(toURL));
+      } else {
+        win.history.pushState(newState, "", toPath(toURL));
+      }
+    }
+  }
+};
+const preloadRouteBundles = (path, probability = 0.8) => {
+  if (isBrowser) {
+    path = path.endsWith("/") ? path : path + "/";
+    path = path.length > 1 && path.startsWith("/") ? path.slice(1) : path;
+    p(path, probability);
+  }
+};
+
+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 resolveHead = (endpoint, routeLocation, contentModules, locale, defaults) => {
+  const getData = (loaderOrAction) => {
+    const id = loaderOrAction.__id;
+    if (loaderOrAction.__brand === "server_loader") {
+      if (!(id in endpoint.loaders)) {
+        throw new Error("You can not get the returned data of a loader that has not been executed for this request.");
+      }
+    }
+    const data = endpoint.loaders[id];
+    if (isPromise(data)) {
+      throw new Error("Loaders returning a promise can not be resolved for the head function.");
+    }
+    return data;
+  };
+  return resolveRouteConfig(getData, routeLocation, contentModules, locale, endpoint.status, defaults).head;
+};
+
+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
+  };
+};
+
+export { CLIENT_DATA_CACHE as C, DEFAULT_LOADERS_SERIALIZATION_STRATEGY as D, Q_ROUTE as Q, createDocumentHead as a, isSameOrigin as b, createLoaderSignal as c, clientNavigate as d, loadRoute as e, toPath as f, getClientNavPath as g, QFN_KEY as h, isSamePath as i, QACTION_KEY as j, QDATA_KEY as k, loadClientData as l, resolveRouteConfig as m, QLOADER_KEY as n, isPromise as o, preloadRouteBundles as p, resolveHead as r, shouldPreload as s, toUrl as t };