@bleedingdev/modern-js-runtime 3.2.0-ultramodern.98 → 3.4.0-ultramodern.0

package/dist/esm/router/runtime/tanstack/routeTree.mjs

@@ -1,470 +0,0 @@
-import { createRootRoute, createRoute, notFound, redirect } from "@tanstack/react-router";
-import { createElement } from "react";
-import { DefaultNotFound } from "../DefaultNotFound.mjs";
-function createTanstackRoute(options) {
-    return createRoute(options);
-}
-function createTanstackRootRoute(options) {
-    return createRootRoute(options);
-}
-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 isResponse(value) {
-    const record = value;
-    return null != record && 'object' == typeof record && 'number' == typeof record.status && 'object' == typeof record.headers;
-}
-function isTanstackRedirect(value) {
-    return isResponse(value) && 'object' == typeof value.options;
-}
-const redirectStatusCodes = new Set([
-    301,
-    302,
-    303,
-    307,
-    308
-]);
-function isRedirectResponse(res) {
-    return redirectStatusCodes.has(res.status);
-}
-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 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 createElement(resolvedComponent, props);
-        pendingLoad ||= load();
-        throw pendingLoad;
-    };
-    Component.load = load;
-    Component.preload = load;
-    return Component;
-}
-function throwTanstackRedirect(location) {
-    const target = location || '/';
-    try {
-        new URL(target);
-        throw redirect({
-            href: target
-        });
-    } catch  {
-        throw redirect({
-            to: target
-        });
-    }
-}
-function mapParamsForModernLoader({ modernRoute, params }) {
-    if ('nested' === modernRoute.type && modernRoute.path?.includes('*')) {
-        const { _splat, ...rest } = params;
-        if (void 0 !== _splat) return {
-            ...rest,
-            '*': _splat
-        };
-        return rest;
-    }
-    return params;
-}
-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 wrapModernLoader(modernRoute, modernLoader, revalidationState) {
-    const route = modernRoute;
-    return async (ctx)=>{
-        try {
-            if (revalidationState) rememberRouteLocation(revalidationState, ctx);
-            if ('function' == typeof route.lazyImport) try {
-                await route.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 = mapParamsForModernLoader({
-                modernRoute,
-                params: ctx.params || {}
-            });
-            const result = modernLoader ? await modernLoader({
-                request,
-                params,
-                context: ctx?.context?.requestContext
-            }) : null;
-            if (isResponse(result)) {
-                if (isRedirectResponse(result)) {
-                    const location = result.headers.get('Location') || '/';
-                    throwTanstackRedirect(location);
-                }
-                if (404 === result.status) throw notFound();
-            }
-            return normalizeModernLoaderResult(result);
-        } catch (err) {
-            if (isResponse(err)) {
-                if (isTanstackRedirect(err)) throw err;
-                if (isRedirectResponse(err)) {
-                    const location = err.headers.get('Location') || '/';
-                    throwTanstackRedirect(location);
-                }
-                if (404 === err.status) throw notFound();
-            }
-            throw err;
-        }
-    };
-}
-function isRouteObjectPathlessLayout(route) {
-    return !route.path && !route.index;
-}
-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) {
-    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 result = await routeLoader({
-                request,
-                params,
-                context: ctx?.context?.requestContext
-            });
-            if (isResponse(result)) {
-                if (isRedirectResponse(result)) {
-                    const location = result.headers.get('Location') || '/';
-                    throwTanstackRedirect(location);
-                }
-                if (404 === result.status) throw notFound();
-            }
-            return normalizeModernLoaderResult(result);
-        } catch (err) {
-            if (isResponse(err)) {
-                if (isTanstackRedirect(err)) throw err;
-                if (isRedirectResponse(err)) {
-                    const location = err.headers.get('Location') || '/';
-                    throwTanstackRedirect(location);
-                }
-                if (404 === err.status) throw notFound();
-            }
-            throw err;
-        }
-    };
-}
-function toRouteComponent(routeObject) {
-    const route = routeObject;
-    const lazyImport = 'function' == typeof route.lazyImport ? route.lazyImport : void 0;
-    const fallbackComponent = route.Component ? route.Component : route.element ? ()=>route.element : void 0;
-    if (lazyImport && fallbackComponent) return createServerLazyImportComponent(lazyImport, fallbackComponent);
-    if (route.Component) return route.Component;
-    const element = route.element;
-    if (element) return ()=>element;
-}
-function toModernRouteComponent(route) {
-    const component = route.component || void 0;
-    if ('function' == typeof route.lazyImport && component) return createServerLazyImportComponent(route.lazyImport, component);
-    return component;
-}
-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;
-}
-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;
-}
-function createRouteFromRouteObject(opts) {
-    const { parent, routeObject } = opts;
-    const modernRouteObject = routeObject;
-    const revalidationState = {};
-    const shouldRevalidate = modernRouteObject.shouldRevalidate;
-    const shouldReload = createModernShouldReload(shouldRevalidate, revalidationState);
-    const stableFallbackId = routeObject.id || modernRouteObject.file || routeObject.path || 'pathless';
-    const base = {
-        getParentRoute: ()=>parent,
-        component: toRouteComponent(routeObject),
-        pendingComponent: toPendingComponent(routeObject),
-        errorComponent: toErrorComponent(routeObject),
-        staticData: createRouteStaticData({
-            modernRouteId: routeObject.id,
-            modernRouteAction: modernRouteObject.action,
-            modernRouteHandle: 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: wrapRouteObjectLoader(routeObject, revalidationState)
-    };
-    if (modernRouteObject.inValidSSRRoute) base.ssr = false;
-    if (shouldReload) base.shouldReload = shouldReload;
-    if (isRouteObjectPathlessLayout(routeObject)) base.id = stableFallbackId;
-    else base.path = routeObject.index ? '/' : toTanstackPath(routeObject.path || '');
-    const route = createTanstackRoute(base);
-    const children = routeObject.children;
-    if (children && children.length > 0) {
-        const childRoutes = children.map((child)=>createRouteFromRouteObject({
-                parent: route,
-                routeObject: child
-            }));
-        route.addChildren(childRoutes);
-    }
-    return route;
-}
-function createRouteFromModernRoute(opts) {
-    const { parent, modernRoute } = opts;
-    const route = modernRoute;
-    const revalidationState = {};
-    const modernId = route.id;
-    const stableFallbackId = modernId || route._component || route.filename || route.data || ('function' == typeof route.loader ? route.id : void 0);
-    const pendingComponent = route.loading || route.pendingComponent;
-    const errorComponent = route.error || route.errorComponent;
-    const component = toModernRouteComponent(route);
-    const modernLoader = route.loader;
-    const modernAction = route.action;
-    const modernShouldRevalidate = route.shouldRevalidate;
-    const shouldReload = createModernShouldReload(modernShouldRevalidate, revalidationState);
-    const isPathlessLayout = 'nested' === route.type && 'boolean' != typeof route.index && void 0 === route.path;
-    const isIndexRoute = 'nested' === route.type && Boolean(route.index);
-    const base = {
-        getParentRoute: ()=>parent,
-        component: component || void 0,
-        pendingComponent: pendingComponent || void 0,
-        errorComponent: errorComponent || void 0,
-        staticData: createRouteStaticData({
-            modernRouteId: modernId,
-            modernRouteAction: modernAction,
-            modernRouteHandle: mergeModernRouteHandle(route),
-            modernRouteHasAction: route.hasAction || Boolean(modernAction),
-            modernRouteHasClientLoader: route.hasClientLoader || void 0 !== route.clientData,
-            modernRouteHasLoader: route.hasLoader || 'function' == typeof modernLoader,
-            modernRouteIsClientComponent: route.isClientComponent,
-            modernRouteLoader: modernLoader,
-            modernRouteShouldRevalidate: modernShouldRevalidate
-        }),
-        loader: wrapModernLoader(modernRoute, modernLoader, revalidationState)
-    };
-    if (route.inValidSSRRoute) base.ssr = false;
-    if (shouldReload) base.shouldReload = shouldReload;
-    if (isPathlessLayout) base.id = stableFallbackId || 'pathless';
-    else {
-        const rawPath = route.path;
-        base.path = isIndexRoute ? '/' : toTanstackPath(rawPath || '');
-    }
-    const tanstackRoute = createTanstackRoute(base);
-    const children = route.children;
-    if (children && children.length > 0) {
-        const childRoutes = children.map((child)=>createRouteFromModernRoute({
-                parent: tanstackRoute,
-                modernRoute: child
-            }));
-        tanstackRoute.addChildren(childRoutes);
-    }
-    return tanstackRoute;
-}
-function createRouteTreeFromModernRoutes(routes) {
-    const rootModern = routes.find((r)=>r && 'nested' === r.type && r.isRoot);
-    const rootComponent = rootModern ? toModernRouteComponent(rootModern) : void 0;
-    const pendingComponent = rootModern?.loading;
-    const errorComponent = rootModern?.error;
-    const rootLoader = rootModern?.loader;
-    const rootAction = rootModern?.action;
-    const rootModernId = rootModern?.id;
-    const rootShouldRevalidate = rootModern?.shouldRevalidate;
-    const rootRevalidationState = {};
-    const rootShouldReload = createModernShouldReload(rootShouldRevalidate, rootRevalidationState);
-    const rootRouteOptions = {
-        component: rootComponent || void 0,
-        pendingComponent: pendingComponent || void 0,
-        errorComponent: errorComponent || void 0,
-        notFoundComponent: DefaultNotFound,
-        staticData: createRouteStaticData({
-            modernRouteId: rootModernId,
-            modernRouteAction: rootAction,
-            modernRouteHandle: rootModern ? mergeModernRouteHandle(rootModern) : void 0,
-            modernRouteHasAction: rootModern?.hasAction || Boolean(rootAction),
-            modernRouteHasClientLoader: rootModern?.hasClientLoader || void 0 !== rootModern?.clientData,
-            modernRouteHasLoader: rootModern?.hasLoader || 'function' == typeof rootLoader,
-            modernRouteIsClientComponent: rootModern?.isClientComponent,
-            modernRouteLoader: rootLoader,
-            modernRouteShouldRevalidate: rootShouldRevalidate
-        }),
-        loader: rootModern ? wrapModernLoader(rootModern, rootLoader, rootRevalidationState) : void 0
-    };
-    if (rootShouldReload) rootRouteOptions.shouldReload = rootShouldReload;
-    if (rootModern?.inValidSSRRoute) rootRouteOptions.ssr = false;
-    const rootRoute = createTanstackRootRoute(rootRouteOptions);
-    const topLevel = rootModern ? rootModern.children || [] : routes;
-    const childRoutes = topLevel.map((child)=>createRouteFromModernRoute({
-            parent: rootRoute,
-            modernRoute: child
-        }));
-    rootRoute.addChildren(childRoutes);
-    return rootRoute;
-}
-function getRootLikeRouteObject(routes) {
-    return routes.find((route)=>'/' === route.path && !route.index);
-}
-function createRouteTreeFromRouteObjects(routes) {
-    const rootLikeRoute = getRootLikeRouteObject(routes);
-    const rootRevalidationState = {};
-    const rootShouldRevalidate = rootLikeRoute?.shouldRevalidate;
-    const rootShouldReload = createModernShouldReload(rootShouldRevalidate, rootRevalidationState);
-    const rootRouteOptions = {
-        component: rootLikeRoute ? toRouteComponent(rootLikeRoute) : void 0,
-        pendingComponent: rootLikeRoute ? toPendingComponent(rootLikeRoute) : void 0,
-        errorComponent: rootLikeRoute ? toErrorComponent(rootLikeRoute) : void 0,
-        notFoundComponent: DefaultNotFound,
-        staticData: createRouteStaticData({
-            modernRouteId: rootLikeRoute?.id,
-            modernRouteAction: rootLikeRoute?.action,
-            modernRouteHandle: rootLikeRoute ? 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 ? wrapRouteObjectLoader(rootLikeRoute, rootRevalidationState) : void 0
-    };
-    if (rootShouldReload) rootRouteOptions.shouldReload = rootShouldReload;
-    if (rootLikeRoute?.inValidSSRRoute) rootRouteOptions.ssr = false;
-    const rootRoute = createTanstackRootRoute(rootRouteOptions);
-    const topLevel = rootLikeRoute ? [
-        ...rootLikeRoute.children || [],
-        ...routes.filter((route)=>route !== rootLikeRoute)
-    ] : routes;
-    const childRoutes = topLevel.map((routeObject)=>createRouteFromRouteObject({
-            parent: rootRoute,
-            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));
-}
-export { createRouteTreeFromModernRoutes, createRouteTreeFromRouteObjects, getModernRouteIdsFromMatches };

package/dist/esm/router/runtime/tanstack/rsc/ClientSlot.mjs

@@ -1,19 +0,0 @@
-"use client";
-import { Fragment, jsx } from "react/jsx-runtime";
-import { useSlotContext } from "./SlotContext.mjs";
-function ClientSlot({ args, slot }) {
-    const context = useSlotContext();
-    if (!context) throw new Error('ClientSlot must be rendered inside CompositeComponent.');
-    const implementation = context.implementations[slot];
-    if (void 0 === implementation) {
-        if (context.strict) throw new Error(`Missing RSC slot implementation for "${slot}".`);
-        return null;
-    }
-    if ('function' == typeof implementation) return /*#__PURE__*/ jsx(Fragment, {
-        children: implementation(...args)
-    });
-    return /*#__PURE__*/ jsx(Fragment, {
-        children: implementation
-    });
-}
-export { ClientSlot };

package/dist/esm/router/runtime/tanstack/rsc/CompositeComponent.mjs

@@ -1,41 +0,0 @@
-"use client";
-import { jsx } from "react/jsx-runtime";
-import { Suspense } from "react";
-import { SlotProvider } from "./SlotContext.mjs";
-import { RSC_PROXY_GET_TREE, RSC_PROXY_PATH } from "./symbols.mjs";
-function EmptyFallback() {
-    return null;
-}
-function selectTreePath(tree, path) {
-    let current = tree;
-    for (const key of path){
-        if (null === current || 'object' != typeof current) return null;
-        current = current[key];
-    }
-    return current;
-}
-function CompositeInner({ slotProps, src, strict }) {
-    const getTree = src[RSC_PROXY_GET_TREE];
-    if (!getTree) throw new Error('CompositeComponent src must come from createCompositeComponent().');
-    const tree = selectTreePath(getTree(), src[RSC_PROXY_PATH] || []);
-    return /*#__PURE__*/ jsx(SlotProvider, {
-        implementations: slotProps,
-        strict: strict,
-        children: tree
-    });
-}
-function CompositeComponent(props) {
-    const { children, src, strict, ...slotProps } = props;
-    return /*#__PURE__*/ jsx(Suspense, {
-        fallback: /*#__PURE__*/ jsx(EmptyFallback, {}),
-        children: /*#__PURE__*/ jsx(CompositeInner, {
-            slotProps: {
-                ...slotProps,
-                children
-            },
-            src: src,
-            strict: strict
-        })
-    });
-}
-export { CompositeComponent };

package/dist/esm/router/runtime/tanstack/rsc/ReplayableStream.mjs

@@ -1,104 +0,0 @@
-const REPLAYABLE_STREAM_MARKER = Symbol.for('modern.tanstack.rsc.ReplayableStream');
-class ReplayableStream {
-    start() {
-        const signal = this.options.signal;
-        if (signal?.aborted) return void this.release();
-        this.abortListener = ()=>this.release();
-        signal?.addEventListener('abort', this.abortListener, {
-            once: true
-        });
-        const reader = this.source.getReader();
-        this.reader = reader;
-        const pump = async ()=>{
-            try {
-                while(!this.released){
-                    const { done, value } = await reader.read();
-                    if (done) break;
-                    this.chunks.push(value);
-                    this.notify();
-                }
-            } catch (err) {
-                if (!this.released) this.error = err;
-            } finally{
-                this.done = true;
-                this.detachAbortListener();
-                try {
-                    reader.releaseLock();
-                } catch  {}
-                if (this.reader === reader) this.reader = null;
-                this.notify();
-            }
-        };
-        pump();
-    }
-    detachAbortListener() {
-        const signal = this.options.signal;
-        if (signal && this.abortListener) signal.removeEventListener('abort', this.abortListener);
-        this.abortListener = null;
-    }
-    notify() {
-        this.waiter?.resolve();
-        this.waiter = null;
-    }
-    wait() {
-        if (this.done || this.released) return Promise.resolve();
-        if (!this.waiter) {
-            let resolve;
-            const promise = new Promise((res)=>{
-                resolve = res;
-            });
-            this.waiter = {
-                promise,
-                resolve
-            };
-        }
-        return this.waiter.promise;
-    }
-    release() {
-        if (this.released) return;
-        this.released = true;
-        this.chunks = [];
-        this.detachAbortListener();
-        try {
-            this.reader?.cancel(new Error('ReplayableStream released'));
-        } catch  {}
-        this.notify();
-    }
-    isReleased() {
-        return this.released;
-    }
-    createReplayStream() {
-        if (this.released) return new ReadableStream({
-            start (controller) {
-                controller.close();
-            }
-        });
-        let index = 0;
-        return new ReadableStream({
-            pull: async (controller)=>{
-                while(true){
-                    if (index < this.chunks.length) return void controller.enqueue(this.chunks[index++]);
-                    if (this.error) return void controller.error(this.error);
-                    if (this.done || this.released) return void controller.close();
-                    await this.wait();
-                }
-            },
-            cancel: ()=>{}
-        });
-    }
-    constructor(source, options = {}){
-        this.source = source;
-        this.options = options;
-        this[_REPLAYABLE_STREAM_MARKER] = true;
-        this.chunks = [];
-        this.done = false;
-        this.waiter = null;
-        this.released = false;
-        this.reader = null;
-        this.abortListener = null;
-        this.start();
-    }
-}
-_REPLAYABLE_STREAM_MARKER = REPLAYABLE_STREAM_MARKER;
-var _REPLAYABLE_STREAM_MARKER;
-export { REPLAYABLE_STREAM_MARKER, ReplayableStream };

package/dist/esm/router/runtime/tanstack/rsc/RscNodeRenderer.mjs

@@ -1,31 +0,0 @@
-"use client";
-import { Fragment, jsx } from "react/jsx-runtime";
-import { Suspense } from "react";
-import { RSC_PROXY_GET_TREE, RSC_PROXY_PATH } from "./symbols.mjs";
-function EmptyFallback() {
-    return null;
-}
-function selectTreePath(tree, path) {
-    let current = tree;
-    for (const key of path){
-        if (null === current || 'object' != typeof current) return null;
-        current = current[key];
-    }
-    return current;
-}
-function RscNodeRenderInner({ data }) {
-    const getTree = data[RSC_PROXY_GET_TREE];
-    if (!getTree) throw new Error('Renderable RSC is missing its decoded tree getter.');
-    return /*#__PURE__*/ jsx(Fragment, {
-        children: selectTreePath(getTree(), data[RSC_PROXY_PATH] || [])
-    });
-}
-function RscNodeRenderer({ data }) {
-    return /*#__PURE__*/ jsx(Suspense, {
-        fallback: /*#__PURE__*/ jsx(EmptyFallback, {}),
-        children: /*#__PURE__*/ jsx(RscNodeRenderInner, {
-            data: data
-        })
-    });
-}
-export { RscNodeRenderer };

package/dist/esm/router/runtime/tanstack/rsc/SlotContext.mjs

@@ -1,17 +0,0 @@
-"use client";
-import { jsx } from "react/jsx-runtime";
-import { createContext, use } from "react";
-const SlotContext = /*#__PURE__*/ createContext(null);
-function useSlotContext() {
-    return use(SlotContext);
-}
-function SlotProvider({ children, implementations, strict }) {
-    return /*#__PURE__*/ jsx(SlotContext, {
-        value: {
-            implementations,
-            strict: true === strict
-        },
-        children: children
-    });
-}
-export { SlotProvider, useSlotContext };