@bleedingdev/modern-js-runtime-extensions 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

package/dist/cjs/routerPrefetchPolicy.js

@@ -0,0 +1,153 @@
+"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__, {
+    createRouterPrefetchPolicy: ()=>createRouterPrefetchPolicy
+});
+const external_navigationWarmup_js_namespaceObject = require("./navigationWarmup.js");
+const external_prefetchPolicy_js_namespaceObject = require("./prefetchPolicy.js");
+const INTENT_DELAY = 100;
+const VIEWPORT_ROOT_MARGIN = '200px';
+const MAX_CONCURRENT_WARMUPS = 4;
+const WARMUP_TTL = 30000;
+function createRouterPrefetchPolicy() {
+    const cache = new Map();
+    const queue = [];
+    let activeWarmups = 0;
+    const canWarmup = ()=>{
+        const navigator = globalThis.navigator;
+        const connection = navigator?.connection || navigator?.mozConnection || navigator?.webkitConnection;
+        return !connection?.saveData && connection?.effectiveType !== 'slow-2g' && connection?.effectiveType !== '2g';
+    };
+    const runNext = ()=>{
+        while(activeWarmups < MAX_CONCURRENT_WARMUPS && queue.length > 0){
+            const task = queue.shift();
+            if (task.cancelled) continue;
+            activeWarmups += 1;
+            task.run().catch(()=>{
+                cache.delete(task.key);
+            }).finally(()=>{
+                activeWarmups -= 1;
+                runNext();
+            });
+        }
+    };
+    return {
+        canWarmup,
+        allowData (route) {
+            return route?.handle?.navigationWarmup?.data !== false;
+        },
+        observe ({ element, prefetch: inputPrefetch, preload: inputPreload, notify }) {
+            const prefetch = inputPrefetch ?? 'render';
+            const preload = (0, external_prefetchPolicy_js_namespaceObject.normalizePreloadBehavior)(inputPreload, prefetch);
+            let state = {
+                code: 'render' === prefetch || 'render' === preload,
+                data: 'render' === prefetch
+            };
+            let timer;
+            let observer;
+            const update = (next)=>{
+                state = next;
+                notify(state);
+            };
+            const cancelTimer = ()=>{
+                if (void 0 !== timer) {
+                    clearTimeout(timer);
+                    timer = void 0;
+                }
+            };
+            notify(state);
+            if (element && ('viewport' === prefetch || 'viewport' === preload) && "u" > typeof IntersectionObserver) {
+                observer = new IntersectionObserver((entries)=>{
+                    if (!entries.some((entry)=>entry.isIntersecting)) return;
+                    update({
+                        code: true,
+                        data: state.data || 'viewport' === prefetch
+                    });
+                    observer?.disconnect();
+                }, {
+                    rootMargin: VIEWPORT_ROOT_MARGIN
+                });
+                observer.observe(element);
+            }
+            return {
+                onIntent () {
+                    if ('intent' !== prefetch && 'intent' !== preload) return;
+                    if (void 0 !== timer) return;
+                    timer = setTimeout(()=>{
+                        timer = void 0;
+                        update({
+                            code: true,
+                            data: state.data || 'intent' === prefetch
+                        });
+                    }, INTENT_DELAY);
+                },
+                onCancel () {
+                    if ('intent' === prefetch || 'intent' === preload) {
+                        cancelTimer();
+                        update({
+                            code: false,
+                            data: false
+                        });
+                    }
+                },
+                dispose () {
+                    cancelTimer();
+                    observer?.disconnect();
+                }
+            };
+        },
+        schedule ({ runtimeContext, chunkLoader, publicPath, key: operationKey, run }) {
+            if (!canWarmup()) return ()=>{};
+            const now = performance.now();
+            for (const [key, timestamp] of cache)if (now - timestamp > WARMUP_TTL) cache.delete(key);
+            const key = (0, external_navigationWarmup_js_namespaceObject.getNavigationWarmupCacheKey)(runtimeContext, chunkLoader, publicPath, operationKey);
+            if (cache.has(key)) return ()=>{};
+            cache.set(key, now);
+            const task = {
+                key,
+                run,
+                cancelled: false
+            };
+            queue.push(task);
+            runNext();
+            return ()=>{
+                task.cancelled = true;
+                if (queue.includes(task)) cache.delete(key);
+            };
+        }
+    };
+}
+exports.createRouterPrefetchPolicy = __webpack_exports__.createRouterPrefetchPolicy;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRouterPrefetchPolicy"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/routerProvider.js

