@bleedingdev/modern-js-plugin-tanstack 3.5.0-ultramodern.9 → 3.5.0-ultramodern.91

package/dist/cjs/runtime/routeTree/components.js

@@ -0,0 +1,102 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    pickRouteModuleComponent: ()=>pickRouteModuleComponent,
+    toErrorComponent: ()=>toErrorComponent,
+    toPendingComponent: ()=>toPendingComponent,
+    toRouteComponent: ()=>toRouteComponent
+});
+const external_react_namespaceObject = require("react");
+function pickRouteModuleComponent(routeModule, seen = new Set()) {
+    if ('function' == typeof routeModule || routeModule && 'object' == typeof routeModule && '$$typeof' in routeModule) return routeModule;
+    if (!routeModule || 'object' != typeof routeModule) return;
+    if (seen.has(routeModule)) return;
+    seen.add(routeModule);
+    const module = routeModule;
+    for (const candidate of [
+        module.default,
+        module.Component
+    ]){
+        const component = pickRouteModuleComponent(candidate, seen);
+        if (component) return component;
+    }
+}
+function createServerLazyImportComponent(lazyImport, fallbackComponent) {
+    if ("u" > typeof document) return fallbackComponent;
+    let resolvedComponent;
+    let pendingLoad;
+    const load = async ()=>{
+        if (resolvedComponent) return resolvedComponent;
+        const routeModule = await lazyImport();
+        const component = pickRouteModuleComponent(routeModule);
+        if (component) resolvedComponent = component;
+        return resolvedComponent;
+    };
+    const Component = (props)=>{
+        if (resolvedComponent) return (0, external_react_namespaceObject.createElement)(resolvedComponent, props);
+        pendingLoad ||= load();
+        throw pendingLoad;
+    };
+    Component.load = load;
+    Component.preload = load;
+    return Component;
+}
+function toRouteComponent(routeObject, options = {}) {
+    const route = routeObject;
+    const lazyImport = 'function' == typeof route.lazyImport ? route.lazyImport : void 0;
+    const routeComponent = route.Component || route.component;
+    const fallbackComponent = routeComponent ? routeComponent : route.element ? ()=>route.element : void 0;
+    if (lazyImport && fallbackComponent) return createServerLazyImportComponent(lazyImport, fallbackComponent);
+    if (routeComponent) return routeComponent;
+    const element = route.element;
+    if (element) return ()=>element;
+}
+function toErrorComponent(routeObject) {
+    const route = routeObject;
+    if (route.ErrorBoundary) return route.ErrorBoundary;
+    if (route.errorElement) return ()=>route.errorElement;
+}
+function toPendingComponent(routeObject) {
+    const route = routeObject;
+    return route.HydrateFallback || route.pendingComponent || void 0;
+}
+exports.pickRouteModuleComponent = __webpack_exports__.pickRouteModuleComponent;
+exports.toErrorComponent = __webpack_exports__.toErrorComponent;
+exports.toPendingComponent = __webpack_exports__.toPendingComponent;
+exports.toRouteComponent = __webpack_exports__.toRouteComponent;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "pickRouteModuleComponent",
+    "toErrorComponent",
+    "toPendingComponent",
+    "toRouteComponent"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/routeTree/construction.js

