@qwik.dev/router 2.0.0-beta.28 → 2.0.0-beta.29

package/lib/chunks/routing.qwik.mjs

@@ -1,7 +1,6 @@
-import { createAsync$, isBrowser } from '@qwik.dev/core';
-import { p } from '@qwik.dev/core/preloader';
+import { createAsyncQrl, inlinedQrl, _captures, isBrowser, withLocale } from '@qwik.dev/core';
 import { _deserialize, _UNINITIALIZED } from '@qwik.dev/core/internal';
-import { R as RouteDataProp, M as MenuDataProp } from './types.qwik.mjs';
+import { p } from '@qwik.dev/core/preloader';
 
 const MODULE_CACHE = /* @__PURE__ */ new WeakMap();
 const CLIENT_DATA_CACHE = /* @__PURE__ */ new Map();
@@ -13,6 +12,35 @@ 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;
@@ -64,7 +92,10 @@ const loadClientData = async (url, opts, retryCount = 0) => {
             const { action } = opts;
             const actionData = clientData.loaders[action.id];
             resolveFn = () => {
-              action.resolve({ status: rsp.status, result: actionData });
+              action.resolve({
+                status: rsp.status,
+                result: actionData
+              });
             };
           }
           return clientData;
@@ -88,35 +119,6 @@ const loadClientData = async (url, opts, retryCount = 0) => {
     return v;
   });
 };
-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 toPath = (url) => url.pathname + url.search + url.hash;
 const toUrl = (url, baseUrl) => new URL(url, baseUrl.href);
@@ -169,23 +171,35 @@ const isPromise = (value) => {
   return value && typeof value.then === "function";
 };
 const createLoaderSignal = (loadersObject, loaderId, url, serializationStrategy, container) => {
-  return createAsync$(
-    async () => {
-      if (isBrowser && loadersObject[loaderId] === _UNINITIALIZED) {
-        const data = await loadClientData(url, {
-          loaderIds: [loaderId]
-        });
-        loadersObject[loaderId] = data?.loaders[loaderId] ?? _UNINITIALIZED;
-      }
-      return loadersObject[loaderId];
-    },
-    {
-      container,
-      serializationStrategy
+  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);
@@ -202,14 +216,6 @@ const clientNavigate = (win, navType, fromURL, toURL, replaceState = false) => {
     }
   }
 };
