@bleedingdev/modern-js-plugin-tanstack 3.2.0-ultramodern.0

package/dist/cjs/runtime/rsc/payloadRouter.js

@@ -0,0 +1,211 @@
+"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__, {
+    __setTanstackRscPayloadDecoderForTests: ()=>__setTanstackRscPayloadDecoderForTests,
+    createTanstackRscServerPayload: ()=>createTanstackRscServerPayload,
+    handleTanstackRscRedirect: ()=>handleTanstackRscRedirect,
+    isTanstackRscPayloadNavigationEnabled: ()=>isTanstackRscPayloadNavigationEnabled,
+    loadTanstackRscPayload: ()=>loadTanstackRscPayload,
+    loadTanstackRscRouteData: ()=>loadTanstackRscRouteData
+});
+const react_router_namespaceObject = require("@tanstack/react-router");
+const payloadFetchCache = new Map();
+let payloadDecoder;
+function getRouteId(match) {
+    const routeId = match.routeId ?? match.route?.id ?? match.id;
+    return 'string' == typeof routeId ? routeId : void 0;
+}
+function getRouteStaticData(match) {
+    return match.route?.options?.staticData || {};
+}
+function getRouteParentId(match) {
+    const parentId = match.route?.parentRoute?.id;
+    return 'string' == typeof parentId ? parentId : void 0;
+}
+function toRoutePath(match) {
+    const path = match.route?.options?.path;
+    return 'string' == typeof path ? path : void 0;
+}
+function toPayloadRoute(match) {
+    const routeId = getRouteId(match);
+    if (!routeId) return;
+    const staticData = getRouteStaticData(match);
+    const params = match.params && 'object' == typeof match.params ? match.params : {};
+    const pathname = 'string' == typeof match.pathname ? match.pathname : '';
+    return {
+        handle: staticData.modernRouteHandle,
+        hasAction: Boolean(staticData.modernRouteHasAction || staticData.modernRouteAction),
+        hasErrorBoundary: false,
+        hasLoader: Boolean(staticData.modernRouteHasLoader),
+        hasClientLoader: Boolean(staticData.modernRouteHasClientLoader),
+        id: routeId,
+        index: Boolean(match.route?.options?.index) || void 0,
+        params,
+        parentId: getRouteParentId(match),
+        path: toRoutePath(match),
+        pathname,
+        pathnameBase: 'string' == typeof match.pathnameBase ? match.pathnameBase : pathname
+    };
+}
+function createTanstackRscServerPayload(router, options = {}) {
+    const matches = Array.isArray(router.state?.matches) ? router.state.matches : [];
+    const routes = [];
+    const loaderData = {};
+    const errors = {};
+    for (const match of matches){
+        const payloadRoute = toPayloadRoute(match);
+        if (payloadRoute) {
+            routes.push(payloadRoute);
+            if ('loaderData' in match && void 0 !== match.loaderData && !(options.omitClientLoaderData && payloadRoute.hasClientLoader)) loaderData[payloadRoute.id] = match.loaderData;
+            if (void 0 !== match.error) errors[payloadRoute.id] = match.error;
+        }
+    }
+    return {
+        type: 'render',
+        actionData: null,
+        errors: Object.keys(errors).length > 0 ? errors : null,
+        loaderData,
+        location: router.state?.location,
+        routes
+    };
+}
+function handleTanstackRscRedirect(headers, basename, status) {
+    const newHeaders = new Headers(headers);
+    let redirectUrl = headers.get('Location') || '/';
+    if ('/' !== basename) redirectUrl = redirectUrl.replace(basename, '') || '/';
+    newHeaders.set('X-Modernjs-Redirect', redirectUrl);
+    newHeaders.set('X-Modernjs-BaseUrl', basename);
+    newHeaders.delete('Location');
+    return new Response(null, {
+        headers: newHeaders,
+        status
+    });
+}
+function isTanstackRscPayloadNavigationEnabled() {
+    return "u" > typeof window;
+}
+async function decodePayload(stream) {
+    if (payloadDecoder) return payloadDecoder(stream);
+    const runtime = await import("@modern-js/runtime/rsc/client");
+    return runtime.createFromReadableStream(stream);
+}
+function isServerPayload(value) {
+    return Boolean(value) && 'object' == typeof value && 'render' === value.type && Array.isArray(value.routes);
+}
+function createPayloadFetchKey(request) {
+    return request.url;
+}
+function isAbsoluteUrl(value) {
+    try {
+        new URL(value);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+async function fetchTanstackRscPayload(request) {
+    const headers = new Headers(request.headers);
+    headers.set('x-rsc-tree', 'true');
+    const response = await fetch(request.url, {
+        credentials: 'same-origin',
+        headers,
+        method: 'GET',
+        signal: request.signal
+    });
+    const redirectLocation = response.headers.get('X-Modernjs-Redirect');
+    if (redirectLocation) {
+        if (isAbsoluteUrl(redirectLocation)) throw (0, react_router_namespaceObject.redirect)({
+            href: redirectLocation
+        });
+        throw (0, react_router_namespaceObject.redirect)({
+            to: redirectLocation || '/'
+        });
+    }
+    if (404 === response.status && !response.body) throw (0, react_router_namespaceObject.notFound)();
+    if (!response.body) throw new Error('TanStack RSC payload response body is null.');
+    const payload = await decodePayload(response.body);
+    if (!isServerPayload(payload)) throw new Error('Unexpected TanStack RSC payload type.');
+    return payload;
+}
+function loadTanstackRscPayload(request) {
+    const key = createPayloadFetchKey(request);
+    let payloadPromise = payloadFetchCache.get(key);
+    if (!payloadPromise) {
+        payloadPromise = fetchTanstackRscPayload(request).finally(()=>{
+            payloadFetchCache.delete(key);
+        });
+        payloadFetchCache.set(key, payloadPromise);
+    }
+    return payloadPromise;
+}
+function isSerializedNotFound(value) {
+    return Boolean(value) && 'object' == typeof value && true === value.isNotFound;
+}
+function toRouteErrors(payload) {
+    return payload.errors && 'object' == typeof payload.errors ? payload.errors : {};
+}
+function toRouteLoaderData(payload) {
+    return payload.loaderData && 'object' == typeof payload.loaderData ? payload.loaderData : {};
+}
+async function loadTanstackRscRouteData({ hasClientLoader, loadClientData, request, routeId }) {
+    if (hasClientLoader) return loadClientData();
+    if (!routeId) return loadClientData();
+    const payload = await loadTanstackRscPayload(request);
+    const errors = toRouteErrors(payload);
+    const routeError = errors[routeId];
+    if (void 0 !== routeError) {
+        if (isSerializedNotFound(routeError)) throw (0, react_router_namespaceObject.notFound)({
+            ...routeError,
+            routeId
+        });
+        throw routeError;
+    }
+    const loaderData = toRouteLoaderData(payload);
+    if (routeId in loaderData) return loaderData[routeId];
+    const payloadRoute = payload.routes.find((route)=>route.id === routeId);
+    if (payloadRoute && payloadRoute.hasClientLoader) return loadClientData();
+}
+function __setTanstackRscPayloadDecoderForTests(decoder) {
+    payloadDecoder = decoder;
+    payloadFetchCache.clear();
+}
+exports.__setTanstackRscPayloadDecoderForTests = __webpack_exports__.__setTanstackRscPayloadDecoderForTests;
+exports.createTanstackRscServerPayload = __webpack_exports__.createTanstackRscServerPayload;
+exports.handleTanstackRscRedirect = __webpack_exports__.handleTanstackRscRedirect;
+exports.isTanstackRscPayloadNavigationEnabled = __webpack_exports__.isTanstackRscPayloadNavigationEnabled;
+exports.loadTanstackRscPayload = __webpack_exports__.loadTanstackRscPayload;
+exports.loadTanstackRscRouteData = __webpack_exports__.loadTanstackRscRouteData;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "__setTanstackRscPayloadDecoderForTests",
+    "createTanstackRscServerPayload",
+    "handleTanstackRscRedirect",
+    "isTanstackRscPayloadNavigationEnabled",
+    "loadTanstackRscPayload",
+    "loadTanstackRscRouteData"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/rsc/server.js

@@ -0,0 +1,246 @@
+"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__, {
+    CompositeComponent: ()=>external_CompositeComponent_js_namespaceObject.CompositeComponent,
+    createCompositeComponent: ()=>createCompositeComponent,
+    getTanstackRscSerializationAdapters: ()=>getTanstackRscSerializationAdapters,
+    renderServerComponent: ()=>renderServerComponent,
+    rscSerializationAdapter: ()=>rscSerializationAdapter
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const server_namespaceObject = require("@modern-js/runtime/rsc/server");
+const react_router_namespaceObject = require("@tanstack/react-router");
+const router_core_namespaceObject = require("@tanstack/router-core");
+const external_react_namespaceObject = require("react");
+const external_ClientSlot_js_namespaceObject = require("./ClientSlot.js");
+const external_createRscProxy_js_namespaceObject = require("./createRscProxy.js");
+const external_ReplayableStream_js_namespaceObject = require("./ReplayableStream.js");
+const external_slotUsageSanitizer_js_namespaceObject = require("./slotUsageSanitizer.js");
+const external_symbols_js_namespaceObject = require("./symbols.js");
+const external_CompositeComponent_js_namespaceObject = require("./CompositeComponent.js");
+function createTreeGetter(stream) {
+    let ready = false;
+    let tree;
+    const treePromise = Promise.resolve((0, server_namespaceObject.createFromReadableStream)(stream.createReplayStream())).then((value)=>{
+        tree = value;
+        ready = true;
+        return value;
+    });
+    return ()=>{
+        if (ready) return tree;
+        return (0, external_react_namespaceObject.use)(treePromise);
+    };
+}
+function createSlotProxy(options) {
+    const cache = new Map();
+    return new Proxy({}, {
+        get (_target, prop) {
+            if ('then' === prop || 'string' != typeof prop) return;
+            if ('children' === prop) {
+                options?.onSlotCall?.('children', []);
+                return /*#__PURE__*/ (0, external_react_namespaceObject.createElement)(external_ClientSlot_js_namespaceObject.ClientSlot, {
+                    args: [],
+                    slot: 'children'
+                });
+            }
+            if (!cache.has(prop)) cache.set(prop, (...args)=>{
+                options?.onSlotCall?.(prop, args);
+                return /*#__PURE__*/ (0, external_react_namespaceObject.createElement)(external_ClientSlot_js_namespaceObject.ClientSlot, {
+                    args,
+                    slot: prop
+                });
+            });
+            return cache.get(prop);
+        }
+    });
+}
+function toReplayableFlightStream(node, handlers) {
+    const flightStream = (0, server_namespaceObject.renderRsc)({
+        element: node
+    });
+    return new external_ReplayableStream_js_namespaceObject.ReplayableStream(handlers ? wrapReadableStream(flightStream, handlers) : flightStream);
+}
+async function renderServerComponent(node) {
+    const stream = toReplayableFlightStream(/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(jsx_runtime_namespaceObject.Fragment, {
+        children: node
+    }));
+    const streamWrapper = {
+        createReplayStream: ()=>stream.createReplayStream()
+    };
+    return (0, external_createRscProxy_js_namespaceObject.createRscProxy)(createTreeGetter(streamWrapper), {
+        renderable: true,
+        stream: streamWrapper
+    });
+}
+async function createCompositeComponent(component) {
+    const slotUsagesEmitter = 'development' === process.env.NODE_ENV ? createReadableStreamEmitter() : void 0;
+    const slotProxy = createSlotProxy({
+        onSlotCall: slotUsagesEmitter ? (slot, args)=>{
+            const sanitizedArgs = (0, external_slotUsageSanitizer_js_namespaceObject.sanitizeSlotArgs)(args);
+            slotUsagesEmitter.emit({
+                slot,
+                ...sanitizedArgs.length ? {
+                    args: sanitizedArgs
+                } : {}
+            });
+        } : void 0
+    });
+    async function ServerComponentWrapper() {
+        return component(slotProxy);
+    }
+    const flightStream = toReplayableFlightStream(/*#__PURE__*/ (0, external_react_namespaceObject.createElement)(ServerComponentWrapper), slotUsagesEmitter ? {
+        onCancel: slotUsagesEmitter.close,
+        onDone: slotUsagesEmitter.close,
+        onError: slotUsagesEmitter.close
+    } : void 0);
+    const streamWrapper = {
+        createReplayStream: ()=>flightStream.createReplayStream()
+    };
+    return (0, external_createRscProxy_js_namespaceObject.createRscProxy)(createTreeGetter(streamWrapper), {
+        renderable: false,
+        slotUsagesStream: slotUsagesEmitter?.stream,
+        stream: streamWrapper
+    });
+}
+const adapter = (0, react_router_namespaceObject.createSerializationAdapter)({
+    key: '$MODERN_TANSTACK_RSC',
+    test: external_symbols_js_namespaceObject.isServerComponent,
+    toSerializable: (component)=>{
+        const streamWrapper = component[external_symbols_js_namespaceObject.SERVER_COMPONENT_STREAM];
+        if (!streamWrapper) throw new Error('Cannot serialize TanStack RSC without a Flight stream.');
+        const kind = (0, external_symbols_js_namespaceObject.isRenderableServerComponent)(component) ? 'renderable' : 'composite';
+        const slotUsagesStream = 'development' === process.env.NODE_ENV && 'composite' === kind ? component[external_symbols_js_namespaceObject.RSC_SLOT_USAGES_STREAM] : void 0;
+        return {
+            kind,
+            stream: new router_core_namespaceObject.RawStream(streamWrapper.createReplayStream(), {
+                hint: 'text'
+            }),
+            ...slotUsagesStream ? {
+                slotUsagesStream
+            } : {}
+        };
+    },
+    fromSerializable: ()=>{
+        throw new Error('TanStack RSC data should not be deserialized on server.');
+    }
+});
+function getTanstackRscSerializationAdapters() {
+    return [
+        adapter
+    ];
+}
+const rscSerializationAdapter = getTanstackRscSerializationAdapters;
+function createReadableStreamEmitter() {
+    let closed = false;
+    const queue = [];
+    let controller = null;
+    const stream = new ReadableStream({
+        start (ctrl) {
+            controller = ctrl;
+            for (const value of queue)ctrl.enqueue(value);
+            queue.length = 0;
+            if (closed) ctrl.close();
+        },
+        cancel () {
+            closed = true;
+            controller = null;
+            queue.length = 0;
+        }
+    });
+    const emit = (value)=>{
+        if (closed) return;
+        if (!controller) return void queue.push(value);
+        try {
+            controller.enqueue(value);
+        } catch  {}
+    };
+    const close = ()=>{
+        if (closed) return;
+        closed = true;
+        try {
+            controller?.close();
+        } catch  {}
+        controller = null;
+    };
+    return {
+        close,
+        emit,
+        stream
+    };
+}
+function wrapReadableStream(source, handlers) {
+    const reader = source.getReader();
+    let finished = false;
+    const finish = (kind)=>{
+        if (finished) return;
+        finished = true;
+        if ('cancel' === kind) handlers.onCancel?.();
+        else if ('error' === kind) handlers.onError?.();
+        else handlers.onDone?.();
+        try {
+            reader.releaseLock();
+        } catch  {}
+    };
+    return new ReadableStream({
+        async pull (controller) {
+            try {
+                const { done, value } = await reader.read();
+                if (done) {
+                    controller.close();
+                    finish('done');
+                    return;
+                }
+                controller.enqueue(value);
+            } catch (err) {
+                try {
+                    controller.error(err);
+                } catch  {}
+                finish('error');
+            }
+        },
+        async cancel (reason) {
+            try {
+                await reader.cancel(reason);
+            } catch  {}
+            finish('cancel');
+        }
+    });
+}
+exports.CompositeComponent = __webpack_exports__.CompositeComponent;
+exports.createCompositeComponent = __webpack_exports__.createCompositeComponent;
+exports.getTanstackRscSerializationAdapters = __webpack_exports__.getTanstackRscSerializationAdapters;
+exports.renderServerComponent = __webpack_exports__.renderServerComponent;
+exports.rscSerializationAdapter = __webpack_exports__.rscSerializationAdapter;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "CompositeComponent",
+    "createCompositeComponent",
+    "getTanstackRscSerializationAdapters",
+    "renderServerComponent",
+    "rscSerializationAdapter"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/rsc/slotUsageSanitizer.js

@@ -0,0 +1,65 @@
+"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__, {
+    sanitizeSlotArgs: ()=>sanitizeSlotArgs
+});
+const external_react_namespaceObject = require("react");
+const REACT_ELEMENT_TYPE = Symbol.for('react.element');
+const REACT_PORTAL_TYPE = Symbol.for('react.portal');
+const REACT_TRANSITIONAL_ELEMENT_TYPE = Symbol.for('react.transitional.element');
+function isReactElementLike(value) {
+    if (!value || 'object' != typeof value && 'function' != typeof value) return false;
+    if ((0, external_react_namespaceObject.isValidElement)(value)) return true;
+    const type = value.$$typeof;
+    return type === REACT_ELEMENT_TYPE || type === REACT_TRANSITIONAL_ELEMENT_TYPE || type === REACT_PORTAL_TYPE;
+}
+function sanitizeSlotArg(value, seen) {
+    if (isReactElementLike(value)) return 'React element';
+    if (null == value) return value;
+    if ('string' == typeof value || 'number' == typeof value || 'boolean' == typeof value || 'bigint' == typeof value) return value;
+    if ('object' != typeof value && 'function' != typeof value) return String(value);
+    if (seen.has(value)) return '[Circular]';
+    seen.add(value);
+    if (Array.isArray(value)) return value.map((item)=>sanitizeSlotArg(item, seen));
+    const proto = Object.getPrototypeOf(value);
+    if (proto === Object.prototype || null === proto) {
+        const out = {};
+        for (const [key, item] of Object.entries(value))out[key] = sanitizeSlotArg(item, seen);
+        return out;
+    }
+    return String(value);
+}
+function sanitizeSlotArgs(args) {
+    const seen = new WeakSet();
+    return args.map((arg)=>sanitizeSlotArg(arg, seen));
+}
+exports.sanitizeSlotArgs = __webpack_exports__.sanitizeSlotArgs;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "sanitizeSlotArgs"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/rsc/symbols.js

