rsbuild-plugin-react-router 0.5.0 → 0.6.0

package/dist/511.js

@@ -1,12 +1,12 @@
 import { basename, dirname, normalize, relative, resolve } from "pathe";
 import { existsSync, readFileSync, statSync } from "node:fs";
+import { createRequire } from "node:module";
 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 = [
+let PLUGIN_NAME = 'rsbuild:react-router', DEFAULT_JS_DIST_PATH = 'static/js', JS_EXTENSIONS = [
     '.tsx',
     '.ts',
     '.jsx',
@@ -18,14 +18,16 @@ let PLUGIN_NAME = 'rsbuild:react-router', JS_EXTENSIONS = [
     'action',
     'middleware',
     'headers'
-], SERVER_ONLY_ROUTE_EXPORTS_SET = new Set(SERVER_ONLY_ROUTE_EXPORTS), CLIENT_ROUTE_EXPORTS_SET = new Set([
+], SERVER_ONLY_ROUTE_EXPORTS_SET = new Set(SERVER_ONLY_ROUTE_EXPORTS), CLIENT_NON_COMPONENT_EXPORTS = [
     'clientAction',
     'clientLoader',
     'clientMiddleware',
     'handle',
     'meta',
     'links',
-    'shouldRevalidate',
+    'shouldRevalidate'
+], CLIENT_ROUTE_EXPORTS_SET = new Set([
+    ...CLIENT_NON_COMPONENT_EXPORTS,
     'default',
     'ErrorBoundary',
     'HydrateFallback',
@@ -50,7 +52,7 @@ let PLUGIN_NAME = 'rsbuild:react-router', JS_EXTENSIONS = [
     links: 'links',
     meta: 'meta',
     shouldRevalidate: 'shouldRevalidate'
-}, getPatternIdentifierNames = (pattern, names = new Set())=>{
+}, SPA_FALLBACK_HTML_FILE = '__spa-fallback.html', getProgram = (ast)=>ast.program ?? ast, 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);
@@ -215,22 +217,115 @@ let PLUGIN_NAME = 'rsbuild:react-router', JS_EXTENSIONS = [
         }
     }
     return cache.set(declaration, !1), !1;
-};
-function toFunctionExpression(decl) {
-    return {
-        ...decl,
-        type: 'FunctionExpression',
-        declare: void 0
+}, removeExports = (ast, exportsToRemove, exportsToRemoveSet = new Set(exportsToRemove), options = {})=>{
+    let currentlyLive, removedReferenceCache, isRemovableDeadDeclaration, program = getProgram(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);
     };
-}
-function toClassExpression(decl) {
-    return {
+    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 && !1 !== options.pruneDeadDeclarations && (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;
+}, removeUnusedImports = (ast)=>{
+    let program = getProgram(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));
+}, toExpression = (decl, type)=>({
         ...decl,
-        type: 'ClassExpression',
+        type,
         declare: void 0
-    };
-}
-let getComponentExportName = (exportedName)=>{
+    }), 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)=>{
@@ -250,13 +345,40 @@ let getComponentExportName = (exportedName)=>{
         if (declaration && declarationIncludesName(declaration, name)) return !0;
     }
     return !1;
-};
+}, requireFromApp = createRequire(resolve(process.cwd(), 'package.json')), resolveAppPackagePath = (specifier)=>{
+    try {
+        return requireFromApp.resolve(specifier);
+    } catch  {
+        return;
+    }
+}, parseVersionMajorMinor = (version)=>{
+    let match = version?.match(/^(\d+)\.(\d+)\./);
+    if (match) return {
+        major: Number(match[1]),
+        minor: Number(match[2])
+    };
+}, packageVersionCache = new Map(), getPackageVersion = (packageName, resolvePackagePath = resolveAppPackagePath)=>{
+    let cacheable = resolvePackagePath === resolveAppPackagePath;
+    if (cacheable && packageVersionCache.has(packageName)) return packageVersionCache.get(packageName);
+    let packageJsonPath = resolvePackagePath(`${packageName}/package.json`);
+    if (packageJsonPath) try {
+        let packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8')), version = 'string' == typeof packageJson.version ? packageJson.version : void 0;
+        return cacheable && packageVersionCache.set(packageName, version), version;
+    } catch  {
+        cacheable && packageVersionCache.set(packageName, void 0);
+        return;
+    }
+}, escapeHtml = (value)=>value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
 function combineURLs(baseURL, relativeURL) {
     return relativeURL ? `${baseURL.replace(/\/+$/, '')}/${relativeURL.replace(/^\/+/, '')}` : baseURL;
 }
 function normalizeAssetPrefix(assetPrefix) {
     return assetPrefix && 'auto' !== assetPrefix ? assetPrefix.endsWith('/') ? assetPrefix : `${assetPrefix}/` : '/';
 }