@@ -0,0 +1,152 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createRouteTreeFromRouteObjects: ()=>createRouteTreeFromRouteObjects,
+    getModernRouteIdsFromMatches: ()=>getModernRouteIdsFromMatches
+});
+const context_namespaceObject = require("@modern-js/runtime/context");
+const react_router_namespaceObject = require("@tanstack/react-router");
+const external_outlet_js_namespaceObject = require("../outlet.js");
+const external_components_js_namespaceObject = require("./components.js");
+const external_loaders_js_namespaceObject = require("./loaders.js");
+const external_paths_js_namespaceObject = require("./paths.js");
+const external_staticData_js_namespaceObject = require("./staticData.js");
+const external_tanstackRoutes_js_namespaceObject = require("./tanstackRoutes.js");
+function createRouteFromRouteObject(opts) {
+    const { options = {}, parent, pathlessFallbackId = 'pathless', routeObject } = opts;
+    const modernRouteObject = routeObject;
+    const revalidationState = {};
+    const shouldRevalidate = modernRouteObject.shouldRevalidate;
+    const shouldReload = (0, external_loaders_js_namespaceObject.createModernShouldReload)(shouldRevalidate, revalidationState);
+    const stableFallbackId = routeObject.id || modernRouteObject.file || pathlessFallbackId;
+    const component = (0, external_components_js_namespaceObject.toRouteComponent)(routeObject, options);
+    const base = {
+        getParentRoute: ()=>parent,
+        component,
+        pendingComponent: (0, external_components_js_namespaceObject.toPendingComponent)(routeObject),
+        errorComponent: (0, external_components_js_namespaceObject.toErrorComponent)(routeObject),
+        validateSearch: modernRouteObject.validateSearch,
+        loaderDeps: modernRouteObject.loaderDeps,
+        staticData: (0, external_staticData_js_namespaceObject.createRouteStaticData)({
+            modernRouteId: routeObject.id,
+            modernRouteAction: modernRouteObject.action,
+            modernRouteHandle: (0, external_staticData_js_namespaceObject.mergeModernRouteHandle)(modernRouteObject),
+            modernRouteHasAction: modernRouteObject.hasAction || Boolean(modernRouteObject.action),
+            modernRouteHasClientLoader: modernRouteObject.hasClientLoader || void 0 !== modernRouteObject.clientData,
+            modernRouteHasLoader: modernRouteObject.hasLoader || 'function' == typeof modernRouteObject.loader,
+            modernRouteIsClientComponent: modernRouteObject.isClientComponent,
+            modernRouteLoader: modernRouteObject.loader,
+            modernRouteShouldRevalidate: shouldRevalidate
+        }),
+        loader: (0, external_loaders_js_namespaceObject.wrapRouteObjectLoader)(routeObject, revalidationState, options)
+    };
+    if (modernRouteObject.inValidSSRRoute) base.ssr = false;
+    if (shouldReload) base.shouldReload = shouldReload;
+    if ((0, external_paths_js_namespaceObject.isRouteObjectPathlessLayout)(routeObject)) base.id = stableFallbackId;
+    else base.path = routeObject.index ? '/' : (0, external_paths_js_namespaceObject.toTanstackPath)(routeObject.path || '');
+    const route = (0, external_tanstackRoutes_js_namespaceObject.createTanstackRoute)(base);
+    (0, external_tanstackRoutes_js_namespaceObject.wrapRouteComponentWithModernContext)(route, component, routeObject.id);
+    const children = routeObject.children;
+    if (children && children.length > 0) {
+        const childRoutes = children.map((child, index)=>createRouteFromRouteObject({
+                options,
+                parent: route,
+                pathlessFallbackId: `pathless-${index}`,
+                routeObject: child
+            }));
+        route.addChildren(childRoutes);
+    }
+    return route;
+}
+function getRootLikeRouteObject(routes) {
+    return routes.find((route)=>'/' === route.path && !route.index);
+}
+function createRouteTreeFromRouteObjects(routes, options = {}) {
+    const rootLikeRoute = getRootLikeRouteObject(routes);
+    const rootRevalidationState = {};
+    const rootShouldRevalidate = rootLikeRoute?.shouldRevalidate;
+    const rootShouldReload = (0, external_loaders_js_namespaceObject.createModernShouldReload)(rootShouldRevalidate, rootRevalidationState);
+    const rootComponent = rootLikeRoute ? (0, external_components_js_namespaceObject.toRouteComponent)(rootLikeRoute) : void 0;
+    const rootRouteOptions = {
+        component: rootComponent,
+        pendingComponent: rootLikeRoute ? (0, external_components_js_namespaceObject.toPendingComponent)(rootLikeRoute) : void 0,
+        errorComponent: rootLikeRoute ? (0, external_components_js_namespaceObject.toErrorComponent)(rootLikeRoute) : void 0,
+        validateSearch: rootLikeRoute?.validateSearch,
+        loaderDeps: rootLikeRoute?.loaderDeps,
+        notFoundComponent: context_namespaceObject.DefaultNotFound,
+        staticData: (0, external_staticData_js_namespaceObject.createRouteStaticData)({
+            modernRouteId: rootLikeRoute?.id,
+            modernRouteAction: rootLikeRoute?.action,
+            modernRouteHandle: rootLikeRoute ? (0, external_staticData_js_namespaceObject.mergeModernRouteHandle)(rootLikeRoute) : void 0,
+            modernRouteHasAction: rootLikeRoute?.hasAction || Boolean(rootLikeRoute?.action),
+            modernRouteHasClientLoader: rootLikeRoute?.hasClientLoader || void 0 !== rootLikeRoute?.clientData,
+            modernRouteHasLoader: rootLikeRoute?.hasLoader || 'function' == typeof rootLikeRoute?.loader,
+            modernRouteIsClientComponent: rootLikeRoute?.isClientComponent,
+            modernRouteLoader: rootLikeRoute?.loader,
+            modernRouteShouldRevalidate: rootShouldRevalidate
+        }),
+        loader: rootLikeRoute ? (0, external_loaders_js_namespaceObject.wrapRouteObjectLoader)(rootLikeRoute, rootRevalidationState, options) : void 0
+    };
+    if (rootShouldReload) rootRouteOptions.shouldReload = rootShouldReload;
+    if (rootLikeRoute?.inValidSSRRoute) rootRouteOptions.ssr = false;
+    const rootRoute = (0, external_tanstackRoutes_js_namespaceObject.createTanstackRootRoute)(rootRouteOptions);
+    if (rootComponent) rootRoute.options.component = (0, external_outlet_js_namespaceObject.withModernRouteMatchContext)(rootComponent, react_router_namespaceObject.rootRouteId);
+    const topLevel = rootLikeRoute ? [
+        ...rootLikeRoute.children || [],
+        ...routes.filter((route)=>route !== rootLikeRoute)
+    ] : routes;
+    const childRoutes = topLevel.map((routeObject, index)=>createRouteFromRouteObject({
+            options,
+            parent: rootRoute,
+            pathlessFallbackId: `pathless-${index}`,
+            routeObject
+        }));
+    rootRoute.addChildren(childRoutes);
+    return rootRoute;
+}
+function getModernRouteIdsFromMatches(router) {
+    const matches = router.state.matches || [];
+    const routesById = router.routesById;
+    const ids = matches.map((match)=>{
+        const normalizedMatch = match;
+        const routeId = 'string' == typeof normalizedMatch.routeId ? normalizedMatch.routeId : void 0;
+        return normalizedMatch.route?.options?.staticData?.modernRouteId ?? (routeId ? routesById?.[routeId]?.options?.staticData?.modernRouteId : void 0);
+    }).filter((id)=>'string' == typeof id);
+    return Array.from(new Set(ids));
+}
+exports.createRouteTreeFromRouteObjects = __webpack_exports__.createRouteTreeFromRouteObjects;
+exports.getModernRouteIdsFromMatches = __webpack_exports__.getModernRouteIdsFromMatches;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRouteTreeFromRouteObjects",
+    "getModernRouteIdsFromMatches"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/routeTree/index.js