-const newScrollState = () => {
-  return {
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0
-  };
-};
 const preloadRouteBundles = (path, probability = 0.8) => {
   if (isBrowser) {
     path = path.endsWith("/") ? path : path + "/";
@@ -218,127 +224,157 @@ const preloadRouteBundles = (path, probability = 0.8) => {
   }
 };
 
-function matchRoute(route, path) {
-  const routeIdx = startIdxSkipSlash(route);
-  const routeLength = lengthNoTrailingSlash(route);
-  const pathIdx = startIdxSkipSlash(path);
-  const pathLength = lengthNoTrailingSlash(path);
-  return matchRoutePart(route, routeIdx, routeLength, path, pathIdx, pathLength);
-}
-function matchRoutePart(route, routeIdx, routeLength, path, pathIdx, pathLength) {
-  if (path.startsWith("/build/")) {
-    return null;
-  }
-  let params = null;
-  while (routeIdx < routeLength) {
-    const routeCh = route.charCodeAt(routeIdx++);
-    const pathCh = path.charCodeAt(pathIdx++);
-    if (routeCh === 91 /* OPEN_BRACKET */) {
-      const isMany = isThreeDots(route, routeIdx);
-      const paramNameStart = routeIdx + (isMany ? 3 : 0);
-      const paramNameEnd = scan(route, paramNameStart, routeLength, 93 /* CLOSE_BRACKET */);
-      const paramName = route.substring(paramNameStart, paramNameEnd);
-      const paramSuffixEnd = scan(route, paramNameEnd + 1, routeLength, 47 /* SLASH */);
-      const suffix = route.substring(paramNameEnd + 1, paramSuffixEnd);
-      routeIdx = paramNameEnd + 1;
-      const paramValueStart = pathIdx - 1;
-      if (isMany) {
-        const match = recursiveScan(
-          paramName,
-          suffix,
-          path,
-          paramValueStart,
-          pathLength,
-          route,
-          routeIdx + suffix.length + 1,
-          routeLength
-        );
-        if (match) {
-          return Object.assign(params || (params = {}), match);
+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;
         }
       }
-      const paramValueEnd = scan(path, paramValueStart, pathLength, 47 /* SLASH */, suffix);
-      if (paramValueEnd == -1) {
-        return null;
-      }
-      const paramValue = path.substring(paramValueStart, paramValueEnd);
-      if (!isMany && !suffix && !paramValue) {
-        return null;
-      }
-      pathIdx = paramValueEnd;
-      (params || (params = {}))[paramName] = decodeURIComponent(paramValue);
-    } else if (routeCh !== pathCh) {
-      if (!(isNaN(pathCh) && isRestParameter(route, routeIdx))) {
-        return null;
-      }
+      existingArr.push(newItem);
     }
   }
-  if (allConsumed(route, routeIdx) && allConsumed(path, pathIdx)) {
-    return params || {};
-  } else {
-    return null;
+};
+const resolveDocumentHead = (resolvedHead, updatedHead) => {
+  if (typeof updatedHead.title === "string") {
+    resolvedHead.title = updatedHead.title;
   }
-}
-function isRestParameter(text, idx) {
-  return text.charCodeAt(idx) === 91 /* OPEN_BRACKET */ && isThreeDots(text, idx + 1);
-}
-function lengthNoTrailingSlash(text) {
-  const length = text.length;
-  return length > 1 && text.charCodeAt(length - 1) === 47 /* SLASH */ ? length - 1 : length;
-}
-function allConsumed(text, idx) {
-  const length = text.length;
-  return idx >= length || idx == length - 1 && text.charCodeAt(idx) === 47 /* SLASH */;
-}
-function startIdxSkipSlash(text) {
-  return text.charCodeAt(0) === 47 /* SLASH */ ? 1 : 0;
-}
-function isThreeDots(text, idx) {
-  return text.charCodeAt(idx) === 46 /* DOT */ && text.charCodeAt(idx + 1) === 46 /* DOT */ && text.charCodeAt(idx + 2) === 46 /* DOT */;
-}
-function scan(text, idx, end, ch, suffix = "") {
-  while (idx < end && text.charCodeAt(idx) !== ch) {
-    idx++;
+  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 suffixLength = suffix.length;
-  for (let i = 0; i < suffixLength; i++) {
-    if (text.charCodeAt(idx - suffixLength + i) !== suffix.charCodeAt(i)) {
-      return -1;
+});
+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;
     }
-  }
-  return idx - suffixLength;
-}
-function recursiveScan(paramName, suffix, path, pathStart, pathLength, route, routeStart, routeLength) {
-  if (path.charCodeAt(pathStart) === 47 /* SLASH */) {
-    pathStart++;
-  }
-  let pathIdx = pathLength;
-  const sep = suffix + "/";
-  while (pathIdx >= pathStart) {
-    const match = matchRoutePart(route, routeStart, routeLength, path, pathIdx, pathLength);
-    if (match) {
-      let value = path.substring(pathStart, Math.min(pathIdx, pathLength));
-      if (value.endsWith(sep)) {
-        value = value.substring(0, value.length - sep.length);
+    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
+        };
       }
-      match[paramName] = decodeURIComponent(value);
-      return match;
     }
-    const newPathIdx = lastIndexOf(path, pathStart, sep, pathIdx, pathStart - 1) + sep.length;
-    if (pathIdx === newPathIdx) {
-      break;
+    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;
+      }
     }
-    pathIdx = newPathIdx;
   }