@@ -0,0 +1,105 @@
+"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__, {
+    createRouterPlugin: ()=>createRouterPlugin,
+    createRouterProviderRealm: ()=>createRouterProviderRealm,
+    reportUnsupportedProviderRegistryHooks: ()=>reportUnsupportedProviderRegistryHooks,
+    resolveRouterProvider: ()=>resolveRouterProvider
+});
+const merge_namespaceObject = require("@modern-js/runtime-utils/merge");
+function reportUnsupportedProviderRegistryHooks(providerPlugin, routerProviderRegistryHooks) {
+    const unsupportedHookNames = Object.keys(providerPlugin.registryHooks ?? {}).filter((hookName)=>!(hookName in routerProviderRegistryHooks));
+    if (unsupportedHookNames.length > 0) console.warn(`[@modern-js/runtime] The router provider "${providerPlugin.name}" declares registry hooks outside the router hook contract: ${unsupportedHookNames.join(', ')}. These hooks are not registered when the provider is resolved through \`runtime.router.framework\` — declare them on a separate runtime plugin instead.`);
+    return unsupportedHookNames;
+}
+function createRouterProviderRealm(registrations) {
+    const providers = new Map();
+    let defaultProvider;
+    for (const registration of registrations){
+        if (0 === registration.name.length) throw new Error('[@modern-js/runtime] A router provider realm cannot contain an unnamed provider.');
+        if (providers.has(registration.name)) throw new Error(`[@modern-js/runtime] Router provider "${registration.name}" is declared more than once in the same runtime realm.`);
+        if (true === registration.isDefault && void 0 !== defaultProvider && defaultProvider !== registration.name) throw new Error(`[@modern-js/runtime] Router provider realm declares both "${defaultProvider}" and "${registration.name}" as defaults.`);
+        providers.set(registration.name, registration.factory);
+        if (true === registration.isDefault) defaultProvider = registration.name;
+    }
+    const providerNames = Object.freeze([
+        ...providers.keys()
+    ]);
+    return Object.freeze({
+        ...void 0 !== defaultProvider ? {
+            defaultProvider
+        } : {},
+        get: (name)=>providers.get(name),
+        names: ()=>providerNames
+    });
+}
+function resolveRouterProvider(framework, options) {
+    const name = framework || options.realm.defaultProvider;
+    const realmProviderNames = options.realm.names();
+    if (void 0 === name) throw new Error(`[@modern-js/runtime] The app-owned router provider realm does not declare a default provider. Available realm providers: ${realmProviderNames.join(', ') || '(none)'}.`);
+    const factory = options.realm.get(name);
+    if (void 0 === factory) throw new Error(`[@modern-js/runtime] Router provider "${name}" is not registered in the app-owned router provider realm. Available realm providers: ${realmProviderNames.join(', ') || '(none)'}.`);
+    return factory;
+}
+function createRouterPlugin({ defaultProvider, registryHooks, localProviders = [] }) {
+    const realm = createRouterProviderRealm([
+        {
+            ...defaultProvider,
+            isDefault: true
+        },
+        ...localProviders
+    ]);
+    return (userConfig = {})=>({
+            name: '@modern-js/plugin-router',
+            registryHooks,
+            setup (api) {
+                const mergedConfig = (0, merge_namespaceObject.merge)(api.getRuntimeConfig().router || {}, userConfig);
+                const factory = resolveRouterProvider(mergedConfig.framework, {
+                    realm
+                });
+                const provider = factory(userConfig);
+                reportUnsupportedProviderRegistryHooks(provider, registryHooks);
+                provider.setup?.(api);
+            }
+        });
+}
+exports.createRouterPlugin = __webpack_exports__.createRouterPlugin;
+exports.createRouterProviderRealm = __webpack_exports__.createRouterProviderRealm;
+exports.reportUnsupportedProviderRegistryHooks = __webpack_exports__.reportUnsupportedProviderRegistryHooks;
+exports.resolveRouterProvider = __webpack_exports__.resolveRouterProvider;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRouterPlugin",
+    "createRouterProviderRealm",
+    "reportUnsupportedProviderRegistryHooks",
+    "resolveRouterProvider"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/routerState.js