@@ -0,0 +1,47 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createRouteTreeFromRouteObjects: ()=>external_construction_js_namespaceObject.createRouteTreeFromRouteObjects,
+    getModernRouteIdsFromMatches: ()=>external_construction_js_namespaceObject.getModernRouteIdsFromMatches,
+    pickRouteModuleComponent: ()=>external_components_js_namespaceObject.pickRouteModuleComponent
+});
+const external_components_js_namespaceObject = require("./components.js");
+const external_construction_js_namespaceObject = require("./construction.js");
+exports.createRouteTreeFromRouteObjects = __webpack_exports__.createRouteTreeFromRouteObjects;
+exports.getModernRouteIdsFromMatches = __webpack_exports__.getModernRouteIdsFromMatches;
+exports.pickRouteModuleComponent = __webpack_exports__.pickRouteModuleComponent;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRouteTreeFromRouteObjects",
+    "getModernRouteIdsFromMatches",
+    "pickRouteModuleComponent"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/routeTree/loaders.js

@@ -0,0 +1,158 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createModernShouldReload: ()=>createModernShouldReload,
+    wrapRouteObjectLoader: ()=>wrapRouteObjectLoader
+});
+const react_router_namespaceObject = require("@tanstack/react-router");
+const external_loaderBridge_js_namespaceObject = require("../loaderBridge.js");
+const payloadRouter_js_namespaceObject = require("../rsc/payloadRouter.js");
+function isModernDeferredData(value) {
+    if (!value || 'object' != typeof value) return false;
+    const deferred = value;
+    return true === deferred.__modern_deferred && Boolean(deferred.data) && 'object' == typeof deferred.data && !Array.isArray(deferred.data);
+}
+function normalizeModernLoaderResult(result) {
+    return isModernDeferredData(result) ? result.data : result;
+}
+function normalizeModernLoaderResponse(result) {
+    if ((0, external_loaderBridge_js_namespaceObject.isResponse)(result)) {
+        if ((0, external_loaderBridge_js_namespaceObject.isRedirectResponse)(result)) {
+            const location = result.headers.get('Location') || '/';
+            (0, external_loaderBridge_js_namespaceObject.throwTanstackRedirect)(location);
+        }
+        if (404 === result.status) throw (0, react_router_namespaceObject.notFound)();
+    }
+    return normalizeModernLoaderResult(result);
+}
+function createModernRequest(input, signal) {
+    return new Request(input, {
+        signal
+    });
+}
+function getModernUrlFromLoaderContext(ctx) {
+    const href = 'string' == typeof ctx?.location ? ctx.location : ctx?.location?.publicHref || ctx?.location?.href || ctx?.location?.url?.href || '/';
+    const baseRequest = ctx?.context?.request instanceof Request ? ctx.context.request : void 0;
+    const baseUrl = baseRequest?.url || ("u" > typeof window ? window.origin : 'http://localhost');
+    return new URL(href || '/', baseUrl);
+}
+function rememberRouteLocation(state, ctx) {
+    state.currentUrl = getModernUrlFromLoaderContext(ctx);
+    state.currentParams = ctx?.params || {};
+}
+function createModernShouldReload(shouldRevalidate, state) {
+    if ('function' != typeof shouldRevalidate) return;
+    const revalidate = shouldRevalidate;
+    return (ctx)=>{
+        const nextUrl = getModernUrlFromLoaderContext(ctx);
+        const nextParams = ctx?.params || {};
+        const result = revalidate({
+            currentUrl: state.currentUrl || nextUrl,
+            currentParams: state.currentParams || nextParams,
+            nextUrl,
+            nextParams,
+            defaultShouldRevalidate: void 0
+        });
+        state.currentUrl = nextUrl;
+        state.currentParams = nextParams;
+        return 'boolean' == typeof result ? result : void 0;
+    };
+}
+function isRouteObjectSplatRoute(route) {
+    return 'string' == typeof route.path && route.path.includes('*');
+}
+function mapParamsForRouteObjectLoader({ route, params }) {
+    if (isRouteObjectSplatRoute(route)) {
+        const { _splat, ...rest } = params;
+        if (void 0 !== _splat) return {
+            ...rest,
+            '*': _splat
+        };
+        return rest;
+    }
+    return params;
+}
+function wrapRouteObjectLoader(route, revalidationState, options = {}) {
+    const modernRoute = route;
+    const routeLoader = modernRoute.loader;
+    if ('function' != typeof routeLoader) return;
+    return async (ctx)=>{
+        try {
+            if (revalidationState) rememberRouteLocation(revalidationState, ctx);
+            if ('function' == typeof modernRoute.lazyImport) try {
+                await modernRoute.lazyImport();
+            } catch  {}
+            const signal = ctx?.abortController?.signal || ctx?.signal || new AbortController().signal;
+            const baseRequest = ctx?.context?.request instanceof Request ? ctx.context.request : void 0;
+            const href = 'string' == typeof ctx?.location ? ctx.location : ctx?.location?.publicHref || ctx?.location?.href || ctx?.location?.url?.href || '';
+            const request = void 0 !== baseRequest ? new Request(baseRequest, {
+                signal
+            }) : createModernRequest(href, signal);
+            const params = mapParamsForRouteObjectLoader({
+                route,
+                params: ctx.params || {}
+            });
+            const loadModernData = async ()=>{
+                const result = await routeLoader({
+                    request,
+                    params,
+                    context: ctx?.context?.requestContext
+                });
+                return normalizeModernLoaderResponse(result);
+            };
+            if (options.rscPayloadRouter && (0, payloadRouter_js_namespaceObject.isTanstackRscPayloadNavigationEnabled)()) return (0, payloadRouter_js_namespaceObject.loadTanstackRscRouteData)({
+                hasClientLoader: modernRoute.hasClientLoader || void 0 !== modernRoute.clientData,
+                loadClientData: loadModernData,
+                request,
+                routeId: ctx.route?.id
+            });
+            return loadModernData();
+        } catch (err) {
+            if ((0, external_loaderBridge_js_namespaceObject.isResponse)(err)) {
+                if ((0, external_loaderBridge_js_namespaceObject.isTanstackRedirect)(err)) throw err;
+                if ((0, external_loaderBridge_js_namespaceObject.isRedirectResponse)(err)) {
+                    const location = err.headers.get('Location') || '/';
+                    (0, external_loaderBridge_js_namespaceObject.throwTanstackRedirect)(location);
+                }
+                if (404 === err.status) throw (0, react_router_namespaceObject.notFound)();
+            }
+            throw err;
+        }
+    };
+}
+exports.createModernShouldReload = __webpack_exports__.createModernShouldReload;
+exports.wrapRouteObjectLoader = __webpack_exports__.wrapRouteObjectLoader;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createModernShouldReload",
+    "wrapRouteObjectLoader"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/routeTree/paths.js