@@ -0,0 +1,72 @@
+"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__, {
+    RENDERABLE_RSC: ()=>RENDERABLE_RSC,
+    RSC_PROXY_GET_TREE: ()=>RSC_PROXY_GET_TREE,
+    RSC_PROXY_PATH: ()=>RSC_PROXY_PATH,
+    RSC_SLOT_USAGES: ()=>RSC_SLOT_USAGES,
+    RSC_SLOT_USAGES_STREAM: ()=>RSC_SLOT_USAGES_STREAM,
+    SERVER_COMPONENT_STREAM: ()=>SERVER_COMPONENT_STREAM,
+    isRenderableServerComponent: ()=>isRenderableServerComponent,
+    isServerComponent: ()=>isServerComponent
+});
+const SERVER_COMPONENT_STREAM = Symbol.for('modern.tanstack.rsc.stream');
+const RENDERABLE_RSC = Symbol.for('modern.tanstack.rsc.renderable');
+const RSC_PROXY_GET_TREE = Symbol.for('modern.tanstack.rsc.proxy.getTree');
+const RSC_PROXY_PATH = Symbol.for('modern.tanstack.rsc.proxy.path');
+const RSC_SLOT_USAGES_STREAM = Symbol.for('modern.tanstack.rsc.slotUsages.stream');
+const RSC_SLOT_USAGES = Symbol.for('modern.tanstack.rsc.slotUsages');
+function isServerComponent(value) {
+    if (null == value) return false;
+    if ('object' != typeof value && 'function' != typeof value) return false;
+    return SERVER_COMPONENT_STREAM in value && void 0 !== value[SERVER_COMPONENT_STREAM];
+}
+function isRenderableServerComponent(value) {
+    if (null == value) return false;
+    if ('object' != typeof value && 'function' != typeof value) return false;
+    return RENDERABLE_RSC in value && true === value[RENDERABLE_RSC];
+}
+exports.RENDERABLE_RSC = __webpack_exports__.RENDERABLE_RSC;
+exports.RSC_PROXY_GET_TREE = __webpack_exports__.RSC_PROXY_GET_TREE;
+exports.RSC_PROXY_PATH = __webpack_exports__.RSC_PROXY_PATH;
+exports.RSC_SLOT_USAGES = __webpack_exports__.RSC_SLOT_USAGES;
+exports.RSC_SLOT_USAGES_STREAM = __webpack_exports__.RSC_SLOT_USAGES_STREAM;
+exports.SERVER_COMPONENT_STREAM = __webpack_exports__.SERVER_COMPONENT_STREAM;
+exports.isRenderableServerComponent = __webpack_exports__.isRenderableServerComponent;
+exports.isServerComponent = __webpack_exports__.isServerComponent;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "RENDERABLE_RSC",
+    "RSC_PROXY_GET_TREE",
+    "RSC_PROXY_PATH",
+    "RSC_SLOT_USAGES",
+    "RSC_SLOT_USAGES_STREAM",
+    "SERVER_COMPONENT_STREAM",
+    "isRenderableServerComponent",
+    "isServerComponent"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/types.js

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