@@ -0,0 +1,175 @@
+"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__, {
+    applyRouterRuntimeState: ()=>applyRouterRuntimeState,
+    applyRouterServerPrepareResult: ()=>applyRouterServerPrepareResult,
+    cleanupRouterRuntimeState: ()=>cleanupRouterRuntimeState,
+    createRouterServerSnapshot: ()=>createRouterServerSnapshot,
+    getRouterHydrationScripts: ()=>getRouterHydrationScripts,
+    getRouterMatchedRouteIds: ()=>getRouterMatchedRouteIds,
+    getRouterRuntimeState: ()=>getRouterRuntimeState,
+    getRouterServerSnapshot: ()=>getRouterServerSnapshot,
+    subscribeRouterRuntimeState: ()=>subscribeRouterRuntimeState
+});
+const external_contextExtensions_js_namespaceObject = require("./contextExtensions.js");
+const routerRuntimeStateExtension = (0, external_contextExtensions_js_namespaceObject.createRuntimeContextExtension)('@modern-js/runtime:router-runtime-state');
+const routerServerSnapshotExtension = (0, external_contextExtensions_js_namespaceObject.createRuntimeContextExtension)('@modern-js/runtime:router-server-snapshot');
+function getRouterRuntimeState(runtimeContext) {
+    return routerRuntimeStateExtension.get(runtimeContext);
+}
+function getRouterServerSnapshot(runtimeContext) {
+    return routerServerSnapshotExtension.get(runtimeContext);
+}
+function createRouterServerSnapshot(snapshot) {
+    const matches = snapshot.matches?.map((match)=>Object.freeze({
+            ...match,
+            ...match.params ? {
+                params: Object.freeze({
+                    ...match.params
+                })
+            } : {}
+        }));
+    const matchedRouteIds = snapshot.matchedRouteIds ?? matches?.map((match)=>match.assetRouteId ?? match.routeId);
+    return Object.freeze({
+        ...snapshot,
+        ...snapshot.hydrationScripts ? {
+            hydrationScripts: Object.freeze([
+                ...snapshot.hydrationScripts
+            ])
+        } : {},
+        ...matchedRouteIds ? {
+            matchedRouteIds: Object.freeze([
+                ...matchedRouteIds
+            ])
+        } : {},
+        ...matches ? {
+            matches: Object.freeze(matches)
+        } : {},
+        ...snapshot.errors ? {
+            errors: Object.freeze({
+                ...snapshot.errors
+            })
+        } : {},
+        ...snapshot.routerData ? {
+            routerData: Object.freeze({
+                ...snapshot.routerData,
+                ...snapshot.routerData.loaderData ? {
+                    loaderData: Object.freeze({
+                        ...snapshot.routerData.loaderData
+                    })
+                } : {},
+                ...snapshot.routerData.errors ? {
+                    errors: Object.freeze({
+                        ...snapshot.routerData.errors
+                    })
+                } : {}
+            })
+        } : {}
+    });
+}
+const routerRuntimeStateListeners = new WeakMap();
+function subscribeRouterRuntimeState(runtimeContext, listener) {
+    if (!runtimeContext || 'object' != typeof runtimeContext) return ()=>void 0;
+    let listeners = routerRuntimeStateListeners.get(runtimeContext);
+    if (!listeners) {
+        listeners = new Set();
+        routerRuntimeStateListeners.set(runtimeContext, listeners);
+    }
+    listeners.add(listener);
+    return ()=>{
+        listeners?.delete(listener);
+    };
+}
+const pendingRouterRuntimeStateNotifications = new WeakSet();
+function notifyRouterRuntimeState(runtimeContext) {
+    const listeners = routerRuntimeStateListeners.get(runtimeContext);
+    if (!listeners?.size) return;
+    if (pendingRouterRuntimeStateNotifications.has(runtimeContext)) return;
+    pendingRouterRuntimeStateNotifications.add(runtimeContext);
+    const deliver = ()=>{
+        pendingRouterRuntimeStateNotifications.delete(runtimeContext);
+        const current = routerRuntimeStateListeners.get(runtimeContext);
+        if (!current?.size) return;
+        for (const listener of [
+            ...current
+        ])try {
+            listener();
+        } catch  {}
+    };
+    if ('function' == typeof queueMicrotask) queueMicrotask(deliver);
+    else setTimeout(deliver, 0);
+}
+function applyRouterRuntimeState(runtimeContext, state) {
+    const previous = routerRuntimeStateExtension.get(runtimeContext);
+    routerRuntimeStateExtension.set(runtimeContext, state);
+    if (previous?.instance !== state.instance || previous?.framework !== state.framework || previous?.navigation !== state.navigation) notifyRouterRuntimeState(runtimeContext);
+    return runtimeContext;
+}
+function applyRouterServerPrepareResult(runtimeContext, result) {
+    if (result.snapshot) routerServerSnapshotExtension.set(runtimeContext, createRouterServerSnapshot(result.snapshot));
+    return applyRouterRuntimeState(runtimeContext, {
+        ...result.state,
+        cleanup: result.cleanup ?? result.state.cleanup
+    });
+}
+function getRouterHydrationScripts(runtimeContext) {
+    return getRouterServerSnapshot(runtimeContext)?.hydrationScripts ?? [];
+}
+function getRouterMatchedRouteIds(runtimeContext) {
+    return getRouterServerSnapshot(runtimeContext)?.matchedRouteIds;
+}
+async function cleanupRouterRuntimeState(runtimeContext) {
+    try {
+        await getRouterRuntimeState(runtimeContext)?.cleanup?.();
+    } catch  {}
+}
+exports.applyRouterRuntimeState = __webpack_exports__.applyRouterRuntimeState;
+exports.applyRouterServerPrepareResult = __webpack_exports__.applyRouterServerPrepareResult;
+exports.cleanupRouterRuntimeState = __webpack_exports__.cleanupRouterRuntimeState;
+exports.createRouterServerSnapshot = __webpack_exports__.createRouterServerSnapshot;
+exports.getRouterHydrationScripts = __webpack_exports__.getRouterHydrationScripts;
+exports.getRouterMatchedRouteIds = __webpack_exports__.getRouterMatchedRouteIds;
+exports.getRouterRuntimeState = __webpack_exports__.getRouterRuntimeState;
+exports.getRouterServerSnapshot = __webpack_exports__.getRouterServerSnapshot;
+exports.subscribeRouterRuntimeState = __webpack_exports__.subscribeRouterRuntimeState;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "applyRouterRuntimeState",
+    "applyRouterServerPrepareResult",
+    "cleanupRouterRuntimeState",
+    "createRouterServerSnapshot",
+    "getRouterHydrationScripts",
+    "getRouterMatchedRouteIds",
+    "getRouterRuntimeState",
+    "getRouterServerSnapshot",
+    "subscribeRouterRuntimeState"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/routerStatePlugin.js

