@bleedingdev/modern-js-runtime 3.2.0-ultramodern.0

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

@@ -0,0 +1,469 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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_DefaultNotFound_js_namespaceObject = require("../DefaultNotFound.js");
+function createTanstackRoute(options) {
+    return (0, react_router_namespaceObject.createRoute)(options);
+}
+function createTanstackRootRoute(options) {
+    return (0, react_router_namespaceObject.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 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 = 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 = 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;
+    if (route.Component) return route.Component;
+    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;
+}
+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),
+        wrapInSuspense: true,
+        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 = route.component;
+    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,
+        wrapInSuspense: true,
+        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?.component;
+    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,
+        wrapInSuspense: true,
+        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);
+    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,
+        wrapInSuspense: true,
+        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);
+    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 ids = matches.map((match)=>{
+        const route = match.route;
+        return route?.options?.staticData?.modernRouteId;
+    }).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/ClientSlot.js

@@ -0,0 +1,53 @@
+"use strict";
+"use client";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    ClientSlot: ()=>ClientSlot
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_SlotContext_js_namespaceObject = require("./SlotContext.js");
+function ClientSlot({ args, slot }) {
+    const context = (0, external_SlotContext_js_namespaceObject.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__*/ (0, jsx_runtime_namespaceObject.jsx)(jsx_runtime_namespaceObject.Fragment, {
+        children: implementation(...args)
+    });
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(jsx_runtime_namespaceObject.Fragment, {
+        children: implementation
+    });
+}
+exports.ClientSlot = __webpack_exports__.ClientSlot;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ClientSlot"
+].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

@@ -0,0 +1,75 @@
+"use strict";
+"use client";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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
+});