rsbuild-plugin-react-router 0.2.0 → 0.3.1

package/dist/451.js

@@ -0,0 +1,1103 @@
+import { basename, dirname, normalize, relative, resolve } from "pathe";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { langFromPath, parse, walk as external_yuku_parser_walk } from "yuku-parser";
+import { Analyzer } from "yuku-analyzer";
+import { print } from "yuku-codegen";
+import { readFile, stat } from "node:fs/promises";
+import { rspack } from "@rsbuild/core";
+import { createRequire } from "node:module";
+let PLUGIN_NAME = 'rsbuild:react-router', JS_EXTENSIONS = [
+    '.tsx',
+    '.ts',
+    '.jsx',
+    '.js',
+    '.mjs',
+    '.mts'
+], BUILD_CLIENT_ROUTE_QUERY_STRING = '?__react-router-build-client-route', SERVER_ONLY_ROUTE_EXPORTS = [
+    'loader',
+    'action',
+    'middleware',
+    'headers'
+], SERVER_ONLY_ROUTE_EXPORTS_SET = new Set(SERVER_ONLY_ROUTE_EXPORTS), CLIENT_ROUTE_EXPORTS_SET = new Set([
+    'clientAction',
+    'clientLoader',
+    'clientMiddleware',
+    'handle',
+    'meta',
+    'links',
+    'shouldRevalidate',
+    'default',
+    'ErrorBoundary',
+    'HydrateFallback',
+    'Layout'
+]), NAMED_COMPONENT_EXPORTS_SET = new Set([
+    'HydrateFallback',
+    'ErrorBoundary'
+]), SERVER_EXPORTS = {
+    loader: 'loader',
+    action: 'action',
+    middleware: 'middleware',
+    headers: 'headers'
+}, CLIENT_EXPORTS = {
+    clientAction: 'clientAction',
+    clientLoader: 'clientLoader',
+    clientMiddleware: 'clientMiddleware',
+    default: 'default',
+    ErrorBoundary: 'ErrorBoundary',
+    handle: 'handle',
+    HydrateFallback: 'HydrateFallback',
+    Layout: 'Layout',
+    links: 'links',
+    meta: 'meta',
+    shouldRevalidate: 'shouldRevalidate'
+}, getPatternIdentifierNames = (pattern, names = new Set())=>{
+    if (!pattern) return names;
+    if ('Identifier' === pattern.type) return names.add(pattern.name), names;
+    if ('RestElement' === pattern.type) return getPatternIdentifierNames(pattern.argument, names);
+    if ('AssignmentPattern' === pattern.type) return getPatternIdentifierNames(pattern.left, names);
+    if ('ArrayPattern' === pattern.type) {
+        for (let element of pattern.elements ?? [])getPatternIdentifierNames(element, names);
+        return names;
+    }
+    if ('ObjectPattern' === pattern.type) for (let property of pattern.properties ?? [])'RestElement' === property.type ? getPatternIdentifierNames(property.argument, names) : getPatternIdentifierNames(property.value, names);
+    return names;
+}, getIdentifierNamesFromPattern = (pattern)=>Array.from(getPatternIdentifierNames(pattern)), getExportedName = (node)=>{
+    let exported = node?.exported ?? node;
+    return exported ? 'Identifier' === exported.type ? exported.name : 'Literal' === exported.type || 'StringLiteral' === exported.type ? String(exported.value) : null : null;
+}, identifier = (name)=>({
+        type: 'Identifier',
+        start: 0,
+        end: 0,
+        name,
+        decorators: [],
+        optional: !1,
+        typeAnnotation: null
+    }), callExpression = (callee, args)=>({
+        type: 'CallExpression',
+        start: 0,
+        end: 0,
+        callee,
+        arguments: args,
+        optional: !1
+    }), importDeclaration = (specifiers, source)=>({
+        type: 'ImportDeclaration',
+        start: 0,
+        end: 0,
+        specifiers: specifiers.map((specifier)=>({
+                type: 'ImportSpecifier',
+                start: 0,
+                end: 0,
+                imported: identifier(specifier.imported),
+                local: identifier(specifier.local),
+                importKind: 'value'
+            })),
+        source: {
+            type: 'Literal',
+            start: 0,
+            end: 0,
+            value: source,
+            raw: JSON.stringify(source)
+        },
+        attributes: [],
+        phase: null,
+        importKind: 'value'
+    }), exportSpecifier = (local, exported)=>({
+        type: 'ExportSpecifier',
+        start: 0,
+        end: 0,
+        local: identifier(local),
+        exported: identifier(exported),
+        exportKind: 'value'
+    }), exportNamedDeclaration = (specifiers)=>({
+        type: 'ExportNamedDeclaration',
+        start: 0,
+        end: 0,
+        declaration: null,
+        specifiers,
+        source: null,
+        attributes: [],
+        exportKind: 'value'
+    }), variableDeclaration = (name, init)=>({
+        type: 'VariableDeclaration',
+        start: 0,
+        end: 0,
+        kind: 'const',
+        declare: !1,
+        declarations: [
+            {
+                type: 'VariableDeclarator',
+                start: 0,
+                end: 0,
+                id: identifier(name),
+                init,
+                definite: !1
+            }
+        ]
+    }), removeFromArray = (array, value)=>{
+    let index = array.indexOf(value);
+    index >= 0 && array.splice(index, 1);
+}, assertAllowedBindingName = (name, exportsToRemove)=>{
+    if (exportsToRemove.has(name)) throw Error(`Cannot remove destructured export "${name}"`);
+}, validateRestElement = (element, exportsToRemove)=>{
+    element.argument?.type === 'Identifier' && element.argument.name && assertAllowedBindingName(element.argument.name, exportsToRemove);
+}, validateObjectProperty = (property, exportsToRemove)=>{
+    'RestElement' === property.type ? validateRestElement(property, exportsToRemove) : 'Property' === property.type && validateBindingTarget(property.value, exportsToRemove);
+}, validateBindingTarget = (node, exportsToRemove)=>{
+    if (node) switch(node.type){
+        case 'Identifier':
+            node.name && assertAllowedBindingName(node.name, exportsToRemove);
+            return;
+        case 'AssignmentPattern':
+            validateBindingTarget(node.left, exportsToRemove);
+            return;
+        case 'ArrayPattern':
+            for (let element of node.elements ?? [])element?.type === 'RestElement' ? validateRestElement(element, exportsToRemove) : validateBindingTarget(element, exportsToRemove);
+            return;
+        case 'ObjectPattern':
+            for (let property of node.properties ?? [])validateObjectProperty(property, exportsToRemove);
+    }
+}, getDeclaredNames = (node)=>{
+    let names = new Set();
+    if ('VariableDeclaration' === node.type) for (let declarator of node.declarations ?? [])getPatternIdentifierNames(declarator.id, names);
+    else if (('FunctionDeclaration' === node.type || 'ClassDeclaration' === node.type) && node.id?.name) names.add(node.id.name);
+    else if ('ImportDeclaration' === node.type) for (let specifier of node.specifiers ?? [])specifier.local?.name && names.add(specifier.local.name);
+    return names;
+}, collectReferencedNames = (node)=>{
+    let referenced = new Set();
+    return external_yuku_parser_walk(node, {
+        Identifier (node, ctx) {
+            let parent = ctx.parent;
+            !(parent && 'Identifier' === node.type && (((node, parent)=>{
+                if (!parent || 'Identifier' !== node.type) return !1;
+                if (('FunctionDeclaration' === parent.type || 'FunctionExpression' === parent.type || 'ClassDeclaration' === parent.type || 'ClassExpression' === parent.type) && parent.id === node) return !0;
+                if ('VariableDeclarator' === parent.type) return !!(node.name && getPatternIdentifierNames(parent.id).has(node.name));
+                if (('ImportSpecifier' === parent.type || 'ImportDefaultSpecifier' === parent.type || 'ImportNamespaceSpecifier' === parent.type) && parent.local === node) return !0;
+                if (('FunctionDeclaration' === parent.type || 'FunctionExpression' === parent.type || 'ArrowFunctionExpression' === parent.type) && node.name) {
+                    let name = node.name;
+                    return (parent.params ?? []).some((param)=>getPatternIdentifierNames(param).has(name));
+                }
+                return !1;
+            })(node, parent) || 'MemberExpression' === parent.type && parent.property === node && !parent.computed || 'Property' === parent.type && parent.key === node && !parent.computed && !parent.shorthand || 'MethodDefinition' === parent.type && parent.key === node && !parent.computed || 'ExportSpecifier' === parent.type || 'ExportDefaultSpecifier' === parent.type || 'ExportNamespaceSpecifier' === parent.type || 'ImportSpecifier' === parent.type && parent.imported === node || 'LabeledStatement' === parent.type || 'BreakStatement' === parent.type || 'ContinueStatement' === parent.type)) && node.name && referenced.add(node.name);
+        },
+        JSXIdentifier (node, ctx) {
+            let name, parent = ctx.parent;
+            if (parent) {
+                if ('JSXMemberExpression' === parent.type && parent.object === node) {
+                    node.name && referenced.add(node.name);
+                    return;
+                }
+                if (node.name && (name = node.name, /^[A-Z]/.test(name)) && ('JSXOpeningElement' === parent.type || 'JSXClosingElement' === parent.type) && parent.name === node) return void referenced.add(node.name);
+            }
+        },
+        ExportSpecifier (node, ctx) {
+            let declaration = ctx.parent;
+            !declaration?.source && declaration?.exportKind !== 'type' && node.local?.name && 'type' !== node.exportKind && referenced.add(node.local.name);
+        }
+    }), referenced;
+}, collectLiveTopLevelDeclarations = (program, graph)=>{
+    let pendingNames = [];
+    for (let statement of program.body ?? [])if ('VariableDeclaration' !== statement.type && !graph.declarationsByNode.has(statement)) for (let name of collectReferencedNames(statement))pendingNames.push(name);
+    let visitedNames = new Set(), liveDeclarations = new Set();
+    for(; pendingNames.length > 0;){
+        let name = pendingNames.pop();
+        if (!(!name || visitedNames.has(name))) {
+            for (let declaration of (visitedNames.add(name), graph.declarationsByName.get(name) ?? []))if (!liveDeclarations.has(declaration)) for (let referencedName of (liveDeclarations.add(declaration), declaration.referencedNames))pendingNames.push(referencedName);
+        }
+    }
+    return liveDeclarations;
+}, declarationReferencesName = (declaration, names, graph, cache, visitedNames = new Set())=>{
+    let cached = cache.get(declaration);
+    if (void 0 !== cached) return cached;
+    for (let referencedName of declaration.referencedNames){
+        if (names.has(referencedName)) return cache.set(declaration, !0), !0;
+        if (!visitedNames.has(referencedName)) {
+            for (let referencedDeclaration of (visitedNames.add(referencedName), graph.declarationsByName.get(referencedName) ?? []))if (declarationReferencesName(referencedDeclaration, names, graph, cache, visitedNames)) return cache.set(declaration, !0), !0;
+        }
+    }
+    return cache.set(declaration, !1), !1;
+};
+function toFunctionExpression(decl) {
+    return {
+        ...decl,
+        type: 'FunctionExpression',
+        declare: void 0
+    };
+}
+function toClassExpression(decl) {
+    return {
+        ...decl,
+        type: 'ClassExpression',
+        declare: void 0
+    };
+}
+let getComponentExportName = (exportedName)=>{
+    var name;
+    return 'default' === exportedName ? 'Component' : (name = exportedName, NAMED_COMPONENT_EXPORTS_SET.has(name)) ? exportedName : null;
+}, declarationIncludesName = (declaration, name)=>'VariableDeclaration' === declaration.type ? (declaration.declarations ?? []).some((declarator)=>{
+        let pattern;
+        return pattern = declarator.id, getPatternIdentifierNames(pattern).has(name);
+    }) : ('FunctionDeclaration' === declaration.type || 'ClassDeclaration' === declaration.type || 'TSEnumDeclaration' === declaration.type) && declaration.id?.name ? declaration.id.name === name : 'ImportDeclaration' === declaration.type && (declaration.specifiers ?? []).some((specifier)=>specifier.local?.name === name), hasTopLevelBindingName = (program, name)=>{
+    for (let statement of program.body ?? []){
+        if ('ImportDeclaration' === statement.type) {
+            if (declarationIncludesName(statement, name)) return !0;
+            continue;
+        }
+        if ('ExportDefaultDeclaration' === statement.type) {
+            if (statement.declaration?.id?.name === name) return !0;
+            continue;
+        }
+        let declaration = 'ExportNamedDeclaration' === statement.type ? statement.declaration : statement;
+        if (declaration && declarationIncludesName(declaration, name)) return !0;
+    }
+    return !1;
+};
+function combineURLs(baseURL, relativeURL) {
+    return relativeURL ? `${baseURL.replace(/\/+$/, '')}/${relativeURL.replace(/^\/+/, '')}` : baseURL;
+}
+function normalizeAssetPrefix(assetPrefix) {
+    return assetPrefix && 'auto' !== assetPrefix ? assetPrefix.endsWith('/') ? assetPrefix : `${assetPrefix}/` : '/';
+}
+function createRouteId(file) {
+    return normalize(file.replace(/\.[^/.]+$/, ''));
+}
+function findEntryFile(basePath) {
+    for (let ext of JS_EXTENSIONS){
+        let filePath = `${basePath}${ext}`;
+        if (existsSync(filePath)) return filePath;
+    }
+    return `${basePath}.tsx`;
+}
+function generateWithProps() {
+    return `
+    import { createElement as h } from "react";
+    import { useActionData, useLoaderData, useMatches, useParams, useRouteError } from "react-router";
+
+    export function withComponentProps(Component) {
+      return function Wrapped() {
+        const props = {
+          params: useParams(),
+          loaderData: useLoaderData(),
+          actionData: useActionData(),
+          matches: useMatches(),
+        };
+        return h(Component, props);
+      };
+    }
+
+    export function withHydrateFallbackProps(HydrateFallback) {
+      return function Wrapped() {
+        const props = {
+          params: useParams(),
+        };
+        return h(HydrateFallback, props);
+      };
+    }
+
+    export function withErrorBoundaryProps(ErrorBoundary) {
+      return function Wrapped() {
+        const props = {
+          params: useParams(),
+          loaderData: useLoaderData(),
+          actionData: useActionData(),
+          error: useRouteError(),
+        };
+        return h(ErrorBoundary, props);
+      };
+    }
+  `;
+}
+let routeChunkExportNames = [
+    'clientAction',
+    'clientLoader',
+    'clientMiddleware',
+    'HydrateFallback'
+];
+[
+    ...routeChunkExportNames
+];
+let mightContainRouteChunkExportName = (source)=>routeChunkExportNames.some((exportName)=>source.includes(exportName)), createRouteChunkExportMap = (getValue)=>Object.fromEntries(routeChunkExportNames.map((exportName)=>[
+            exportName,
+            getValue(exportName)
+        ])), routeChunkQueryStringPrefix = '?route-chunk=', routeChunkQueryStrings = {
+    main: `${routeChunkQueryStringPrefix}main`,
+    clientAction: `${routeChunkQueryStringPrefix}clientAction`,
+    clientLoader: `${routeChunkQueryStringPrefix}clientLoader`,
+    clientMiddleware: `${routeChunkQueryStringPrefix}clientMiddleware`,
+    HydrateFallback: `${routeChunkQueryStringPrefix}HydrateFallback`
+}, routeChunkEntrySuffix = {
+    clientAction: 'client-action',
+    clientLoader: 'client-loader',
+    clientMiddleware: 'client-middleware',
+    HydrateFallback: 'hydrate-fallback'
+}, invariant = (value, message)=>{
+    if (!value) throw Error(message);
+}, getOrSetFromCache = (cache, key, version, getValue)=>{
+    let entry = cache.get(key);
+    if (entry?.version === version) return entry.value;
+    let value = getValue();
+    return cache.set(key, {
+        value,
+        version
+    }), value;
+}, analyzeCode = (code, cache, cacheKey)=>getOrSetFromCache(cache, `${cacheKey}::analyzeCode`, code, ()=>{
+        let module = new Analyzer().addFile(cacheKey, code, {
+            lang: 'tsx',
+            sourceType: 'module',
+            attachComments: !0
+        }), errors = module.diagnostics.filter((diagnostic)=>'error' === diagnostic.severity);
+        if (errors.length > 0) throw Error(errors.map((error)=>error.message).join('\n'));
+        return {
+            module,
+            program: module.ast
+        };
+    }), route_chunks_getExportedName = (exported)=>'Identifier' === exported.type ? exported.name : String(exported.value), setsIntersect = (set1, set2)=>{
+    let smallerSet = set1, largerSet = set2;
+    for (let element of (set1.size > set2.size && (smallerSet = set2, largerSet = set1), smallerSet))if (largerSet.has(element)) return !0;
+    return !1;
+}, getExportDependencies = (code, cache, cacheKey)=>getOrSetFromCache(cache, `${cacheKey}::getExportDependencies`, code, ()=>{
+        let { module } = analyzeCode(code, cache, cacheKey), exportDependencies = new Map(), topLevelStatementCache = new Map(), variableDeclaratorCache = new Map(), getCachedTopLevelStatementForNode = (node)=>{
+            let cached = topLevelStatementCache.get(node);
+            if (cached) return cached;
+            let statement = ((module, node)=>{
+                let current = node, parent = module.parentOf(current);
+                for(; parent && 'Program' !== parent.type;)current = parent, parent = module.parentOf(current);
+                return invariant(parent?.type === 'Program', 'Expected node to be within Program'), current;
+            })(module, node);
+            return topLevelStatementCache.set(node, statement), statement;
+        }, getCachedVariableDeclaratorForNode = (node)=>{
+            if (variableDeclaratorCache.has(node)) return variableDeclaratorCache.get(node) ?? null;
+            let declarator = ((module, node)=>{
+                let current = node;
+                for(; current;){
+                    if ('VariableDeclarator' === current.type) return current;
+                    current = module.parentOf(current);
+                }
+                return null;
+            })(module, node);
+            return variableDeclaratorCache.set(node, declarator), declarator;
+        }, addCachedTopLevelStatement = (dependencies, node)=>{
+            let statement = getCachedTopLevelStatementForNode(node);
+            return dependencies.topLevelStatements.add(statement), 'ImportDeclaration' === statement.type || statement.type.startsWith('Export') || dependencies.topLevelNonModuleStatements.add(statement), statement;
+        }, handleExport = (exportName, exportNode, localSymbol)=>{
+            let dependencies = {
+                topLevelStatements: new Set(),
+                topLevelNonModuleStatements: new Set(),
+                importedIdentifierNames: new Set(),
+                exportedVariableDeclarators: new Set()
+            }, visitedSymbols = new Set(), scannedNodes = new Set(), scanNode = (node)=>{
+                scannedNodes.has(node) || (scannedNodes.add(node), external_yuku_parser_walk(node, {
+                    Identifier (node) {
+                        let reference = module.referenceOf(node);
+                        reference?.symbol && visitSymbol(reference.symbol);
+                    }
+                }));
+            }, visitSymbol = (symbol)=>{
+                if (!visitedSymbols.has(symbol)) {
+                    for (let declaration of (visitedSymbols.add(symbol), symbol.declarations)){
+                        let statement = addCachedTopLevelStatement(dependencies, declaration);
+                        'ImportDeclaration' === statement.type && dependencies.importedIdentifierNames.add(symbol.name);
+                        let declarator = getCachedVariableDeclaratorForNode(declaration);
+                        declarator && 'ExportNamedDeclaration' === getCachedTopLevelStatementForNode(declarator).type && dependencies.exportedVariableDeclarators.add(declarator), scanNode(declarator ?? statement);
+                    }
+                    for (let reference of symbol.references){
+                        let statement = addCachedTopLevelStatement(dependencies, reference.node);
+                        scanNode(getCachedVariableDeclaratorForNode(reference.node) ?? statement);
+                    }
+                }
+            };
+            addCachedTopLevelStatement(dependencies, exportNode), localSymbol ? visitSymbol(localSymbol) : scanNode(getCachedTopLevelStatementForNode(exportNode)), exportDependencies.set(exportName, dependencies);
+        };
+        for (let exp of module.exports)exp.typeOnly || exp.isStar || exp.isExportEquals || handleExport(exp.name, exp.node, exp.local ?? null);
+        return exportDependencies;
+    }), getChunkableExportMap = (code, cache, cacheKey)=>getOrSetFromCache(cache, `${cacheKey}::getChunkableExportMap`, code, ()=>{
+        let exportDependencies = getExportDependencies(code, cache, cacheKey);
+        return createRouteChunkExportMap((exportName)=>((exportName, exportDependencies)=>{
+                let dependencies = exportDependencies.get(exportName);
+                if (!dependencies) return !1;
+                for (let [currentExportName, currentDependencies] of exportDependencies)if (currentExportName !== exportName && setsIntersect(currentDependencies.topLevelNonModuleStatements, dependencies.topLevelNonModuleStatements)) return !1;
+                if (dependencies.exportedVariableDeclarators.size > 1) return !1;
+                if (dependencies.exportedVariableDeclarators.size > 0) {
+                    for (let [currentExportName, currentDependencies] of exportDependencies)if (currentExportName !== exportName && setsIntersect(currentDependencies.exportedVariableDeclarators, dependencies.exportedVariableDeclarators)) return !1;
+                }
+                return !0;
+            })(exportName, exportDependencies));
+    }), generateCode = (program)=>{
+    if (0 === program.body.length) return;
+    let result = print(program, {
+        comments: !0
+    });
+    if (result.errors.length > 0) throw Error(result.errors.map((error)=>error.message).join('\n'));
+    return result.code;
+}, filterImportSpecifiers = (node, shouldKeep)=>{
+    if (0 === node.specifiers.length) return node;
+    let specifiers = node.specifiers.filter((specifier)=>shouldKeep(specifier.local.name));
+    return specifiers.length > 0 ? {
+        ...node,
+        specifiers
+    } : null;
+}, getChunkedExport = (code, exportName, cache, cacheKey)=>getOrSetFromCache(cache, `${cacheKey}::getChunkedExport::${exportName}`, code, ()=>{
+        if (!routeChunkExportNames.includes(exportName) || !getChunkableExportMap(code, cache, cacheKey)[exportName]) return;
+        let dependencies = getExportDependencies(code, cache, cacheKey).get(exportName);
+        invariant(dependencies, 'Expected export to have dependencies');
+        let program = analyzeCode(code, cache, cacheKey).program, body = program.body.filter((node)=>dependencies.topLevelStatements.has(node)).map((node)=>'ImportDeclaration' !== node.type ? node : 0 === dependencies.importedIdentifierNames.size ? null : filterImportSpecifiers(node, (importedName)=>dependencies.importedIdentifierNames.has(importedName))).map((node)=>{
+            if (!node || !node.type.startsWith('Export')) return node;
+            if ('ExportAllDeclaration' === node.type) return null;
+            if ('ExportDefaultDeclaration' === node.type) return 'default' === exportName ? node : null;
+            let { declaration } = node;
+            if (declaration?.type === 'VariableDeclaration') {
+                let declarations = declaration.declarations.filter((declarationNode)=>dependencies.exportedVariableDeclarators.has(declarationNode));
+                return declarations.length > 0 ? {
+                    ...node,
+                    declaration: {
+                        ...declaration,
+                        declarations
+                    }
+                } : null;
+            }
+            if (declaration?.type === 'FunctionDeclaration' || declaration?.type === 'ClassDeclaration') return declaration.id?.name === exportName ? node : null;
+            if ('ExportNamedDeclaration' === node.type) {
+                let specifiers = node.specifiers.filter((specifier)=>route_chunks_getExportedName(specifier.exported) === exportName);
+                return specifiers.length > 0 ? {
+                    ...node,
+                    specifiers
+                } : null;
+            }
+            throw Error('Unknown export node type');
+        }).filter(Boolean);
+        return generateCode({
+            ...program,
+            body
+        });
+    }), hasCachedChunkedExport = (code, exportName, cache, cacheKey)=>{
+    let key;
+    return key = `${cacheKey}::getChunkedExport::${exportName}`, cache.get(key)?.version === code;
+}, getRouteChunkModuleId = (filePath, chunkName)=>`${filePath}${routeChunkQueryStrings[chunkName]}`, normalizeRelativeFilePath = (file, appDirectory)=>{
+    let fullPath = resolve(appDirectory, file);
+    return normalize(relative(appDirectory, fullPath)).split('?')[0];
+}, isRootRouteModuleId = (config, id)=>normalizeRelativeFilePath(id, config.appDirectory) === config.rootRouteFile, shouldAnalyzeRouteChunks = (config, id, code)=>!!config.splitRouteModules && mightContainRouteChunkExportName(code) && !isRootRouteModuleId(config, id), createEmptyRouteChunkByExportName = ()=>createRouteChunkExportMap(()=>!1), buildManifestChunkValidity = (exportNames, hasRouteChunkByExportName)=>createRouteChunkExportMap((exportName)=>!exportNames.has(exportName) || hasRouteChunkByExportName[exportName]), detectRouteChunksIfEnabled = async (cache, config, id, code)=>{
+    let analysisCache, exportDependencies, hasRouteChunkByExportName, chunkedExports, hasRouteChunks;
+    if (!shouldAnalyzeRouteChunks(config, id, code)) return {
+        exportNames: [],
+        chunkedExports: [],
+        hasRouteChunks: !1,
+        hasRouteChunkByExportName: createEmptyRouteChunkByExportName()
+    };
+    let cacheKey = normalizeRelativeFilePath(id, config.appDirectory);
+    return exportDependencies = getExportDependencies(code, analysisCache = cache ?? new Map(), cacheKey), hasRouteChunks = (chunkedExports = Object.entries(hasRouteChunkByExportName = getChunkableExportMap(code, analysisCache, cacheKey)).filter(([, isChunked])=>isChunked).map(([exportName])=>exportName)).length > 0, {
+        exportNames: Array.from(exportDependencies.keys()),
+        hasRouteChunks,
+        hasRouteChunkByExportName,
+        chunkedExports
+    };
+}, getRouteChunkIfEnabled = async (cache, config, id, chunkName, code)=>{
+    if (!config.splitRouteModules) return null;
+    if ('main' === chunkName) {
+        if (!mightContainRouteChunkExportName(code)) return code;
+    } else if (!code.includes(chunkName)) return null;
+    return ((code, chunkName, cache, cacheKey)=>{
+        let analysisCache = cache ?? new Map();
+        if ('main' === chunkName) return getOrSetFromCache(analysisCache, `${cacheKey}::omitChunkedExports::${routeChunkExportNames.join(',')}`, code, ()=>{
+            let chunkableExportMap = getChunkableExportMap(code, analysisCache, cacheKey), exportNameSet = new Set(routeChunkExportNames), isOmitted = (exportName)=>exportNameSet.has(exportName) && !!chunkableExportMap[exportName], exportDependencies = getExportDependencies(code, analysisCache, cacheKey), allExportNames = Array.from(exportDependencies.keys()), omittedExportNames = allExportNames.filter(isOmitted), retainedExportNames = allExportNames.filter((exportName)=>!isOmitted(exportName)), omittedStatements = new Set(), omittedExportedVariableDeclarators = new Set(), retainedImportedIdentifierNames = new Set(), omittedImportedIdentifierNames = new Set();
+            for (let omittedExportName of omittedExportNames){
+                let dependencies = exportDependencies.get(omittedExportName);
+                for (let statement of (invariant(dependencies, `Expected dependencies for ${omittedExportName}`), dependencies.topLevelNonModuleStatements))omittedStatements.add(statement);
+                for (let declarator of dependencies.exportedVariableDeclarators)omittedExportedVariableDeclarators.add(declarator);
+                for (let importedName of dependencies.importedIdentifierNames)omittedImportedIdentifierNames.add(importedName);
+            }
+            for (let retainedExportName of retainedExportNames){
+                let dependencies = exportDependencies.get(retainedExportName);
+                if (dependencies) for (let importedName of dependencies.importedIdentifierNames)retainedImportedIdentifierNames.add(importedName);
+            }
+            let program = analyzeCode(code, analysisCache, cacheKey).program, body = program.body.filter((node)=>!omittedStatements.has(node)).map((node)=>'ImportDeclaration' !== node.type ? node : filterImportSpecifiers(node, (importedName)=>!!retainedImportedIdentifierNames.has(importedName) || !omittedImportedIdentifierNames.has(importedName))).map((node)=>{
+                if (!node || !node.type.startsWith('Export') || 'ExportAllDeclaration' === node.type) return node;
+                if ('ExportDefaultDeclaration' === node.type) return isOmitted('default') ? null : node;
+                if (node.declaration?.type === 'VariableDeclaration') {
+                    let declarations = node.declaration.declarations.filter((declarationNode)=>!omittedExportedVariableDeclarators.has(declarationNode));
+                    return declarations.length > 0 ? {
+                        ...node,
+                        declaration: {
+                            ...node.declaration,
+                            declarations
+                        }
+                    } : null;
+                }
+                if (node.declaration?.type === 'FunctionDeclaration' || node.declaration?.type === 'ClassDeclaration') return isOmitted(node.declaration.id.name) ? null : node;
+                if ('ExportNamedDeclaration' === node.type) {
+                    let specifiers = node.specifiers.filter((specifier)=>!isOmitted(route_chunks_getExportedName(specifier.exported)));
+                    return specifiers.length > 0 || node.declaration ? {
+                        ...node,
+                        specifiers
+                    } : null;
+                }
+                throw Error('Unknown node type');
+            }).filter(Boolean);
+            return generateCode({
+                ...program,
+                body
+            });
+        });
+        return hasCachedChunkedExport(code, chunkName, analysisCache, cacheKey) || ((code, cache, cacheKey)=>{
+            let chunkableExportMap = getChunkableExportMap(code, cache, cacheKey);
+            for (let exportName of routeChunkExportNames)chunkableExportMap[exportName] && (hasCachedChunkedExport(code, exportName, cache, cacheKey) || getChunkedExport(code, exportName, cache, cacheKey));
+        })(code, analysisCache, cacheKey), getChunkedExport(code, chunkName, analysisCache, cacheKey);
+    })(code, chunkName, cache, normalizeRelativeFilePath(id, config.appDirectory)) ?? null;
+}, validateRouteChunks = ({ config, id, valid })=>{
+    if (isRootRouteModuleId(config, id)) return;
+    let invalidChunks = Object.entries(valid).filter(([, isValid])=>!isValid).map(([chunkName])=>chunkName);
+    if (0 === invalidChunks.length) return;
+    let plural = invalidChunks.length > 1;
+    throw Error([
+        `Error splitting route module: ${normalizeRelativeFilePath(id, config.appDirectory)}`,
+        invalidChunks.map((name)=>`- ${name}`).join('\n'),
+        `${plural ? 'These exports' : 'This export'} could not be split into ${plural ? 'their own chunks' : 'its own chunk'} because ${plural ? 'they share' : 'it shares'} code with other exports. You should extract any shared code into its own module and then import it within the route module.`
+    ].join('\n\n'));
+}, getRouteChunkEntryName = (routeId, chunkName)=>`${routeId}-${routeChunkEntrySuffix[chunkName]}`, setBoundedCacheEntry = (cache, key, value, maxEntries)=>{
+    if (maxEntries <= 0) return void cache.clear();
+    if (!cache.has(key) && cache.size >= maxEntries) {
+        let oldestEntry = cache.keys().next();
+        oldestEntry.done || cache.delete(oldestEntry.value);
+    }
+    cache.set(key, value);
+}, exportInfoCache = new Map(), routeModuleAnalysisCache = new Map(), getParseErrors = (result)=>result.diagnostics.filter((diagnostic)=>'error' === diagnostic.severity), getParseErrorMessage = (errors)=>errors.map((error)=>error.message).join('\n'), parseProgram = (code, resourcePath)=>{
+    let sourcePath = resourcePath ? resourcePath.replace(/[?#].*$/, '') : void 0, lang = sourcePath ? langFromPath(sourcePath) : 'tsx', result = parse(code, {
+        sourceType: 'module',
+        lang
+    }), errors = getParseErrors(result);
+    if (0 === errors.length) return result.program ?? result;
+    if (!sourcePath || 'ts' !== lang && 'tsx' !== lang) throw Error(getParseErrorMessage(errors));
+    let normalizedResult = parse(rspack.experiments.swc.transformSync(code, {
+        filename: sourcePath,
+        jsc: {
+            parser: {
+                syntax: "typescript",
+                tsx: 'tsx' === lang
+            }
+        }
+    }).code, {
+        sourceType: 'module',
+        lang: 'js'
+    }), normalizedErrors = getParseErrors(normalizedResult);
+    if (normalizedErrors.length > 0) throw Error(getParseErrorMessage(normalizedErrors));
+    return normalizedResult.program ?? normalizedResult;
+}, cachePromiseOnReject = (promise, invalidate)=>promise.catch((error)=>{
+        throw invalidate(), error;
+    }), isTypeOnlyExport = (node)=>'type' === node.exportKind || 'TSExportAssignment' === node.type || node.declaration?.declare === !0 || 'ExportDefaultDeclaration' === node.type && node.declaration?.type === 'TSInterfaceDeclaration', collectProgramExportNames = (program)=>{
+    let exportNames = new Set();
+    for (let statement of program.body ?? []){
+        if (isTypeOnlyExport(statement)) continue;
+        if ('ExportAllDeclaration' === statement.type) {
+            let exported = getExportedName(statement.exported);
+            exported && exportNames.add(exported);
+            continue;
+        }
+        if ('ExportDefaultDeclaration' === statement.type) {
+            exportNames.add('default');
+            continue;
+        }
+        if ('ExportNamedDeclaration' !== statement.type) continue;
+        let declaration = statement.declaration;
+        if (declaration) {
+            if ('VariableDeclaration' === declaration.type) for (let declarator of declaration.declarations ?? [])for (let name of getIdentifierNamesFromPattern(declarator.id))exportNames.add(name);
+            else ('FunctionDeclaration' === declaration.type || 'ClassDeclaration' === declaration.type || 'TSEnumDeclaration' === declaration.type) && declaration.id?.name && exportNames.add(declaration.id.name);
+            continue;
+        }
+        for (let specifier of statement.specifiers ?? []){
+            if ('type' === specifier.exportKind) continue;
+            let exported = getExportedName(specifier.exported);
+            exported && exportNames.add(exported);
+        }
+    }
+    return Array.from(exportNames);
+}, collectExportAllModules = (program)=>{
+    let modules = [];
+    for (let statement of program.body ?? []){
+        if ('ExportAllDeclaration' !== statement.type || isTypeOnlyExport(statement) || statement.exported) continue;
+        let source = statement.source?.value;
+        'string' == typeof source && modules.push(source);
+    }
+    return modules;
+}, getExportNames = async (code, resourcePath)=>(await getExportNamesAndExportAll(code, resourcePath)).exportNames, getExportNamesAndExportAll = async (code, resourcePath)=>{
+    var code1, resourcePath1;
+    let lang, trackedExportInfo, cacheKey = (code1 = code, lang = (resourcePath1 = resourcePath) ? langFromPath(resourcePath1.replace(/[?#].*$/, '')) : 'inline', `${lang}\0${code1}`), cached = exportInfoCache.get(cacheKey);
+    return cached || (trackedExportInfo = cachePromiseOnReject((async ()=>{
+        let program = parseProgram(code, resourcePath);
+        return {
+            exportNames: collectProgramExportNames(program),
+            exportAllModules: collectExportAllModules(program)
+        };
+    })(), ()=>{
+        exportInfoCache.get(cacheKey) === trackedExportInfo && exportInfoCache.delete(cacheKey);
+    }), setBoundedCacheEntry(exportInfoCache, cacheKey, trackedExportInfo, 2048), trackedExportInfo);
+}, getRouteModuleAnalysis = async (resourcePath)=>{
+    let trackedAnalysis, stats = await stat(resourcePath), cached = routeModuleAnalysisCache.get(resourcePath);
+    return cached?.mtimeMs === stats.mtimeMs && cached.size === stats.size ? cached.analysis : (trackedAnalysis = cachePromiseOnReject((async ()=>{
+        let source = await readFile(resourcePath, 'utf8'), program = parseProgram(source, resourcePath);
+        return {
+            code: source,
+            exports: collectProgramExportNames(program),
+            exportAllModules: collectExportAllModules(program)
+        };
+    })(), ()=>{
+        routeModuleAnalysisCache.get(resourcePath)?.analysis === trackedAnalysis && routeModuleAnalysisCache.delete(resourcePath);
+    }), setBoundedCacheEntry(routeModuleAnalysisCache, resourcePath, {
+        mtimeMs: stats.mtimeMs,
+        size: stats.size,
+        analysis: trackedAnalysis
+    }, 2048), trackedAnalysis);
+}, tryStat = (path)=>statSync(path, {
+        throwIfNoEntry: !1
+    }) ?? null, PACKAGE_IMPORT_CONDITIONS = new Set([
+    'import',
+    'node'
+]), PACKAGE_RESOLUTION_NOT_APPLICABLE = Symbol('package resolution not applicable'), resolveIndexFile = (dirPath)=>{
+    for (let ext of JS_EXTENSIONS){
+        let candidate = resolve(dirPath, `index${ext}`), stats = tryStat(candidate);
+        if (stats?.isFile()) return candidate;
+    }
+    return null;
+}, resolvePathWithExtensions = (basePath)=>{
+    let stats = tryStat(basePath);
+    if (stats?.isFile()) return basePath;
+    if (stats?.isDirectory()) return resolveIndexFile(basePath);
+    for (let ext of JS_EXTENSIONS){
+        let candidate = `${basePath}${ext}`, candidateStats = tryStat(candidate);
+        if (candidateStats?.isFile()) return candidate;
+    }
+    return resolveIndexFile(basePath);
+}, resolvePackageExportTarget = (target)=>{
+    if (!target) return null;
+    if ('string' == typeof target) return target;
+    if (Array.isArray(target)) {
+        for (let nestedTarget of target){
+            let resolvedTarget = resolvePackageExportTarget(nestedTarget);
+            if (resolvedTarget) return resolvedTarget;
+        }
+        return null;
+    }
+    for (let [condition, nestedTarget] of Object.entries(target))if ('default' === condition || PACKAGE_IMPORT_CONDITIONS.has(condition)) {
+        let resolvedTarget = resolvePackageExportTarget(nestedTarget);
+        if (resolvedTarget) return resolvedTarget;
+    }
+    return null;
+}, resolveExportAllModule = (specifier, importerPath)=>{
+    if (specifier.startsWith('.') || specifier.startsWith('/')) {
+        let resolvedPath = resolvePathWithExtensions(specifier.startsWith('/') ? specifier : resolve(dirname(importerPath), specifier));
+        if (resolvedPath) return resolvedPath;
+    }
+    let importResolvedPath = ((specifier, importerPath)=>{
+        let parsedSpecifier = ((specifier)=>{
+            if (specifier.startsWith('.') || specifier.startsWith('/') || specifier.startsWith('#')) return null;
+            let parts = specifier.split('/'), packageName = specifier.startsWith('@') ? parts.slice(0, 2).join('/') : parts[0], packagePathParts = specifier.startsWith('@') ? parts.slice(2) : parts.slice(1);
+            return {
+                packageName,
+                packageSubpath: packagePathParts.length > 0 ? `./${packagePathParts.join('/')}` : '.'
+            };
+        })(specifier);
+        if (!parsedSpecifier) return PACKAGE_RESOLUTION_NOT_APPLICABLE;
+        let packageDirectory = ((importerPath, packageName)=>{
+            let currentDirectory = dirname(importerPath);
+            for(;;){
+                let packageDirectory = resolve(currentDirectory, 'node_modules', packageName), packageJsonPath = resolve(packageDirectory, 'package.json');
+                if (tryStat(packageJsonPath)?.isFile()) return packageDirectory;
+                let parentDirectory = dirname(currentDirectory);
+                if (parentDirectory === currentDirectory) return null;
+                currentDirectory = parentDirectory;
+            }
+        })(importerPath, parsedSpecifier.packageName);
+        if (!packageDirectory) return PACKAGE_RESOLUTION_NOT_APPLICABLE;
+        let packageJson = ((packageDirectory)=>{
+            try {
+                return JSON.parse(readFileSync(resolve(packageDirectory, 'package.json'), 'utf8'));
+            } catch  {
+                return null;
+            }
+        })(packageDirectory);
+        return packageJson && (void 0 !== packageJson.exports || packageJson.module || packageJson.main) ? ((packageDirectory, packageSubpath, packageJson)=>{
+            let exports = packageJson.exports;
+            if (!exports) {
+                let entry = packageJson.module ?? packageJson.main;
+                return entry ? resolvePathWithExtensions(resolve(packageDirectory, entry)) : null;
+            }
+            let resolvedTarget = resolvePackageExportTarget('object' == typeof exports && !Array.isArray(exports) && Object.keys(exports).some((key)=>key.startsWith('.')) ? exports[packageSubpath] : '.' === packageSubpath ? exports : void 0);
+            return resolvedTarget && resolvedTarget.startsWith('./') ? resolvePathWithExtensions(resolve(packageDirectory, resolvedTarget)) : null;
+        })(packageDirectory, parsedSpecifier.packageSubpath, packageJson) : PACKAGE_RESOLUTION_NOT_APPLICABLE;
+    })(specifier, importerPath);
+    if (importResolvedPath !== PACKAGE_RESOLUTION_NOT_APPLICABLE) return importResolvedPath;
+    try {
+        return createRequire(importerPath).resolve(specifier);
+    } catch  {
+        return null;
+    }
+}, createBundlerRouteExportResolver = (resolveModule)=>(specifier, importerPath)=>new Promise((resolvePromise)=>{
+            resolveModule(dirname(importerPath), specifier, (error, resolved)=>{
+                resolvePromise(error || !resolved ? null : resolved);
+            });
+        }), collectClientOnlyStubExportNames = async (code, resourcePath, resolveModule = resolveExportAllModule)=>{
+    let { exportNames: directExportNames, exportAllModules } = await getExportNamesAndExportAll(code, resourcePath), exportNames = new Set(directExportNames), unresolvedExportAll = new Set(), visitedModules = new Set(), collectExportNamesFromModule = async (modulePath)=>{
+        if (visitedModules.has(modulePath)) return;
+        visitedModules.add(modulePath);
+        let { exports: moduleExportNames, exportAllModules: moduleExportAll } = await getRouteModuleAnalysis(modulePath);
+        for (let name of moduleExportNames)'default' !== name && exportNames.add(name);
+        for (let nestedSpecifier of moduleExportAll){
+            let nestedPath = await resolveModule(nestedSpecifier, modulePath);
+            if (!nestedPath) {
+                unresolvedExportAll.add(nestedSpecifier);
+                continue;
+            }
+            await collectExportNamesFromModule(nestedPath);
+        }
+    };
+    for (let specifier of exportAllModules){
+        let resolvedPath = await resolveModule(specifier, resourcePath);
+        if (!resolvedPath) {
+            unresolvedExportAll.add(specifier);
+            continue;
+        }
+        await collectExportNamesFromModule(resolvedPath);
+    }
+    if (unresolvedExportAll.size > 0) throw Error(`[${PLUGIN_NAME}] Client-only module uses \`export * from\` with unresolvable specifier(s): ${Array.from(unresolvedExportAll).map((spec)=>`\`${spec}\``).join(', ')}. Please explicitly re-export named bindings in \`${relative(process.cwd(), resourcePath)}\`.`);
+    return exportNames;
+}, createRouteClientEntryArtifact = async ({ code, resourcePath, environmentName, isBuild, routeChunkCache, routeChunkConfig })=>{
+    let isServer = 'node' === environmentName, routeChunkInfo = !isServer && isBuild && shouldAnalyzeRouteChunks(routeChunkConfig, resourcePath, code) ? await detectRouteChunksIfEnabled(routeChunkCache, routeChunkConfig, resourcePath, code) : null;
+    return {
+        code: (({ exportNames, chunkedExports, isServer, resourcePath })=>{
+            let chunkedExportSet = chunkedExports.length > 0 ? new Set(chunkedExports) : void 0, reexports = exportNames.filter((exp)=>!chunkedExportSet?.has(exp) && (CLIENT_ROUTE_EXPORTS_SET.has(exp) || isServer && SERVER_ONLY_ROUTE_EXPORTS_SET.has(exp))).sort(), target = `${resourcePath}?react-router-route`;
+            return `export { ${reexports.join(', ')} } from ${JSON.stringify(target)};`;
+        })({
+            exportNames: routeChunkInfo?.exportNames ?? await getExportNames(code, resourcePath),
+            chunkedExports: routeChunkInfo?.chunkedExports ?? [],
+            isServer,
+            resourcePath
+        })
+    };
+}, createRouteChunkArtifact = async ({ code, resource, resourcePath, isBuild, routeChunkCache, routeChunkConfig })=>{
+    let splitRouteModules = routeChunkConfig.splitRouteModules;
+    if (!isBuild || !splitRouteModules) return {
+        code: 'export {};',
+        map: null
+    };
+    let chunkName = ((id)=>{
+        let queryIndex = id.indexOf(routeChunkQueryStringPrefix);
+        if (-1 === queryIndex) return null;
+        let chunkNameStart = queryIndex + routeChunkQueryStringPrefix.length, chunkNameEnd = id.indexOf('&', chunkNameStart), chunkName = id.slice(chunkNameStart, -1 === chunkNameEnd ? void 0 : chunkNameEnd);
+        return 'main' === chunkName || routeChunkExportNames.includes(chunkName) ? chunkName : null;
+    })(resource);
+    if (!chunkName) throw Error(`Invalid route chunk name in "${resource}"`);
+    if ('main' !== chunkName && !code.includes(chunkName)) return {
+        code: 'export {};',
+        map: null
+    };
+    let chunk = await getRouteChunkIfEnabled(routeChunkCache, routeChunkConfig, resourcePath, chunkName, code);
+    if ('enforce' === splitRouteModules && 'main' === chunkName && chunk) {
+        let exportNameSet, exportNames = await getExportNames(chunk, resourcePath);
+        validateRouteChunks({
+            config: routeChunkConfig,
+            id: resourcePath,
+            valid: (exportNameSet = new Set(exportNames), createRouteChunkExportMap((exportName)=>!exportNameSet.has(exportName)))
+        });
+    }
+    return {
+        code: chunk ?? 'export {};',
+        map: null
+    };
+}, defaultRouteChunkCache = new Map(), getRouteChunkCache = (options)=>options?.routeChunkCache ?? defaultRouteChunkCache, splitRouteExports = async (task, options)=>{
+    let { exportNames, hasRouteChunks, chunkedExports } = await detectRouteChunksIfEnabled(getRouteChunkCache(options), task.routeChunkConfig, task.resourcePath, task.code);
+    if (!hasRouteChunks) return {
+        code: task.code,
+        map: null
+    };
+    let chunkedExportSet = new Set(chunkedExports), mainChunkReexports = exportNames.filter((name)=>!chunkedExportSet.has(name)).join(', '), chunkBasePath = `./${basename(task.resourcePath)}`;
+    return {
+        code: [
+            mainChunkReexports ? `export { ${mainChunkReexports} } from "${getRouteChunkModuleId(chunkBasePath, 'main')}";` : null,
+            ...chunkedExports.map((exportName)=>`export { ${exportName} } from "${getRouteChunkModuleId(chunkBasePath, exportName)}";`)
+        ].filter(Boolean).join('\n'),
+        map: null
+    };
+}, createClientOnlyStub = async (task)=>({
+        code: Array.from(await collectClientOnlyStubExportNames(task.code, task.resourcePath, task.resolveExportAllModule)).map((name)=>'default' === name ? 'export default undefined;' : `export const ${name} = undefined;`).join('\n'),
+        map: null
+    }), transformRouteModule = async (task)=>{
+    let code = task.code, defaultExportMatch = code.match(/\n\s{0,}([\w\d_]+)\sas default,?/);
+    defaultExportMatch && 'number' == typeof defaultExportMatch.index && (code = code.slice(0, defaultExportMatch.index) + code.slice(defaultExportMatch.index + defaultExportMatch[0].length) + `\nexport default ${defaultExportMatch[1]};`);
+    let ast = ((code, options = {})=>{
+        let result = parse(code, {
+            ...options,
+            sourceType: options.sourceType ?? 'module',
+            lang: options.lang ?? 'tsx',
+            attachComments: options.attachComments ?? !0
+        }), errors = result.diagnostics.filter((diagnostic)=>'error' === diagnostic.severity);
+        if (errors.length > 0) throw Error(errors.map((error)=>error.message).join('\n'));
+        return result;
+    })(code, {
+        sourceType: 'module'
+    });
+    if ('web' === task.environmentName && !task.ssr && task.isSpaMode) {
+        let resolvedExportNames = collectProgramExportNames(ast.program ?? ast), isRootRoute = task.resourcePath === task.rootRoutePath, relativePath = relative(process.cwd(), task.resourcePath), invalidServerOnly = resolvedExportNames.filter((exp)=>(!isRootRoute || 'loader' !== exp) && SERVER_ONLY_ROUTE_EXPORTS_SET.has(exp));
+        if (invalidServerOnly.length > 0) {
+            let list = invalidServerOnly.map((e)=>`\`${e}\``).join(', ');
+            throw Error(`SPA Mode: ${invalidServerOnly.length} invalid route export(s) in \`${relativePath}\`: ${list}. See https://reactrouter.com/how-to/spa for more information.`);
+        }
+        if (!isRootRoute && resolvedExportNames.includes('HydrateFallback')) throw Error(`SPA Mode: Invalid \`HydrateFallback\` export found in \`${relativePath}\`. \`HydrateFallback\` is only permitted on the root route in SPA Mode. See https://reactrouter.com/how-to/spa for more information.`);
+    }
+    let removedServerOnlyExports = 'web' === task.environmentName && ((ast, exportsToRemove, exportsToRemoveSet = new Set(exportsToRemove))=>{
+        let currentlyLive, removedReferenceCache, isRemovableDeadDeclaration, program = ast.program ?? ast;
+        if (!((program, exportsToRemove)=>{
+            let removesNamedExports = [
+                ...exportsToRemove
+            ].some((name)=>'default' !== name);
+            for (let statement of program.body ?? []){
+                if ('ExportAllDeclaration' === statement.type) {
+                    let exportedName = statement.exported ? getExportedName({
+                        exported: statement.exported
+                    }) : null;
+                    if (exportedName && exportsToRemove.has(exportedName) || !exportedName && removesNamedExports) return !0;
+                    continue;
+                }
+                if ('ExportDefaultDeclaration' === statement.type) {
+                    if (exportsToRemove.has('default')) return !0;
+                    continue;
+                }
+                if ('ExportNamedDeclaration' !== statement.type) continue;
+                for (let specifier of statement.specifiers ?? []){
+                    if ('ExportSpecifier' !== specifier.type) continue;
+                    let exportedName = getExportedName(specifier);
+                    if (exportedName && exportsToRemove.has(exportedName)) return !0;
+                }
+                let declaration = statement.declaration;
+                if (declaration?.type === 'VariableDeclaration') {
+                    for (let declarator of declaration.declarations ?? [])for (let name of getPatternIdentifierNames(declarator.id))if (exportsToRemove.has(name)) return !0;
+                    continue;
+                }
+                if ((declaration?.type === 'FunctionDeclaration' || declaration?.type === 'ClassDeclaration') && declaration.id?.name && exportsToRemove.has(declaration.id.name)) return !0;
+            }
+            return !1;
+        })(program, exportsToRemoveSet)) return !1;
+        let declarationGraph = ((program)=>{
+            let declarationsByNode = new Map(), declarationsByName = new Map(), registerDeclaration = (node, declarationNode, declaredNames)=>{
+                let declaration = {
+                    referencedNames: collectReferencedNames(declarationNode)
+                };
+                for (let name of (declarationsByNode.set(node, declaration), declaredNames)){
+                    let namedDeclarations = declarationsByName.get(name) ?? new Set();
+                    namedDeclarations.add(declaration), declarationsByName.set(name, namedDeclarations);
+                }
+            };
+            for (let statement of [
+                ...program.body ?? []
+            ]){
+                if ('VariableDeclaration' === statement.type) {
+                    for (let declarator of statement.declarations ?? [])registerDeclaration(declarator, declarator, getPatternIdentifierNames(declarator.id));
+                    continue;
+                }
+                ('FunctionDeclaration' === statement.type || 'ClassDeclaration' === statement.type) && registerDeclaration(statement, statement, getDeclaredNames(statement));
+            }
+            return {
+                declarationsByNode,
+                declarationsByName
+            };
+        })(program), previouslyLive = collectLiveTopLevelDeclarations(program, declarationGraph), exportsChanged = !1, removedExportLocalNames = new Set(), removedExportReferencedNames = new Set(), removesNamedExports = exportsToRemove.some((name)=>'default' !== name), trackRemovedExportReferences = (node)=>{
+            if (!node) return;
+            let declaration = declarationGraph.declarationsByNode.get(node);
+            for (let name of declaration?.referencedNames ?? collectReferencedNames(node))removedExportReferencedNames.add(name);
+        };
+        for (let statement of [
+            ...program.body
+        ]){
+            if ('ExportAllDeclaration' === statement.type) {
+                let exportedName = statement.exported ? getExportedName({
+                    exported: statement.exported
+                }) : null;
+                if (exportedName && exportsToRemoveSet.has(exportedName) && (exportsChanged = !0, removeFromArray(program.body, statement)), !exportedName && removesNamedExports) throw Error('Cannot remove named exports from `export *`; use explicit named re-exports.');
+                continue;
+            }
+            if ('ExportNamedDeclaration' === statement.type) {
+                statement.specifiers?.length && (statement.specifiers = statement.specifiers.filter((specifier)=>{
+                    if ('ExportSpecifier' !== specifier.type) return !0;
+                    let exportedName = getExportedName(specifier);
+                    return !(exportedName && exportsToRemoveSet.has(exportedName)) || (exportsChanged = !0, specifier.local?.name && (removedExportLocalNames.add(specifier.local.name), removedExportReferencedNames.add(specifier.local.name)), !1);
+                }), 0 !== statement.specifiers.length || statement.declaration || removeFromArray(program.body, statement));
+                let declaration = statement.declaration;
+                declaration?.type === 'VariableDeclaration' && (declaration.declarations = (declaration.declarations ?? []).filter((declarator)=>{
+                    let id = declarator.id;
+                    return id?.type === 'Identifier' ? !(id.name && exportsToRemoveSet.has(id.name)) || (exportsChanged = !0, removedExportLocalNames.add(id.name), removedExportReferencedNames.add(id.name), trackRemovedExportReferences(declarator), !1) : (id && validateBindingTarget(id, new Set(exportsToRemove)), !0);
+                }), 0 === declaration.declarations.length && removeFromArray(program.body, statement)), (declaration?.type === 'FunctionDeclaration' || declaration?.type === 'ClassDeclaration') && declaration.id?.name && exportsToRemoveSet.has(declaration.id.name) && (exportsChanged = !0, removedExportLocalNames.add(declaration.id.name), removedExportReferencedNames.add(declaration.id.name), trackRemovedExportReferences(statement), removeFromArray(program.body, statement));
+            }
+            if ('ExportDefaultDeclaration' === statement.type && exportsToRemoveSet.has('default')) {
+                exportsChanged = !0;
+                let declaration = statement.declaration;
+                declaration?.type === 'Identifier' && declaration.name ? (removedExportLocalNames.add(declaration.name), removedExportReferencedNames.add(declaration.name)) : declaration?.id?.name && (removedExportLocalNames.add(declaration.id.name), removedExportReferencedNames.add(declaration.id.name)), trackRemovedExportReferences(statement), removeFromArray(program.body, statement);
+            }
+        }
+        for (let statement of [
+            ...program.body
+        ]){
+            let expression = 'ExpressionStatement' === statement.type ? statement.expression : null, left = expression?.type === 'AssignmentExpression' ? expression.left : null;
+            left?.type === 'MemberExpression' && left.object?.type === 'Identifier' && left.object.name && removedExportLocalNames.has(left.object.name) && removeFromArray(program.body, statement);
+        }
+        return exportsChanged && (currentlyLive = collectLiveTopLevelDeclarations(program, declarationGraph), removedReferenceCache = new Map(), isRemovableDeadDeclaration = (node)=>{
+            let declaration = declarationGraph.declarationsByNode.get(node);
+            return !(!declaration || currentlyLive.has(declaration)) && (previouslyLive.has(declaration) || declarationReferencesName(declaration, removedExportReferencedNames, declarationGraph, removedReferenceCache));
+        }, program.body = program.body.filter((statement)=>'VariableDeclaration' === statement.type ? (statement.declarations = (statement.declarations ?? []).filter((declarator)=>!isRemovableDeadDeclaration(declarator)), statement.declarations.length > 0) : !isRemovableDeadDeclaration(statement))), exportsChanged;
+    })(ast, SERVER_ONLY_ROUTE_EXPORTS, SERVER_ONLY_ROUTE_EXPORTS_SET);
+    return ((ast)=>{
+        let program = ast.program ?? ast, usedNames = new Set(), hocs = [], componentWrapperDeclarations = [];
+        function getUid(name) {
+            let uid = `_${name}`, index = 2;
+            for(; usedNames.has(uid) || hasTopLevelBindingName(program, uid);)uid = `_${name}${index++}`;
+            return usedNames.add(uid), uid;
+        }
+        function getHocUid(hocName) {
+            let uid = getUid(hocName);
+            return hocs.push([
+                hocName,
+                uid
+            ]), identifier(uid);
+        }
+        for (let statement of [
+            ...program.body ?? []
+        ]){
+            var name, name1;
+            if ('ExportDefaultDeclaration' === statement.type) {
+                let declaration = statement.declaration;
+                if (!declaration || !0 === declaration.declare || 'TSInterfaceDeclaration' === declaration.type) continue;
+                let uid = getHocUid('withComponentProps');
+                if (('FunctionDeclaration' === declaration.type || 'ClassDeclaration' === declaration.type) && declaration.id?.name) {
+                    let statementIndex = program.body.indexOf(statement);
+                    program.body.splice(statementIndex, 0, declaration), statement.declaration = callExpression(uid, [
+                        identifier(declaration.id.name)
+                    ]);
+                    continue;
+                }
+                statement.declaration = callExpression(uid, [
+                    'FunctionDeclaration' === declaration.type ? toFunctionExpression(declaration) : 'ClassDeclaration' === declaration.type ? toClassExpression(declaration) : declaration
+                ]);
+                continue;
+            }
+            if ('ExportNamedDeclaration' !== statement.type || 'type' === statement.exportKind) continue;
+            let declaration = statement.declaration;
+            if (declaration?.type === 'VariableDeclaration') {
+                for (let declarator of declaration.declarations ?? []){
+                    if (declarator.id?.type !== 'Identifier' || !declarator.init || (name = declarator.id.name, !NAMED_COMPONENT_EXPORTS_SET.has(name))) continue;
+                    let uid = getHocUid(`with${declarator.id.name}Props`);
+                    declarator.init = callExpression(uid, [
+                        declarator.init
+                    ]);
+                }
+                continue;
+            }
+            if ((declaration?.type === 'FunctionDeclaration' || declaration?.type === 'ClassDeclaration') && declaration.id?.name && (name1 = declaration.id.name, NAMED_COMPONENT_EXPORTS_SET.has(name1))) {
+                statement.declaration = function(name, declaration) {
+                    let uid = getHocUid(`with${name}Props`);
+                    return variableDeclaration(name, callExpression(uid, [
+                        'FunctionDeclaration' === declaration.type ? toFunctionExpression(declaration) : 'ClassDeclaration' === declaration.type ? toClassExpression(declaration) : declaration
+                    ]));
+                }(declaration.id.name, declaration);
+                continue;
+            }
+            if (statement.source) {
+                let importSpecifiers = [], sourceWrapperDeclarations = [], wrappedExportSpecifiers = [];
+                if (statement.specifiers = (statement.specifiers ?? []).filter((specifier)=>{
+                    if ('ExportSpecifier' !== specifier.type || 'type' === specifier.exportKind) return !0;
+                    let exportedName = getExportedName(specifier), importedName = getExportedName(specifier.local), componentExportName = exportedName ? getComponentExportName(exportedName) : null;
+                    if (!exportedName || !importedName || !componentExportName) return !0;
+                    let sourceLocalName = getUid(`${exportedName}Source`), wrappedLocalName = getUid(exportedName), uid = getHocUid(`with${componentExportName}Props`);
+                    return importSpecifiers.push({
+                        imported: importedName,
+                        local: sourceLocalName
+                    }), sourceWrapperDeclarations.push(variableDeclaration(wrappedLocalName, callExpression(uid, [
+                        identifier(sourceLocalName)
+                    ]))), wrappedExportSpecifiers.push(exportSpecifier(wrappedLocalName, exportedName)), !1;
+                }), importSpecifiers.length > 0) {
+                    let statementIndex = program.body.indexOf(statement), replacementStatements = [
+                        importDeclaration(importSpecifiers, String(statement.source.value))
+                    ];
+                    statement.specifiers.length > 0 && replacementStatements.push(statement), replacementStatements.push(...sourceWrapperDeclarations), replacementStatements.push(exportNamedDeclaration(wrappedExportSpecifiers)), program.body.splice(statementIndex, 1, ...replacementStatements);
+                }
+                continue;
+            }
+            for (let specifier of statement.specifiers ?? []){
+                if ('ExportSpecifier' !== specifier.type || 'type' === specifier.exportKind) continue;
+                let exportedName = getExportedName(specifier), componentExportName = exportedName ? getComponentExportName(exportedName) : null;
+                if (!exportedName || !componentExportName) continue;
+                let localName = specifier.local?.name;
+                if (!localName) continue;
+                let wrappedLocalName = getUid(exportedName), uid = getHocUid(`with${componentExportName}Props`);
+                componentWrapperDeclarations.push(variableDeclaration(wrappedLocalName, callExpression(uid, [
+                    identifier(localName)
+                ]))), specifier.local = identifier(wrappedLocalName);
+            }
+        }
+        program.body.push(...componentWrapperDeclarations), hocs.length > 0 && program.body.splice(((program)=>{
+            let index = 0;
+            for (let statement of program.body ?? []){
+                if ('ExpressionStatement' !== statement.type || void 0 === statement.directive && statement.expression?.type !== 'Literal') break;
+                index += 1;
+            }
+            return index;
+        })(program), 0, importDeclaration(hocs.map(([name, local])=>({
+                imported: name,
+                local
+            })), 'virtual/react-router/with-props'));
+    })(ast), removedServerOnlyExports && ((ast)=>{
+        let program = ast.program ?? ast, referenced = collectReferencedNames(program);
+        for (let statement of [
+            ...program.body
+        ])'ImportDeclaration' === statement.type && 0 !== (statement.specifiers ?? []).length && (statement.specifiers = (statement.specifiers ?? []).filter((specifier)=>'type' !== specifier.importKind && (!specifier.local?.name || referenced.has(specifier.local.name))), 0 === statement.specifiers.length && removeFromArray(program.body, statement));
+    })(ast), ((ast, options = {})=>{
+        let result = 'program' in ast ? ast : {
+            program: ast,
+            lineStarts: []
+        }, generated = print(result.program, {
+            comments: !0,
+            sourceMaps: options.sourceMaps ? {
+                lineStarts: result.lineStarts,
+                file: options.filename,
+                sourceFileName: options.sourceFileName
+            } : void 0
+        });
+        if (generated.errors.length > 0) throw Error(generated.errors.map((error)=>error.message).join('\n'));
+        let map = generated.map ? {
+            ...generated.map,
+            file: generated.map.file ?? options.filename ?? '',
+            sourceRoot: generated.map.sourceRoot ?? void 0,
+            sourcesContent: generated.map.sourcesContent?.map((source)=>source ?? '') ?? void 0
+        } : null;
+        return {
+            code: generated.code,
+            map
+        };
+    })(ast, {
+        sourceMaps: task.sourceMaps,
+        filename: task.resource,
+        sourceFileName: task.resourcePath
+    });
+}, executeRouteTransformTask = async (task, options)=>{
+    switch(task.kind){
+        case 'routeClientEntry':
+            return createRouteClientEntryArtifact({
+                code: task.code,
+                resourcePath: task.resourcePath,
+                environmentName: task.environmentName,
+                isBuild: task.isBuild,
+                routeChunkCache: getRouteChunkCache(options),
+                routeChunkConfig: task.routeChunkConfig
+            });
+        case 'routeChunk':
+            return createRouteChunkArtifact({
+                code: task.code,
+                resource: task.resource,
+                resourcePath: task.resourcePath,
+                isBuild: task.isBuild,
+                routeChunkCache: getRouteChunkCache(options),
+                routeChunkConfig: task.routeChunkConfig
+            });
+        case 'splitRouteExports':
+            return splitRouteExports(task, options);
+        case 'clientOnlyStub':
+            return createClientOnlyStub(task);
+        case 'routeModule':
+            return transformRouteModule(task);
+    }
+};
+export { BUILD_CLIENT_ROUTE_QUERY_STRING, CLIENT_EXPORTS, JS_EXTENSIONS, PLUGIN_NAME, SERVER_EXPORTS, buildManifestChunkValidity, combineURLs, createBundlerRouteExportResolver, createEmptyRouteChunkByExportName, createRouteId, detectRouteChunksIfEnabled, executeRouteTransformTask, findEntryFile, generateWithProps, getRouteChunkEntryName, getRouteChunkModuleId, getRouteModuleAnalysis, normalizeAssetPrefix, routeChunkExportNames, setBoundedCacheEntry, validateRouteChunks };