+function resolveEffectiveAssetPrefix(config) {
+    let outputPrefix = 'string' == typeof config.output?.assetPrefix ? config.output.assetPrefix : void 0;
+    return config.isBuild ? normalizeAssetPrefix(outputPrefix) : normalizeAssetPrefix(('string' == typeof config.dev?.assetPrefix ? config.dev.assetPrefix : void 0) ?? outputPrefix);
+}
 function createRouteId(file) {
     return normalize(file.replace(/\.[^/.]+$/, ''));
 }
@@ -269,41 +391,15 @@ function findEntryFile(basePath) {
 }
 function generateWithProps() {
     return `
-    import { createElement as h } from "react";
-    import { useActionData, useLoaderData, useMatches, useParams, useRouteError } from "react-router";
+    import {
+      UNSAFE_withComponentProps,
+      UNSAFE_withErrorBoundaryProps,
+      UNSAFE_withHydrateFallbackProps,
+    } 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);
-      };
-    }
+    export const withComponentProps = UNSAFE_withComponentProps;
+    export const withHydrateFallbackProps = UNSAFE_withHydrateFallbackProps;
+    export const withErrorBoundaryProps = UNSAFE_withErrorBoundaryProps;
   `;
 }
 let routeChunkExportNames = [
@@ -339,7 +435,7 @@ let mightContainRouteChunkExportName = (source)=>routeChunkExportNames.some((exp
         value,
         version
     }), value;
-}, analyzeCode = (code, cache, cacheKey)=>getOrSetFromCache(cache, `${cacheKey}::analyzeCode`, code, ()=>{
+}, hasCachedValue = (cache, key, version)=>cache.get(key)?.version === version, analyzeCode = (code, cache, cacheKey)=>getOrSetFromCache(cache, `${cacheKey}::analyzeCode`, code, ()=>{
         let module = new Analyzer().addFile(cacheKey, code, {
             lang: 'tsx',
             sourceType: 'module',
@@ -350,10 +446,19 @@ let mightContainRouteChunkExportName = (source)=>routeChunkExportNames.some((exp
             module,
             program: module.ast
         };
-    }), route_chunks_getExportedName = (exported)=>'Identifier' === exported.type ? exported.name : String(exported.value), setsIntersect = (set1, set2)=>{
+    }), isTopLevelExportedVariableDeclarator = (module, node)=>{
+    let declaration = module.parentOf(node);
+    if (declaration?.type !== 'VariableDeclaration') return !1;
+    let statement = module.parentOf(declaration);
+    return statement?.type === 'ExportNamedDeclaration';
+}, 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;
+}, isEntryClientImport = (source, importer)=>{
+    if (!source.startsWith('.') && !source.startsWith('/')) return !1;
+    let resolved = normalize(resolve('/', dirname(importer), source));
+    return /(?:^|\/)entry\.client(?:\.[cm]?[jt]sx?)?$/.test(resolved);
 }, 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);
@@ -383,6 +488,7 @@ let mightContainRouteChunkExportName = (source)=>routeChunkExportNames.some((exp
                 topLevelStatements: new Set(),
                 topLevelNonModuleStatements: new Set(),
                 importedIdentifierNames: new Set(),
+                importSources: new Set(),
                 exportedVariableDeclarators: new Set()
             }, visitedSymbols = new Set(), scannedNodes = new Set(), scanNode = (node)=>{
                 scannedNodes.has(node) || (scannedNodes.add(node), external_yuku_parser_walk(node, {
@@ -392,12 +498,15 @@ let mightContainRouteChunkExportName = (source)=>routeChunkExportNames.some((exp
                     }
                 }));
             }, visitSymbol = (symbol)=>{
-                if (!visitedSymbols.has(symbol)) {
-                    for (let declaration of (visitedSymbols.add(symbol), symbol.declarations)){
+                if (!visitedSymbols.has(symbol) && (visitedSymbols.add(symbol), 0 !== symbol.declarations.length)) {
+                    for (let declaration of symbol.declarations){
                         let statement = addCachedTopLevelStatement(dependencies, declaration);
-                        'ImportDeclaration' === statement.type && dependencies.importedIdentifierNames.add(symbol.name);
+                        if ('ImportDeclaration' === statement.type) {
+                            dependencies.importedIdentifierNames.add(symbol.name), 'string' == typeof statement.source?.value && dependencies.importSources.add(statement.source.value);
+                            return;
+                        }
                         let declarator = getCachedVariableDeclaratorForNode(declaration);
-                        declarator && 'ExportNamedDeclaration' === getCachedTopLevelStatementForNode(declarator).type && dependencies.exportedVariableDeclarators.add(declarator), scanNode(declarator ?? statement);
+                        declarator && isTopLevelExportedVariableDeclarator(module, declarator) && dependencies.exportedVariableDeclarators.add(declarator), scanNode(declarator ?? statement);
                     }
                     for (let reference of symbol.references){
                         let statement = addCachedTopLevelStatement(dependencies, reference.node);
@@ -409,19 +518,25 @@ let mightContainRouteChunkExportName = (source)=>routeChunkExportNames.some((exp
         };
         for (let exp of module.exports)exp.typeOnly || exp.isStar || exp.isExportEquals || handleExport(exp.name, exp.node, exp.local ?? null);
         return exportDependencies;
+    }), isExportChunkable = (exportName, exportDependencies, importer)=>{
+    let dependencies = exportDependencies.get(exportName);
+    if (!dependencies || 'clientLoader' === exportName && hasHydrateAssignment(dependencies) || 'clientLoader' === exportName && ((dependencies, importer)=>{
+        for (let source of dependencies.importSources)if (isEntryClientImport(source, importer)) return !0;
+        return !1;
+    })(dependencies, importer)) 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;
+}, hasHydrateAssignment = (dependencies)=>Array.from(dependencies.topLevelNonModuleStatements).some((statement)=>{
+        let expression = statement.expression, left = expression?.left;
+        return 'ExpressionStatement' === statement.type && expression?.type === 'AssignmentExpression' && left?.type === 'MemberExpression' && left.object?.type === 'Identifier' && 'clientLoader' === left.object.name && left.property?.type === 'Identifier' && 'hydrate' === left.property.name;
     }), 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)=>{
+        return createRouteChunkExportMap((exportName)=>isExportChunkable(exportName, exportDependencies, cacheKey));
+    }), hasChunkableExport = (code, exportName, cache, cacheKey)=>routeChunkExportNames.includes(exportName) ? getChunkableExportMap(code, cache, cacheKey)[exportName] : isExportChunkable(exportName, getExportDependencies(code, cache, cacheKey), cacheKey), generateCode = (program)=>{
     if (0 === program.body.length) return;
     let result = print(program, {
         comments: !0
@@ -436,7 +551,7 @@ let mightContainRouteChunkExportName = (source)=>routeChunkExportNames.some((exp
         specifiers
     } : null;
 }, getChunkedExport = (code, exportName, cache, cacheKey)=>getOrSetFromCache(cache, `${cacheKey}::getChunkedExport::${exportName}`, code, ()=>{
-        if (!routeChunkExportNames.includes(exportName) || !getChunkableExportMap(code, cache, cacheKey)[exportName]) return;
+        if (!hasChunkableExport(code, exportName, cache, cacheKey)) 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)=>{
@@ -468,77 +583,90 @@ let mightContainRouteChunkExportName = (source)=>routeChunkExportNames.some((exp
             ...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)=>{
+    }), getChunkedExportCacheKey = (cacheKey, exportName)=>`${cacheKey}::getChunkedExport::${exportName}`, hasCachedChunkedExport = (code, exportName, cache, cacheKey)=>hasCachedValue(cache, getChunkedExportCacheKey(cacheKey, exportName), code), getSharedChunkedExports = (exportDependencies, cacheKey)=>Array.from(exportDependencies.keys()).filter((exportName)=>'default' !== exportName && !routeChunkExportNames.includes(exportName) && !SERVER_ONLY_ROUTE_EXPORTS_SET.has(exportName) && isExportChunkable(exportName, exportDependencies, cacheKey)).sort(), getChunkedExportNames = (code, cache, cacheKey)=>{
+    let exportDependencies = getExportDependencies(code, cache, cacheKey), routeChunkedExports = routeChunkExportNames.filter((exportName)=>isExportChunkable(exportName, exportDependencies, cacheKey));
+    return 0 === routeChunkedExports.length ? [] : [
+        ...routeChunkedExports,
+        ...getSharedChunkedExports(exportDependencies, cacheKey)
+    ];
+}, detectRouteChunks = (code, cache, cacheKey)=>{
+    let analysisCache = cache ?? new Map(), exportDependencies = getExportDependencies(code, analysisCache, cacheKey), hasRouteChunkByExportName = getChunkableExportMap(code, analysisCache, cacheKey), chunkedExports = Object.entries(hasRouteChunkByExportName).filter(([, isChunked])=>isChunked).map(([exportName])=>exportName), sharedChunkedExports = chunkedExports.length > 0 ? getSharedChunkedExports(exportDependencies, cacheKey) : [], hasRouteChunks = chunkedExports.length > 0 || sharedChunkedExports.length > 0;
+    return {
+        exportNames: Array.from(exportDependencies.keys()),
+        hasRouteChunks,
+        hasRouteChunkByExportName,
+        chunkedExports,
+        sharedChunkedExports
+    };
+}, getRouteChunkModuleId = (filePath, chunkName)=>`${filePath}${routeChunkQueryStrings[chunkName] ?? `${routeChunkQueryStringPrefix}${encodeURIComponent(chunkName)}`}`, getRouteChunkNameFromModuleId = (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 || /^[A-Za-z_$][\w$]*$/.test(chunkName) ? chunkName : null;
+}, 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 {
+}, 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)=>shouldAnalyzeRouteChunks(config, id, code) ? detectRouteChunks(code, cache, normalizeRelativeFilePath(id, config.appDirectory)) : {
         exportNames: [],
         chunkedExports: [],
+        sharedChunkedExports: [],
         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)=>{
+    }, 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 ('main' === chunkName) {
+            let exportNames, serverOnlyExports = Array.from(getExportDependencies(code, analysisCache, cacheKey).keys()).filter((exportName)=>SERVER_ONLY_ROUTE_EXPORTS_SET.has(exportName));
+            return exportNames = [
+                ...getChunkedExportNames(code, analysisCache, cacheKey),
+                ...serverOnlyExports
+            ], getOrSetFromCache(analysisCache, `${cacheKey}::omitChunkedExports::${exportNames.join(',')}`, code, ()=>{
+                let exportNameSet = new Set(exportNames), isOmitted = (exportName)=>exportNameSet.has(exportName) && hasChunkableExport(code, exportName, analysisCache, cacheKey), 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);
                 }
-                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;
+                for (let retainedExportName of retainedExportNames){
+                    let dependencies = exportDependencies.get(retainedExportName);
+                    if (dependencies) for (let importedName of dependencies.importedIdentifierNames)retainedImportedIdentifierNames.add(importedName);
                 }
-                throw Error('Unknown node type');
-            }).filter(Boolean);
-            return generateCode({
-                ...program,
-                body
+                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));
+            for (let exportName of getChunkedExportNames(code, cache, cacheKey))hasChunkableExport(code, exportName, cache, cacheKey) && !hasCachedChunkedExport(code, exportName, cache, cacheKey) && (hasCachedValue(cache, getChunkedExportCacheKey(cacheKey, exportName), code) || 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 })=>{
@@ -563,7 +691,7 @@ let mightContainRouteChunkExportName = (source)=>routeChunkExportNames.some((exp
         sourceType: 'module',
         lang
     }), errors = getParseErrors(result);
-    if (0 === errors.length) return result.program ?? result;
+    if (0 === errors.length) return getProgram(result);
     if (!sourcePath || 'ts' !== lang && 'tsx' !== lang) throw Error(getParseErrorMessage(errors));
     let normalizedResult = parse(rspack.experiments.swc.transformSync(code, {
         filename: sourcePath,
@@ -578,7 +706,7 @@ let mightContainRouteChunkExportName = (source)=>routeChunkExportNames.some((exp
         lang: 'js'
     }), normalizedErrors = getParseErrors(normalizedResult);
     if (normalizedErrors.length > 0) throw Error(getParseErrorMessage(normalizedErrors));
-    return normalizedResult.program ?? normalizedResult;
+    return getProgram(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)=>{
@@ -628,22 +756,54 @@ let mightContainRouteChunkExportName = (source)=>routeChunkExportNames.some((exp
     })(), ()=>{
         exportInfoCache.get(cacheKey) === trackedExportInfo && exportInfoCache.delete(cacheKey);
     }), setBoundedCacheEntry(exportInfoCache, cacheKey, trackedExportInfo, 2048), trackedExportInfo);
+}, analyzeRouteModuleCode = (code, resourcePath)=>{
+    let program = parseProgram(code, resourcePath);
+    return {
+        code,
+        exports: collectProgramExportNames(program),
+        exportAllModules: collectExportAllModules(program)
+    };
 }, 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)
-        };
-    })(), ()=>{
+    return cached?.mtimeMs === stats.mtimeMs && cached.size === stats.size ? cached.analysis : (trackedAnalysis = cachePromiseOnReject((async ()=>analyzeRouteModuleCode(await readFile(resourcePath, 'utf8'), resourcePath))(), ()=>{
         routeModuleAnalysisCache.get(resourcePath)?.analysis === trackedAnalysis && routeModuleAnalysisCache.delete(resourcePath);
     }), setBoundedCacheEntry(routeModuleAnalysisCache, resourcePath, {
         mtimeMs: stats.mtimeMs,
         size: stats.size,
         analysis: trackedAnalysis
     }, 2048), trackedAnalysis);
+}, yuku_parse = (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;
+}, generate = (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
+    };
 }, tryStat = (path)=>statSync(path, {
         throwIfNoEntry: !1
     }) ?? null, PACKAGE_IMPORT_CONDITIONS = new Set([
@@ -764,56 +924,72 @@ let mightContainRouteChunkExportName = (source)=>routeChunkExportNames.some((exp
     'hasClientMiddleware',
     'hasErrorBoundary',
     'hasLoader'
-], HMR_FLAG_EXPORT_NAME = {
-    hasAction: SERVER_EXPORTS.action,
-    hasClientAction: CLIENT_EXPORTS.clientAction,
-    hasClientLoader: CLIENT_EXPORTS.clientLoader,
-    hasClientMiddleware: CLIENT_EXPORTS.clientMiddleware,
-    hasErrorBoundary: CLIENT_EXPORTS.ErrorBoundary,
-    hasLoader: SERVER_EXPORTS.loader
-}, createRouteClientEntryArtifact = async ({ code, resourcePath, environmentName, isBuild, routeChunkCache, routeChunkConfig, routeId, devHmr })=>{
-    let isServer = 'node' === environmentName, routeChunkInfo = !isServer && isBuild && shouldAnalyzeRouteChunks(routeChunkConfig, resourcePath, code) ? await detectRouteChunksIfEnabled(routeChunkCache, routeChunkConfig, resourcePath, code) : null;
+], createRouteClientEntryArtifact = async ({ code, resourcePath, environmentName, isBuild, routeChunkCache, routeChunkConfig, routeId, devHmr })=>{
+    let isServer = 'node' === environmentName, routeChunkInfo = !isServer && isBuild && shouldAnalyzeRouteChunks(routeChunkConfig, resourcePath, code) ? await detectRouteChunksIfEnabled(routeChunkCache, routeChunkConfig, resourcePath, code) : null, exportNames = routeChunkInfo?.exportNames ?? await getExportNames(code, resourcePath);
     return {
-        code: (({ exportNames, chunkedExports, isServer, resourcePath, routeId, devHmr })=>{
-            let exports, flags, 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`, reexportCode = `export { ${reexports.join(', ')} } from ${JSON.stringify(target)};`;
-            return !devHmr || isServer || void 0 === routeId ? reexportCode : reexportCode + (({ routeId, target, acceptTarget, flags })=>{
-                let targetJson = JSON.stringify(target), acceptTargetJson = JSON.stringify(acceptTarget);
+        code: (({ exportNames, chunkedExports, sharedChunkedExports = [], isServer, resourcePath, routeId, devHmr })=>{
+            let exports, chunkedExportSet = chunkedExports.length > 0 || sharedChunkedExports.length > 0 ? new Set([
+                ...chunkedExports,
+                ...sharedChunkedExports
+            ]) : void 0, routeRequestPath = `./${basename(resourcePath)}`, target = isServer ? routeRequestPath : chunkedExports.length > 0 ? getRouteChunkModuleId(routeRequestPath, 'main') : `${routeRequestPath}?react-router-route`, reexports = exportNames.filter((exportName)=>(({ chunkedExportSet, exportName, isServer })=>!chunkedExportSet?.has(exportName) && (isServer ? CLIENT_ROUTE_EXPORTS_SET.has(exportName) || SERVER_ONLY_ROUTE_EXPORTS_SET.has(exportName) : CLIENT_ROUTE_EXPORTS_SET.has(exportName)))({
+                    chunkedExportSet,
+                    exportName,
+                    isServer
+                })).sort(), reexportCode = [
+                reexports.length > 0 ? `export { ${reexports.join(', ')} } from ${JSON.stringify(target)};` : null,
+                ...sharedChunkedExports.map((exportName)=>`export { ${exportName} } from ${JSON.stringify(getRouteChunkModuleId(routeRequestPath, exportName))};`)
+            ].filter(Boolean).join('\n');
+            return !devHmr || isServer || void 0 === routeId ? reexportCode : reexportCode + (({ routeId, target, metadata })=>{
+                let targetJson = JSON.stringify(target);
                 return `
-import * as __rrm from ${targetJson};
+import * as __reactRouterRouteModule from ${targetJson};
 import {
-  registerReactRouterRouteExports as __rrr,
-  scheduleReactRouterRouteUpdate as __rru,
+  registerReactRouterRouteExports as __reactRouterRegisterRouteExports,
+  scheduleReactRouterRouteUpdate as __reactRouterScheduleRouteUpdate,
 } from "virtual/react-router/hmr-runtime";
 
-const __rrid = ${JSON.stringify(routeId)};
-const __rrf = ${flags};
-const __rrg = () => __rrm;
-const __rru0 = () => {
-  __rrr(__rrid, __rrm);
-  __rru(__rrid, __rrf, __rrg);
-};
+const __reactRouterRouteId = ${JSON.stringify(routeId)};
+const __reactRouterRouteMetadata = ${JSON.stringify(metadata)};
+const __reactRouterGetRouteModule = () => __reactRouterRouteModule;
 
-__rrr(__rrid, __rrm);
+__reactRouterRegisterRouteExports(
+  __reactRouterRouteId,
+  __reactRouterRouteModule
+);
 
 if (import.meta.webpackHot) {
-  const __rrh = import.meta.webpackHot;
-  __rrh.accept(${acceptTargetJson}, __rru0);
-  __rrh.accept();
-  __rrh.dispose(data => { data.__rr = true; });
-  if (__rrh.data && __rrh.data.__rr) __rru0();
+  import.meta.webpackHot.accept();
+  import.meta.webpackHot.dispose(data => {
+    data.__reactRouterRouteShim = true;
+  });
+  if (
+    import.meta.webpackHot.data &&
+    import.meta.webpackHot.data.__reactRouterRouteShim
+  ) {
+    __reactRouterScheduleRouteUpdate(
+      __reactRouterRouteId,
+      __reactRouterRouteMetadata,
+      __reactRouterGetRouteModule
+    );
+  }
 }
 `;
             })({
                 routeId,
                 target,
-                acceptTarget: `./${basename(resourcePath)}?react-router-route`,
-                flags: (exports = new Set(exportNames), flags = 0, HMR_PATCHABLE_ROUTE_FLAGS.forEach((flag, index)=>{
-                    exports.has(HMR_FLAG_EXPORT_NAME[flag]) && (flags |= 1 << index);
-                }), flags)
+                metadata: {
+                    hasAction: (exports = new Set(exportNames)).has(SERVER_EXPORTS.action),
+                    hasClientAction: exports.has(CLIENT_EXPORTS.clientAction),
+                    hasClientLoader: exports.has(CLIENT_EXPORTS.clientLoader),
+                    hasClientMiddleware: exports.has(CLIENT_EXPORTS.clientMiddleware),
+                    hasErrorBoundary: exports.has(CLIENT_EXPORTS.ErrorBoundary),
+                    hasLoader: exports.has(SERVER_EXPORTS.loader)
+                }
             });
         })({
-            exportNames: routeChunkInfo?.exportNames ?? await getExportNames(code, resourcePath),
+            exportNames,
             chunkedExports: routeChunkInfo?.chunkedExports ?? [],
+            sharedChunkedExports: routeChunkInfo?.sharedChunkedExports ?? [],
             isServer,
             resourcePath,
             routeId,
@@ -826,12 +1002,7 @@ if (import.meta.webpackHot) {
         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);
+    let chunkName = getRouteChunkNameFromModuleId(resource);
     if (!chunkName) throw Error(`Invalid route chunk name in "${resource}"`);
     if ('main' !== chunkName && !code.includes(chunkName)) return {
         code: 'export {};',
@@ -910,131 +1081,27 @@ if (import.meta.webpackHot) {
                 return !1;
         }
     })(declarator.init) && names.add(declarator.id.name);
+}, validateSpaModeRouteExports = ({ exportNames, resourcePath, rootRoutePath })=>{
+    let isRootRoute = resourcePath === rootRoutePath, relativePath = relative(process.cwd(), resourcePath), invalidServerOnly = exportNames.filter((exp)=>(!isRootRoute || 'loader' !== exp) && SERVER_ONLY_ROUTE_EXPORTS_SET.has(exp));
+    if (invalidServerOnly.length > 0) {
+        let list = invalidServerOnly.map((exp)=>`\`${exp}\``).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 && exportNames.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.`);
 }, 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, {
+    let ast = yuku_parse(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);
+    'web' === task.environmentName && !task.ssr && task.isSpaMode && validateSpaModeRouteExports({
+        exportNames: collectProgramExportNames(getProgram(ast)),
+        resourcePath: task.resourcePath,
+        rootRoutePath: task.rootRoutePath
+    });
+    let removedServerOnlyExports = 'web' === task.environmentName && removeExports(ast, SERVER_ONLY_ROUTE_EXPORTS, SERVER_ONLY_ROUTE_EXPORTS_SET);
     ((ast)=>{
-        let program = ast.program ?? ast, usedNames = new Set(), hocs = [], componentWrapperDeclarations = [];
+        let program = getProgram(ast), usedNames = new Set(), hocs = [], componentWrapperDeclarations = [];
         function getUid(name) {
             let uid = `_${name}`, index = 2;
             for(; usedNames.has(uid) || hasTopLevelBindingName(program, uid);)uid = `_${name}${index++}`;
@@ -1043,7 +1110,7 @@ if (import.meta.webpackHot) {
         function getHocUid(hocName) {
             let uid = getUid(hocName);
             return hocs.push([
-                hocName,
+                `UNSAFE_${hocName}`,
                 uid
             ]), identifier(uid);
         }
@@ -1063,7 +1130,7 @@ if (import.meta.webpackHot) {
                     continue;
                 }
                 statement.declaration = callExpression(uid, [
-                    'FunctionDeclaration' === declaration.type ? toFunctionExpression(declaration) : 'ClassDeclaration' === declaration.type ? toClassExpression(declaration) : declaration
+                    'FunctionDeclaration' === declaration.type ? toExpression(declaration, 'FunctionExpression') : 'ClassDeclaration' === declaration.type ? toExpression(declaration, 'ClassExpression') : declaration
                 ]);
                 continue;
             }
@@ -1083,7 +1150,7 @@ if (import.meta.webpackHot) {
                 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
+                        'FunctionDeclaration' === declaration.type ? toExpression(declaration, 'FunctionExpression') : 'ClassDeclaration' === declaration.type ? toExpression(declaration, 'ClassExpression') : declaration
                     ]));
                 }(declaration.id.name, declaration);
                 continue;
@@ -1131,37 +1198,9 @@ if (import.meta.webpackHot) {
         })(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);
-    let result = ((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, {
+            })), 'react-router'));
+    })(ast), removedServerOnlyExports && removeUnusedImports(ast);
+    let result = generate(ast, {
         sourceMaps: task.sourceMaps,
         filename: task.resource,
         sourceFileName: task.resourcePath
@@ -1184,7 +1223,7 @@ if (import.meta.webpackHot) {
             return [
                 ...declared
             ].filter((name)=>!registered.has(name));
-        })(ast.program ?? ast);
+        })(getProgram(ast));
         unregisteredComponents.length > 0 && (result.code += (registrations = unregisteredComponents.map((name)=>`  if (typeof ${name} === 'function' || (typeof ${name} === 'object' && ${name} !== null)) $RefreshReg$(${name}, ${JSON.stringify(name)});`).join('\n'), `\nif (typeof $RefreshReg$ === 'function') {\n${registrations}\n}\n`));
     }
     return result;
@@ -1309,4 +1348,4 @@ if (import.meta.webpackHot) {
         }
     };
 };
-export { BUILD_CLIENT_ROUTE_QUERY_STRING, CLIENT_EXPORTS, HMR_PATCHABLE_ROUTE_FLAGS, JS_EXTENSIONS, PLUGIN_NAME, SERVER_EXPORTS, buildManifestChunkValidity, combineURLs, createBundlerRouteExportResolver, createEmptyRouteChunkByExportName, createReactRouterPerformanceProfiler, createRouteId, detectRouteChunksIfEnabled, executeRouteTransformTask, findEntryFile, generateWithProps, getRouteChunkEntryName, getRouteChunkModuleId, getRouteModuleAnalysis, normalizeAssetPrefix, roundMs, routeChunkExportNames, validateRouteChunks };
+export { BUILD_CLIENT_ROUTE_QUERY_STRING, CLIENT_EXPORTS, CLIENT_NON_COMPONENT_EXPORTS, DEFAULT_JS_DIST_PATH, HMR_PATCHABLE_ROUTE_FLAGS, JS_EXTENSIONS, PLUGIN_NAME, SERVER_EXPORTS, SERVER_ONLY_ROUTE_EXPORTS, SPA_FALLBACK_HTML_FILE, analyzeRouteModuleCode, buildManifestChunkValidity, collectReferencedNames, combineURLs, createBundlerRouteExportResolver, createEmptyRouteChunkByExportName, createReactRouterPerformanceProfiler, createRouteId, detectRouteChunks, detectRouteChunksIfEnabled, escapeHtml, executeRouteTransformTask, findEntryFile, generate, generateWithProps, getExportNames, getExportedName, getPackageVersion, getPatternIdentifierNames, getProgram, getRouteChunkEntryName, getRouteChunkModuleId, getRouteChunkNameFromModuleId, getRouteModuleAnalysis, normalizeAssetPrefix, parseVersionMajorMinor, removeExports, removeUnusedImports, resolveAppPackagePath, resolveEffectiveAssetPrefix, roundMs, routeChunkExportNames, validateRouteChunks, validateSpaModeRouteExports, yuku_parse };