@@ -0,0 +1,57 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+function toTanstackPath(pathname) {
+    return pathname.split('/').map((segment)=>{
+        if (!segment) return segment;
+        if ('*' === segment) return '$';
+        if (segment.startsWith(':')) {
+            const name = segment.slice(1);
+            if (name.endsWith('?')) return `{-$${name.slice(0, -1)}}`;
+            return `$${name}`;
+        }
+        return segment;
+    }).join('/');
+}
+function isRouteObjectPathlessLayout(route) {
+    return !route.path && !route.index;
+}
+__webpack_require__.d(__webpack_exports__, {
+    isRouteObjectPathlessLayout: ()=>isRouteObjectPathlessLayout,
+    toTanstackPath: ()=>toTanstackPath
+});
+exports.isRouteObjectPathlessLayout = __webpack_exports__.isRouteObjectPathlessLayout;
+exports.toTanstackPath = __webpack_exports__.toTanstackPath;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "isRouteObjectPathlessLayout",
+    "toTanstackPath"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/routeTree/staticData.js

@@ -0,0 +1,63 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+function mergeModernRouteHandle(route) {
+    const config = route.config;
+    const handle = {
+        ...route.handle,
+        ...config && 'object' == typeof config ? config.handle : {}
+    };
+    return Object.keys(handle).length > 0 ? handle : void 0;
+}
+function createRouteStaticData(opts) {
+    const staticData = {};
+    if (opts.modernRouteId) staticData.modernRouteId = opts.modernRouteId;
+    if (opts.modernRouteAction) staticData.modernRouteAction = opts.modernRouteAction;
+    if (opts.modernRouteHandle) staticData.modernRouteHandle = opts.modernRouteHandle;
+    if (opts.modernRouteHasAction) staticData.modernRouteHasAction = true;
+    if (opts.modernRouteHasClientLoader) staticData.modernRouteHasClientLoader = true;
+    if (opts.modernRouteHasLoader) staticData.modernRouteHasLoader = true;
+    if (opts.modernRouteIsClientComponent) staticData.modernRouteIsClientComponent = true;
+    if (opts.modernRouteLoader) staticData.modernRouteLoader = opts.modernRouteLoader;
+    if (opts.modernRouteShouldRevalidate) staticData.modernRouteShouldRevalidate = opts.modernRouteShouldRevalidate;
+    return Object.keys(staticData).length > 0 ? staticData : void 0;
+}
+__webpack_require__.d(__webpack_exports__, {
+    createRouteStaticData: ()=>createRouteStaticData,
+    mergeModernRouteHandle: ()=>mergeModernRouteHandle
+});
+exports.createRouteStaticData = __webpack_exports__.createRouteStaticData;
+exports.mergeModernRouteHandle = __webpack_exports__.mergeModernRouteHandle;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRouteStaticData",
+    "mergeModernRouteHandle"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/routeTree/tanstackRoutes.js

