@bleedingdev/modern-js-runtime 3.2.0-ultramodern.120 → 3.2.0-ultramodern.121

package/dist/cjs/router/runtime/tanstack/routeTree.js

@@ -1,525 +0,0 @@
-"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__, {
-    createRouteTreeFromModernRoutes: ()=>createRouteTreeFromModernRoutes,
-    createRouteTreeFromRouteObjects: ()=>createRouteTreeFromRouteObjects,
-    getModernRouteIdsFromMatches: ()=>getModernRouteIdsFromMatches
-});
-const react_router_namespaceObject = require("@tanstack/react-router");
-const external_react_namespaceObject = require("react");
-const external_DefaultNotFound_js_namespaceObject = require("../DefaultNotFound.js");
-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);
-}
-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 (0, external_react_namespaceObject.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 (0, react_router_namespaceObject.redirect)({
-            href: target
-        });
-    } catch  {
-        throw (0, react_router_namespaceObject.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 (0, react_router_namespaceObject.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 (0, react_router_namespaceObject.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 (0, react_router_namespaceObject.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 (0, react_router_namespaceObject.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 component = toRouteComponent(routeObject);
-    const base = {
-        getParentRoute: ()=>parent,
-        component,
-        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);
-    wrapRouteComponentWithModernContext(route, component, routeObject.id);
-    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);
-    wrapRouteComponentWithModernContext(tanstackRoute, component, modernId);
-    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: external_DefaultNotFound_js_namespaceObject.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);
-    if (rootComponent) rootRoute.options.component = (0, external_outlet_js_namespaceObject.withModernRouteMatchContext)(rootComponent, react_router_namespaceObject.rootRouteId);
-    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 rootComponent = rootLikeRoute ? toRouteComponent(rootLikeRoute) : void 0;
-    const rootRouteOptions = {
-        component: rootComponent,
-        pendingComponent: rootLikeRoute ? toPendingComponent(rootLikeRoute) : void 0,
-        errorComponent: rootLikeRoute ? toErrorComponent(rootLikeRoute) : void 0,
-        notFoundComponent: external_DefaultNotFound_js_namespaceObject.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);
-    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)=>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));
-}
-exports.createRouteTreeFromModernRoutes = __webpack_exports__.createRouteTreeFromModernRoutes;
-exports.createRouteTreeFromRouteObjects = __webpack_exports__.createRouteTreeFromRouteObjects;
-exports.getModernRouteIdsFromMatches = __webpack_exports__.getModernRouteIdsFromMatches;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "createRouteTreeFromModernRoutes",
-    "createRouteTreeFromRouteObjects",
-    "getModernRouteIdsFromMatches"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/cjs/router/runtime/tanstack/rsc/CompositeComponent.js

@@ -1,79 +0,0 @@
-"use strict";
-"use client";
-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__, {
-    CompositeComponent: ()=>CompositeComponent
-});
-const jsx_runtime_namespaceObject = require("react/jsx-runtime");
-const external_react_namespaceObject = require("react");
-const external_SlotContext_js_namespaceObject = require("./SlotContext.js");
-const external_symbols_js_namespaceObject = require("./symbols.js");
-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[external_symbols_js_namespaceObject.RSC_PROXY_GET_TREE];
-    if (!getTree) throw new Error('CompositeComponent src must come from createCompositeComponent().');
-    const tree = selectTreePath(getTree(), src[external_symbols_js_namespaceObject.RSC_PROXY_PATH] || []);
-    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_SlotContext_js_namespaceObject.SlotProvider, {
-        implementations: slotProps,
-        strict: strict,
-        children: tree
-    });
-}
-function CompositeComponent(props) {
-    const { children, src, strict, ...slotProps } = props;
-    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_react_namespaceObject.Suspense, {
-        fallback: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(EmptyFallback, {}),
-        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(CompositeInner, {
-            slotProps: {
-                ...slotProps,
-                children
-            },
-            src: src,
-            strict: strict
-        })
-    });
-}
-exports.CompositeComponent = __webpack_exports__.CompositeComponent;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "CompositeComponent"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});