@@ -0,0 +1,113 @@
+"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__, {
+    createRouterStatePlugin: ()=>createRouterStatePlugin
+});
+const external_routerPrefetchPolicy_js_namespaceObject = require("./routerPrefetchPolicy.js");
+const external_routerState_js_namespaceObject = require("./routerState.js");
+function createReactRouterNavigation(router, Link) {
+    let state;
+    let snapshot;
+    return {
+        Link,
+        getSnapshot () {
+            if (state !== router.state) {
+                state = router.state;
+                snapshot = {
+                    location: state.location,
+                    params: Object.assign({}, ...state.matches.map((match)=>match.params))
+                };
+            }
+            return snapshot;
+        },
+        subscribe: (listener)=>router.subscribe(listener),
+        navigate: (href, options)=>router.navigate(href, options)
+    };
+}
+function createRouterStatePlugin({ registryHooks }) {
+    return {
+        name: '@modern-js/router-runtime-policy',
+        registryHooks,
+        setup (api) {
+            api.onBeforeRender((context)=>{
+                const runtimeContext = context;
+                runtimeContext.linkPrefetchPolicy ??= (0, external_routerPrefetchPolicy_js_namespaceObject.createRouterPrefetchPolicy)();
+            });
+            api.onAfterCreateRouter((event)=>{
+                if ('react-router' !== event.framework) return;
+                if ('ssr-prepare' === event.phase) {
+                    const { routerContext } = event.runtimeContext;
+                    if (!routerContext) return;
+                    const snapshot = {
+                        framework: event.framework,
+                        basename: event.basename,
+                        statusCode: routerContext.statusCode,
+                        errors: routerContext.errors ?? void 0,
+                        routerData: {
+                            loaderData: routerContext.loaderData,
+                            errors: routerContext.errors ?? void 0
+                        },
+                        matches: routerContext.matches.flatMap((match)=>'string' == typeof match.route.id ? [
+                                {
+                                    routeId: match.route.id
+                                }
+                            ] : [])
+                    };
+                    (0, external_routerState_js_namespaceObject.applyRouterServerPrepareResult)(event.runtimeContext, {
+                        snapshot,
+                        state: {
+                            framework: event.framework,
+                            basename: event.basename,
+                            instance: event.router
+                        }
+                    });
+                } else if ('client-create' === event.phase) {
+                    const router = event.router;
+                    const { router: api } = event.runtimeContext;
+                    (0, external_routerState_js_namespaceObject.applyRouterRuntimeState)(event.runtimeContext, {
+                        framework: event.framework,
+                        basename: event.basename,
+                        instance: router,
+                        ...api?.Link ? {
+                            navigation: createReactRouterNavigation(router, api.Link)
+                        } : {}
+                    });
+                }
+            });
+        }
+    };
+}
+exports.createRouterStatePlugin = __webpack_exports__.createRouterStatePlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRouterStatePlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/routerStateTypes.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
+});