@@ -0,0 +1,57 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createTanstackRootRoute: ()=>createTanstackRootRoute,
+    createTanstackRoute: ()=>createTanstackRoute,
+    wrapRouteComponentWithModernContext: ()=>wrapRouteComponentWithModernContext
+});
+const react_router_namespaceObject = require("@tanstack/react-router");
+const external_outlet_js_namespaceObject = require("../outlet.js");
+function createTanstackRoute(options) {
+    return (0, react_router_namespaceObject.createRoute)(options);
+}
+function createTanstackRootRoute(options) {
+    return (0, react_router_namespaceObject.createRootRoute)(options);
+}
+function wrapRouteComponentWithModernContext(route, component, routeId) {
+    const routeMatchId = routeId || route.id;
+    if (component && routeMatchId) route.options.component = (0, external_outlet_js_namespaceObject.withModernRouteMatchContext)(component, routeMatchId);
+}
+exports.createTanstackRootRoute = __webpack_exports__.createTanstackRootRoute;
+exports.createTanstackRoute = __webpack_exports__.createTanstackRoute;
+exports.wrapRouteComponentWithModernContext = __webpack_exports__.wrapRouteComponentWithModernContext;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createTanstackRootRoute",
+    "createTanstackRoute",
+    "wrapRouteComponentWithModernContext"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/routeTree/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});