@superblocksteam/vite-plugin-file-sync 2.0.162 → 2.0.163-next.0

package/dist/router-parser.js

@@ -3,9 +3,18 @@ import { join, resolve, dirname, relative } from "node:path";
 import { parse } from "@babel/parser";
 import { findStaticImports, parseStaticImport } from "mlly";
 import { joinURL } from "ufo";
+import { isLocalModuleSpecifier } from "./parsing/imports.js";
 import { getFullImportPath } from "./resolver.js";
 import { traverse } from "./traverse.js";
 import { getLogger } from "./util/logger.js";
+export class MissingCreateBrowserRouterError extends Error {
+    routerFilePath;
+    constructor(routerFilePath) {
+        super("Could not find router file with createBrowserRouter in project");
+        this.routerFilePath = routerFilePath;
+        this.name = "MissingCreateBrowserRouterError";
+    }
+}
 function countRouteObjects(routes) {
     let count = 0;
     for (const element of routes.elements) {
@@ -23,11 +32,13 @@ function countRouteObjects(routes) {
     }
     return count;
 }
-const CONVENTIONAL_ROUTER_PATHS = [
+export const CONVENTIONAL_ROUTER_PATHS = [
     "router.tsx",
     "router.ts",
     "src/router.tsx",
     "src/router.ts",
+    "client/router.tsx",
+    "client/router.ts",
 ];
 let cachedRouterFileLocation = null;
 /**
@@ -132,7 +143,7 @@ function extractReactRouterImports(content) {
 /**
  * Check if content contains createBrowserRouter call, accounting for import aliases
  */
-function hasCreateBrowserRouter(content) {
+export function hasCreateBrowserRouter(content) {
     const { createBrowserRouterAliases, namespaceImports } = extractReactRouterImports(content);
     // Quick substring check first for performance
     if (!content.includes("createBrowserRouter") &&
@@ -249,7 +260,7 @@ export async function findRouterFile(rootDir) {
             cachedRouterFileLocation = null;
         }
     }
-    // Try conventional locations first
+    let routerWithoutCreateBrowserRouter;
     for (const conventionalPath of CONVENTIONAL_ROUTER_PATHS) {
         const fullPath = join(rootDir, conventionalPath);
         try {
@@ -261,13 +272,14 @@ export async function findRouterFile(rootDir) {
                 getLogger().info(`Found router file at: ${conventionalPath}`);
                 return fullPath;
             }
+            routerWithoutCreateBrowserRouter ??= fullPath;
         }
         catch {
             continue;
         }
     }
     // Fall back to scanning all TypeScript files in rootDir
-    getLogger().info("Router not found in conventional locations, scanning TypeScript files…");
+    getLogger().info("Router not found in conventional locations, scanning TypeScript files...");
     const allTsFiles = await findAllTsFiles(rootDir);
     for (const file of allTsFiles) {
         try {
@@ -283,17 +295,11 @@ export async function findRouterFile(rootDir) {
             continue;
         }
     }
+    if (routerWithoutCreateBrowserRouter) {
+        throw new MissingCreateBrowserRouterError(routerWithoutCreateBrowserRouter);
+    }
     throw new Error("Could not find router file with createBrowserRouter in project");
 }
-/**
- * True for project-relative or alias imports (./, ../, /, @/) — i.e. paths
- * we can resolve to a file in this repo. Filters out npm packages.
- */
-function isRelativeOrAliasImport(specifier) {
-    return (specifier.startsWith(".") ||
-        specifier.startsWith("/") ||
-        specifier.startsWith("@/"));
-}
 /**
  * Debug log emitted when `Component:` / `element:` references a value the
  * parser couldn't resolve to an import, usually because the user wrote a
@@ -418,7 +424,10 @@ function extractImportPathFromFunction(node, callableImportMap) {
     return extractImportSpecifierFromExpression(expr, callableImportMap);
 }
 /**
- * Extract the page import specifier from a `lazy:` route property value.
+ * Extract the page import specifier from a route loader expression: a `lazy:`
+ * property value, a top-level const initializer bound as a loader, or a
+ * spread argument (page-classified factory calls and unclassified spreads
+ * alike).
  *
  * Handles the direct arrow form the template ships with
  * (`lazy: () => import("...")`, `lazy: () => import("...").then(...)`), a plain
@@ -443,17 +452,11 @@ function extractImportPathFromFunction(node, callableImportMap) {
  * found wins. Every real/tested loader shape carries exactly one importer.
  */
 function extractImportPathFromLazyValue(node, callableImportMap, lazyLoaderBindings) {
+    node = unwrapTsWrappers(node);
     // `lazy: overview` — a const bound to a loader elsewhere in the file.
     if (node.type === "Identifier") {
         return lazyLoaderBindings?.get(node.name) ?? null;
     }
-    // See through TS type wrappers (`... as any`, `... satisfies T`, `...!`).
-    // They are transparent at runtime, so the importer lives on `.expression`.
-    if (node.type === "TSAsExpression" ||
-        node.type === "TSSatisfiesExpression" ||
-        node.type === "TSNonNullExpression") {
-        return extractImportPathFromLazyValue(node.expression, callableImportMap, lazyLoaderBindings);
-    }
     if (node.type === "ArrowFunctionExpression" ||
         node.type === "FunctionExpression") {
         return extractImportPathFromFunction(node, callableImportMap);
@@ -484,6 +487,200 @@ function extractImportPathFromLazyValue(node, callableImportMap, lazyLoaderBindi
     }
     return null;
 }
+/**
+ * The route-object keys that make a property (or spread contribution) the
+ * page source for a route, as opposed to loaders, handles, and other
+ * metadata.
+ */
+const ROUTE_PAGE_KEYS = new Set(["lazy", "Component", "element"]);
+/** Unwrap runtime-transparent TS wrappers (`as`, `satisfies`, `!`). */
+function unwrapTsWrappers(node) {
+    while (node.type === "TSAsExpression" ||
+        node.type === "TSSatisfiesExpression" ||
+        node.type === "TSNonNullExpression") {
+        node = node.expression;
+    }
+    return node;
+}
+/**
+ * Static key of an object member: identifier (`lazy:`) or string literal
+ * (`"lazy":`). Computed keys are not statically knowable and return null.
+ */
+function getStaticPropertyKey(prop) {
+    if (prop.key.type === "Identifier" && !prop.computed)
+        return prop.key.name;
+    if (prop.key.type === "StringLiteral")
+        return prop.key.value;
+    return null;
+}
+/** True when `p` is the Program, or an export declaration directly under it. */
+function isProgramLevel(p) {
+    if (!p)
+        return false;
+    return (p.isProgram() ||
+        (p.isExportNamedDeclaration() && (p.parentPath?.isProgram() ?? false)));
+}
+/**
+ * Classify what an object literal contributes when spread into a route:
+ * "page" when it carries a page key, "non-page" when its full key set is
+ * visible and carries none, "unknown" when an inner spread hides keys.
+ */
+function classifyRouteFragment(obj) {
+    let sawUnknowableKey = false;
+    for (const prop of obj.properties) {
+        if (prop.type === "SpreadElement") {
+            sawUnknowableKey = true;
+            continue;
+        }
+        const name = getStaticPropertyKey(prop);
+        if (name && ROUTE_PAGE_KEYS.has(name))
+            return "page";
+        // A computed dynamic key could be anything at runtime, so its absence
+        // from the static keys proves nothing.
+        if (!name && prop.computed)
+            sawUnknowableKey = true;
+    }
+    return sawUnknowableKey ? "unknown" : "non-page";
+}
+/**
+ * Classify a local factory by the object literal it returns. Only bodies
+ * made of straight-line statements are inspected; anything that could hide
+ * a return (conditionals, loops, try blocks) classifies as "unknown" so the
+ * caller falls back to the import heuristic instead of wrongly ruling the
+ * factory out. In a straight-line body only the first return is reachable,
+ * so it alone decides.
+ */
+function classifyLocalFactory(fn) {
+    if (fn.body.type !== "BlockStatement") {
+        const expr = unwrapTsWrappers(fn.body);
+        return expr.type === "ObjectExpression"
+            ? { shape: classifyRouteFragment(expr), fragment: expr }
+            : { shape: "unknown", fragment: null };
+    }
+    for (const statement of fn.body.body) {
+        if (statement.type === "ReturnStatement") {
+            const arg = statement.argument
+                ? unwrapTsWrappers(statement.argument)
+                : null;
+            return arg?.type === "ObjectExpression"
+                ? { shape: classifyRouteFragment(arg), fragment: arg }
+                : { shape: "unknown", fragment: null };
+        }
+        if (statement.type !== "VariableDeclaration" &&
+            statement.type !== "ExpressionStatement") {
+            return { shape: "unknown", fragment: null };
+        }
+    }
+    return { shape: "unknown", fragment: null };
+}
+/**
+ * Extract the page import from an object literal spread into a route
+ * (`...{ lazy: () => import("...") }` or a const bound to one). Later page
+ * keys override earlier ones, matching runtime object semantics. Broader
+ * than the explicit-property loop by design: classifyRouteFragment counts
+ * method shorthand and string-literal keys as page-bearing, so extraction
+ * must recognize the same shapes or a "page" fragment would silently
+ * extract nothing.
+ */
+function extractPageImportFromFragment(fragment, allImports, callableImportMap, lazyLoaderBindings) {
+    let importPath = null;
+    for (const prop of fragment.properties) {
+        if (prop.type === "SpreadElement")
+            continue;
+        const key = getStaticPropertyKey(prop);
+        if (!key || !ROUTE_PAGE_KEYS.has(key))
+            continue;
+        if (prop.type === "ObjectMethod") {
+            if (key === "lazy") {
+                const path = extractImportPathFromFunction(prop, callableImportMap);
+                if (path)
+                    importPath = path;
+            }
+            continue;
+        }
+        if (key === "lazy") {
+            const path = extractImportPathFromLazyValue(prop.value, callableImportMap, lazyLoaderBindings);
+            if (path)
+                importPath = path;
+        }
+        else if (key === "Component" && prop.value.type === "Identifier") {
+            importPath = allImports.get(prop.value.name) ?? importPath;
+        }
+        else if (key === "element") {
+            const path = resolveElementImportPath(prop.value, allImports);
+            if (path)
+                importPath = path;
+        }
+    }
+    return importPath;
+}
+/**
+ * Resolve what a route-object spread contributes to the route's page.
+ *
+ * "page": the spread verifiably carries a page key (an object literal, a
+ * const bound to one, or a local factory call, direct or through a const,
+ * whose return shape is inspectable); its import participates like an
+ * explicit property.
+ * "none": the spread verifiably carries no page key and must be ignored, so
+ * a loader-only helper's import is never mistaken for the page.
+ * "heuristic": the parser cannot classify the contribution (an imported
+ * factory, or an indirection it does not chase); the first import found in
+ * the expression is offered as a fallback for the caller to use only when
+ * nothing verified resolves.
+ */
+function resolveSpreadContribution(argument, allImports, callableImportMap, lazyLoaderBindings, spreadBindings) {
+    const unwrapped = unwrapTsWrappers(argument);
+    let fragment = null;
+    let factoryCallee = null;
+    if (unwrapped.type === "ObjectExpression") {
+        fragment = unwrapped;
+    }
+    else if (unwrapped.type === "Identifier") {
+        fragment = spreadBindings?.objectLiterals.get(unwrapped.name) ?? null;
+        if (!fragment) {
+            factoryCallee =
+                spreadBindings?.constFactoryCalls.get(unwrapped.name) ?? null;
+        }
+    }
+    else if (unwrapped.type === "CallExpression" &&
+        unwrapped.callee.type === "Identifier") {
+        factoryCallee = unwrapped.callee.name;
+    }
+    // An inferred page import must be a local module, matching the gate every
+    // other inference site in this file applies; a bare specifier inside a
+    // spread (analytics/i18n wrappers) is never the page.
+    const localOnly = (path) => path && isLocalModuleSpecifier(path) ? path : null;
+    if (fragment) {
+        const shape = classifyRouteFragment(fragment);
+        if (shape === "page") {
+            return {
+                kind: "page",
+                importPath: localOnly(extractPageImportFromFragment(fragment, allImports, callableImportMap, lazyLoaderBindings)),
+            };
+        }
+        if (shape === "non-page")
+            return { kind: "none" };
+        // "unknown": an inner spread hides keys; fall through to the heuristic.
+    }
+    else if (factoryCallee) {
+        const factory = spreadBindings?.factoryShapes.get(factoryCallee);
+        if (factory?.shape === "page") {
+            // The importer is usually passed in through the call's arguments; a
+            // zero-argument factory instead hardcodes it in the returned fragment.
+            const fromArguments = localOnly(extractImportPathFromLazyValue(argument, callableImportMap, lazyLoaderBindings));
+            const fromFragment = factory.fragment
+                ? localOnly(extractPageImportFromFragment(factory.fragment, allImports, callableImportMap, lazyLoaderBindings))
+                : null;
+            return { kind: "page", importPath: fromArguments ?? fromFragment };
+        }
+        if (factory?.shape === "non-page")
+            return { kind: "none" };
+    }
+    return {
+        kind: "heuristic",
+        importPath: localOnly(extractImportPathFromLazyValue(argument, callableImportMap, lazyLoaderBindings)),
+    };
+}
 /**
  * Recognize `lazy(() => import("..."))` / `React.lazy(() => import("..."))`
  * (arrow or plain `function () { return import("..."); }` importer) and return
@@ -527,7 +724,7 @@ function extractAllImports(content) {
         for (const staticImport of staticImports) {
             const parsed = parseStaticImport(staticImport);
             // Skip imports from node_modules and react-router
-            if (!isRelativeOrAliasImport(parsed.specifier)) {
+            if (!isLocalModuleSpecifier(parsed.specifier)) {
                 continue;
             }
             // Handle default imports: import Page1 from "./components/Page1.tsx"
@@ -587,47 +784,41 @@ export async function parseRouterFile(routerFilePath, rootDir, onDiagnostic) {
         // (Identifier) resolves. e.g. const overview = lazyPage(() => import("..."))
         // Maps loaderName → importPath.
         const lazyLoaderBindings = new Map();
+        // Bindings that let route-object spreads be classified statically:
+        // object-literal consts (`...homeRoute`) and local factories whose return
+        // shape says whether the spread contributes a page key (`...gatedLazy(...)`).
+        const spreadBindings = {
+            objectLiterals: new Map(),
+            factoryShapes: new Map(),
+            constFactoryCalls: new Map(),
+        };
         traverse(ast, {
+            FunctionDeclaration(astPath) {
+                const node = astPath.node;
+                if (!node.id)
+                    return;
+                if (isProgramLevel(astPath.parentPath) &&
+                    !spreadBindings.factoryShapes.has(node.id.name)) {
+                    spreadBindings.factoryShapes.set(node.id.name, classifyLocalFactory(node));
+                }
+            },
             VariableDeclarator(astPath) {
                 const node = astPath.node;
                 if (node.id.type !== "Identifier" || !node.init)
                     return;
-                if (node.init.type === "ArrayExpression") {
-                    variableDeclarations.set(node.id.name, node.init);
-                }
-                else if (node.init.type === "TSAsExpression" &&
-                    node.init.expression.type === "ArrayExpression") {
-                    variableDeclarations.set(node.id.name, node.init.expression);
-                }
-                else if (node.init.type === "TSSatisfiesExpression" &&
-                    node.init.expression.type === "ArrayExpression") {
-                    variableDeclarations.set(node.id.name, node.init.expression);
+                // TS wrappers (`as const`, `satisfies T`, `!`) are runtime-transparent.
+                const initExpr = unwrapTsWrappers(node.init);
+                if (initExpr.type === "ArrayExpression") {
+                    variableDeclarations.set(node.id.name, initExpr);
                 }
                 // Only register top-level lazy bindings (Program > VarDecl or
                 // Program > ExportNamedDecl > VarDecl) and never overwrite a
                 // static import — prevents nested/helper-scoped rebindings.
-                const declarationParent = astPath.parentPath?.parentPath;
-                const isTopLevel = declarationParent
-                    ? declarationParent.isProgram() ||
-                        (declarationParent.isExportNamedDeclaration() &&
-                            (declarationParent.parentPath?.isProgram() ?? false))
-                    : false;
+                const isTopLevel = isProgramLevel(astPath.parentPath?.parentPath);
                 // Collect top-level object expressions with arrow-function properties
                 // that contain import() calls (e.g. preload/chunk maps).
-                // Unwrap `as const` / `satisfies T` wrappers the same way we do for arrays.
                 if (isTopLevel) {
-                    let objectExpr = null;
-                    if (node.init.type === "ObjectExpression") {
-                        objectExpr = node.init;
-                    }
-                    else if (node.init.type === "TSAsExpression" &&
-                        node.init.expression.type === "ObjectExpression") {
-                        objectExpr = node.init.expression;
-                    }
-                    else if (node.init.type === "TSSatisfiesExpression" &&
-                        node.init.expression.type === "ObjectExpression") {
-                        objectExpr = node.init.expression;
-                    }
+                    const objectExpr = initExpr.type === "ObjectExpression" ? initExpr : null;
                     if (objectExpr) {
                         const propMap = new Map();
                         for (const prop of objectExpr.properties) {
@@ -646,30 +837,35 @@ export async function parseRouterFile(routerFilePath, rootDir, onDiagnostic) {
                             else {
                                 continue;
                             }
-                            // Accept both identifier keys (`Welcome:`) and string-literal
-                            // keys (`"my-page":`); both look up the same way at call sites.
-                            let propName = null;
-                            if (prop.key.type === "Identifier" && !prop.computed) {
-                                propName = prop.key.name;
-                            }
-                            else if (prop.key.type === "StringLiteral") {
-                                propName = prop.key.value;
-                            }
+                            const propName = getStaticPropertyKey(prop);
                             if (!propName)
                                 continue;
                             const importPath = extractImportPathFromFunction(fn);
-                            if (importPath && isRelativeOrAliasImport(importPath)) {
+                            if (importPath && isLocalModuleSpecifier(importPath)) {
                                 propMap.set(propName, importPath);
                             }
                         }
                         if (propMap.size > 0) {
                             callableImportMap.set(node.id.name, propMap);
                         }
+                        if (!spreadBindings.objectLiterals.has(node.id.name)) {
+                            spreadBindings.objectLiterals.set(node.id.name, objectExpr);
+                        }
+                    }
+                    if ((initExpr.type === "ArrowFunctionExpression" ||
+                        initExpr.type === "FunctionExpression") &&
+                        !spreadBindings.factoryShapes.has(node.id.name)) {
+                        spreadBindings.factoryShapes.set(node.id.name, classifyLocalFactory(initExpr));
+                    }
+                    if (initExpr.type === "CallExpression" &&
+                        initExpr.callee.type === "Identifier" &&
+                        !spreadBindings.constFactoryCalls.has(node.id.name)) {
+                        spreadBindings.constFactoryCalls.set(node.id.name, initExpr.callee.name);
                     }
                 }
                 if (isTopLevel && !allImports.has(node.id.name)) {
-                    const lazyImportPath = extractLazyImportPath(node.init);
-                    if (lazyImportPath && isRelativeOrAliasImport(lazyImportPath)) {
+                    const lazyImportPath = extractLazyImportPath(initExpr);
+                    if (lazyImportPath && isLocalModuleSpecifier(lazyImportPath)) {
                         allImports.set(node.id.name, lazyImportPath);
                     }
                 }
@@ -679,7 +875,7 @@ export async function parseRouterFile(routerFilePath, rootDir, onDiagnostic) {
                 // limited to actual component bindings.
                 if (isTopLevel && !lazyLoaderBindings.has(node.id.name)) {
                     const loaderImportPath = extractImportPathFromLazyValue(node.init, callableImportMap, lazyLoaderBindings);
-                    if (loaderImportPath && isRelativeOrAliasImport(loaderImportPath)) {
+                    if (loaderImportPath && isLocalModuleSpecifier(loaderImportPath)) {
                         lazyLoaderBindings.set(node.id.name, loaderImportPath);
                     }
                 }
@@ -722,7 +918,7 @@ export async function parseRouterFile(routerFilePath, rootDir, onDiagnostic) {
         });
         // Process routes asynchronously after traverse
         if (routesArray) {
-            await extractRoutesFromArray(routesArray, routes, routerFilePath, rootDir, "", allImports, callableImportMap, lazyLoaderBindings);
+            await extractRoutesFromArray(routesArray, routes, routerFilePath, rootDir, "", allImports, callableImportMap, lazyLoaderBindings, spreadBindings);
             if (routeObjectCount > 0 && routes.length === 0) {
                 onDiagnostic?.({
                     kind: "unsupported_route_shape",
@@ -746,19 +942,52 @@ export async function parseRouterFile(routerFilePath, rootDir, onDiagnostic) {
         return [];
     }
 }
-async function extractRoutesFromArray(node, routes, routerFilePath, rootDir, parentPath, allImports, callableImportMap, lazyLoaderBindings) {
+async function extractRoutesFromArray(node, routes, routerFilePath, rootDir, parentPath, allImports, callableImportMap, lazyLoaderBindings, spreadBindings) {
     for (const element of node.elements) {
         if (element && element.type === "ObjectExpression") {
-            await extractRouteFromObject(element, routes, routerFilePath, rootDir, parentPath, allImports, callableImportMap, lazyLoaderBindings);
+            await extractRouteFromObject(element, routes, routerFilePath, rootDir, parentPath, allImports, callableImportMap, lazyLoaderBindings, spreadBindings);
         }
     }
 }
-async function extractRouteFromObject(node, routes, routerFilePath, rootDir, parentPath, allImports, callableImportMap, lazyLoaderBindings) {
+async function extractRouteFromObject(node, routes, routerFilePath, rootDir, parentPath, allImports, callableImportMap, lazyLoaderBindings, spreadBindings) {
     let routePath = null;
     let pageImportPath = null;
     let children = null;
     let hasIndex = false;
+    let heuristicSpreadImportPath = null;
+    let sawUnresolvedPageSpread = false;
     for (const prop of node.properties) {
+        // A route may receive its page property through a spread instead of a
+        // literal key: `{ path: "/home", ...gatedLazy(() => import("...")) }`.
+        // A classified page contribution participates like an explicit property
+        // in source order, so a later contributor overrides an earlier one,
+        // matching runtime spread order when the import is extractable; a
+        // heuristic one is only a fallback for when nothing verified resolves.
+        if (prop.type === "SpreadElement") {
+            const contribution = resolveSpreadContribution(prop.argument, allImports, callableImportMap, lazyLoaderBindings, spreadBindings);
+            if (contribution.kind === "page") {
+                if (contribution.importPath) {
+                    pageImportPath = contribution.importPath;
+                }
+                else {
+                    // The spread verifiably carries the route's page and it could not
+                    // be resolved. At runtime it overrides whatever came before it, so
+                    // an earlier contributor's import is discarded and the heuristic
+                    // fallback suppressed; mapping either would point the route at a
+                    // file the router no longer renders. The route drops unless a
+                    // later contributor resolves.
+                    pageImportPath = null;
+                    sawUnresolvedPageSpread = true;
+                    getLogger().debug(`Router parser: a spread on route "${routePath ?? "(index)"}" in ${routerFilePath} ` +
+                        `carries a page key (lazy/Component/element) the parser could not resolve to an import; ` +
+                        `the route will be dropped unless a later page property resolves.`);
+                }
+            }
+            else if (contribution.kind === "heuristic" && contribution.importPath) {
+                heuristicSpreadImportPath = contribution.importPath;
+            }
+            continue;
+        }
         if (prop.type !== "ObjectProperty")
             continue;
         const key = prop.key.type === "Identifier" ? prop.key.name : null;
@@ -806,6 +1035,14 @@ async function extractRouteFromObject(node, routes, routerFilePath, rootDir, par
             children = prop.value;
         }
     }
+    if (!pageImportPath &&
+        heuristicSpreadImportPath &&
+        !sawUnresolvedPageSpread) {
+        pageImportPath = heuristicSpreadImportPath;
+        getLogger().debug(`Router parser: route "${routePath ?? "(index)"}" in ${routerFilePath} has no verified page property; ` +
+            `treating import "${heuristicSpreadImportPath}" from a spread the parser could not classify as the page. ` +
+            `If that spread contributes a loader rather than a page, the mapping will be wrong.`);
+    }
     // Check if any children have index: true
     let hasIndexChild = false;
     if (children) {
@@ -888,7 +1125,7 @@ async function extractRouteFromObject(node, routes, routerFilePath, rootDir, par
         const currentPath = routePath ? joinURL(parentPath, routePath) : parentPath;
         // Normalize empty path to "/" before passing to children
         const normalizedCurrentPath = currentPath || "/";
-        await extractRoutesFromArray(children, routes, routerFilePath, rootDir, normalizedCurrentPath, allImports, callableImportMap, lazyLoaderBindings);
+        await extractRoutesFromArray(children, routes, routerFilePath, rootDir, normalizedCurrentPath, allImports, callableImportMap, lazyLoaderBindings, spreadBindings);
     }
 }
 //# sourceMappingURL=router-parser.js.map