package/dist/cjs/rsc-disabled/rscDisabledClientBrowserRuntime.js

@@ -0,0 +1,69 @@
+"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__, {
+    createFromFetch: ()=>createFromFetch,
+    createFromReadableStream: ()=>createFromReadableStream,
+    createServerReference: ()=>createServerReference,
+    createTemporaryReferenceSet: ()=>createTemporaryReferenceSet,
+    encodeReply: ()=>encodeReply,
+    registerServerReference: ()=>registerServerReference,
+    setFindSourceMapURLCallback: ()=>setFindSourceMapURLCallback,
+    setServerCallback: ()=>setServerCallback
+});
+const external_rscDisabledRuntimeError_js_namespaceObject = require("./rscDisabledRuntimeError.js");
+const createFromFetch = external_rscDisabledRuntimeError_js_namespaceObject.disabledRscRuntime;
+const createFromReadableStream = external_rscDisabledRuntimeError_js_namespaceObject.disabledRscRuntime;
+const createServerReference = external_rscDisabledRuntimeError_js_namespaceObject.disabledRscRuntime;
+const createTemporaryReferenceSet = external_rscDisabledRuntimeError_js_namespaceObject.disabledRscRuntime;
+const encodeReply = external_rscDisabledRuntimeError_js_namespaceObject.disabledRscRuntime;
+const registerServerReference = external_rscDisabledRuntimeError_js_namespaceObject.disabledRscRuntime;
+const setFindSourceMapURLCallback = external_rscDisabledRuntimeError_js_namespaceObject.disabledRscRuntime;
+const setServerCallback = external_rscDisabledRuntimeError_js_namespaceObject.disabledRscRuntime;
+exports.createFromFetch = __webpack_exports__.createFromFetch;
+exports.createFromReadableStream = __webpack_exports__.createFromReadableStream;
+exports.createServerReference = __webpack_exports__.createServerReference;
+exports.createTemporaryReferenceSet = __webpack_exports__.createTemporaryReferenceSet;
+exports.encodeReply = __webpack_exports__.encodeReply;
+exports.registerServerReference = __webpack_exports__.registerServerReference;
+exports.setFindSourceMapURLCallback = __webpack_exports__.setFindSourceMapURLCallback;
+exports.setServerCallback = __webpack_exports__.setServerCallback;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createFromFetch",
+    "createFromReadableStream",
+    "createServerReference",
+    "createTemporaryReferenceSet",
+    "encodeReply",
+    "registerServerReference",
+    "setFindSourceMapURLCallback",
+    "setServerCallback"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});