-  return null;
-}
-function lastIndexOf(text, start, match, searchIdx, notFoundIdx) {
-  let idx = text.lastIndexOf(match, searchIdx);
-  if (idx == searchIdx - match.length) {
-    idx = text.lastIndexOf(match, searchIdx - match.length - 1);
+  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 idx > start ? idx : notFoundIdx;
-}
+  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 deepFreeze = (obj) => {
   if (obj == null) {
@@ -357,45 +393,350 @@ const deepFreeze = (obj) => {
   return Object.freeze(obj);
 };
 
-const loadRoute = async (routes, menus, cacheModules, pathname, isInternal) => {
-  if (!Array.isArray(routes)) {
-    return null;
-  }
-  for (const routeData of routes) {
-    const routeName = routeData[RouteDataProp.RouteName];
-    const params = matchRoute(routeName, pathname);
-    if (!params) {
-      continue;
+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) {
+    const next = node[key];
+    if (!next) {
+      return void 0;
     }
-    const moduleLoaders = routeData[RouteDataProp.ModuleLoaders];
-    const routeBundleNames = routeData[RouteDataProp.RouteBundleNames];
-    const modules = new Array(moduleLoaders.length);
-    const pendingLoads = [];
-    moduleLoaders.forEach((moduleLoader, i) => {
-      loadModule(
-        moduleLoader,
-        pendingLoads,
-        (routeModule) => modules[i] = routeModule,
-        cacheModules
-      );
-    });
-    let menu = void 0;
-    if (!isInternal) {
-      const menuLoader = getMenuLoader(menus, pathname);
-      loadModule(
-        menuLoader,
-        pendingLoads,
-        (menuModule) => menu = menuModule?.default,
-        cacheModules
-      );
+    node = next;
+    if (node._L) {
+      layouts.push(node._L);
     }
-    if (pendingLoads.length > 0) {
-      await Promise.all(pendingLoads);
+  }
+  return {
+    node,
+    layouts
+  };
+}
+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;
     }
-    return [routeName, params, modules, deepFreeze(menu), routeBundleNames];
+    return resolveLoaders(root, target.node, target.layouts);
   }
-  return null;
-};
+  const index = node._I;
+  if (!index) {
+    return void 0;
+  }
+  if (Array.isArray(index)) {
+    return index;
+  }
+  return [
+    ...gatheredLayouts,
+    index
+  ];
+}
+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 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);
@@ -404,30 +745,65 @@ const loadModule = (moduleLoader, pendingLoads, moduleSetter, cacheModules) => {
     } else {
       const moduleOrPromise = moduleLoader();
       if (typeof moduleOrPromise.then === "function") {
-        pendingLoads.push(
-          moduleOrPromise.then((loadedModule2) => {
-            if (cacheModules !== false) {
-              MODULE_CACHE.set(moduleLoader, loadedModule2);
-            }
-            moduleSetter(loadedModule2);
-          })
-        );
+        pendingLoads.push(moduleOrPromise.then((loadedModule2) => {
+          if (cacheModules !== false) {
+            MODULE_CACHE.set(moduleLoader, loadedModule2);
+          }
+          moduleSetter(loadedModule2);
+        }));
       } else if (moduleOrPromise) {
         moduleSetter(moduleOrPromise);
       }
     }
   }
 };
-const getMenuLoader = (menus, pathname) => {
-  if (menus) {
-    pathname = pathname.endsWith("/") ? pathname : pathname + "/";
-    const menu = menus.find(
-      (m) => m[MenuDataProp.Pathname] === pathname || pathname.startsWith(m[MenuDataProp.Pathname])
-    );
-    if (menu) {
-      return menu[MenuDataProp.MenuLoader];
+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, isSamePath as a, isSameOrigin as b, createLoaderSignal as c, loadRoute as d, clientNavigate as e, QFN_KEY as f, getClientNavPath as g, QACTION_KEY as h, isPromise as i, QDATA_KEY as j, QLOADER_KEY as k, loadClientData as l, preloadRouteBundles as p, shouldPreload as s, toUrl as t };
+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, loadRoute as d, clientNavigate as e, QFN_KEY as f, getClientNavPath as g, QACTION_KEY as h, isSamePath as i, QDATA_KEY as j, isPromise as k, loadClientData as l, QLOADER_KEY as m, resolveRouteConfig as n, preloadRouteBundles as p, resolveHead as r, shouldPreload as s, toUrl as t };