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

package/dist/cjs/core/browser/index.js

@@ -0,0 +1,150 @@
+"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__, {
+    hydrateWithReact17: ()=>hydrateWithReact17,
+    hydrateWithReact18: ()=>hydrateWithReact18,
+    render: ()=>render,
+    renderWithReact17: ()=>renderWithReact17,
+    renderWithReact18: ()=>renderWithReact18
+});
+const constants_namespaceObject = require("@modern-js/utils/universal/constants");
+const external_cookie_namespaceObject = require("cookie");
+const index_js_namespaceObject = require("../context/index.js");
+const runtime_js_namespaceObject = require("../context/runtime.js");
+const wrapper_js_namespaceObject = require("../react/wrapper.js");
+const external_hydrate_js_namespaceObject = require("./hydrate.js");
+const IS_REACT18 = 'true' === process.env.IS_REACT18;
+const getQuery = ()=>window.location.search.substring(1).split('&').reduce((res, item)=>{
+        const [key, value] = item.split('=');
+        if (key) res[key] = value;
+        return res;
+    }, {});
+const getCookieMap = ()=>{
+    const parsed = (0, external_cookie_namespaceObject.parse)(document.cookie || '');
+    return Object.fromEntries(Object.entries(parsed).filter((entry)=>'string' == typeof entry[1]));
+};
+function getSSRData() {
+    const ssrData = window._SSR_DATA;
+    const ssrRequest = ssrData?.context?.request;
+    const finalSSRData = {
+        ...ssrData || {
+            renderLevel: 0,
+            mode: 'string'
+        },
+        context: {
+            ...ssrData?.context || {},
+            request: {
+                ...ssrData?.context?.request || {},
+                params: ssrRequest?.params || {},
+                host: ssrRequest?.host || location.host,
+                pathname: ssrRequest?.pathname || location.pathname,
+                headers: ssrRequest?.headers || {},
+                cookieMap: getCookieMap(),
+                cookie: document.cookie || '',
+                userAgent: ssrRequest?.headers?.['user-agent'] || navigator.userAgent,
+                referer: document.referrer,
+                query: {
+                    ...getQuery(),
+                    ...ssrRequest?.query || {}
+                },
+                url: location.href
+            }
+        }
+    };
+    return finalSSRData;
+}
+function isClientArgs(id) {
+    return void 0 === id || 'string' == typeof id || "u" > typeof HTMLElement && id instanceof HTMLElement;
+}
+async function render(App, id) {
+    const context = (0, runtime_js_namespaceObject.getInitialContext)();
+    const runBeforeRender = async (context)=>{
+        const internalRuntimeContext = (0, index_js_namespaceObject.getGlobalInternalRuntimeContext)();
+        const api = internalRuntimeContext.pluginAPI;
+        api.updateRuntimeContext(context);
+        const hooks = internalRuntimeContext.hooks;
+        await hooks.onBeforeRender.call(context);
+    };
+    if (isClientArgs(id)) {
+        const ssrData = getSSRData();
+        Object.assign(context, {
+            _internalRouterBaseName: App.props.basename,
+            ssrContext: ssrData.context,
+            initialData: ssrData.data?.initialData
+        });
+        await runBeforeRender(context);
+        const rootElement = id && 'string' != typeof id ? id : document.getElementById(id || 'root');
+        async function ModernRender(App) {
+            const renderFunc = IS_REACT18 ? renderWithReact18 : renderWithReact17;
+            return renderFunc(App, rootElement);
+        }
+        async function ModernHydrate(App, callback) {
+            const hydrateFunc = IS_REACT18 ? hydrateWithReact18 : hydrateWithReact17;
+            return hydrateFunc(App, rootElement, callback);
+        }
+        if (window._SSR_DATA) return (0, external_hydrate_js_namespaceObject.hydrateRoot)(App, context, ModernRender, ModernHydrate);
+        return ModernRender((0, wrapper_js_namespaceObject.wrapRuntimeContextProvider)(App, context));
+    }
+    throw Error('`render` function needs id in browser environment, it needs to be string or element');
+}
+async function renderWithReact18(App, rootElement) {
+    const ReactDOM = await import("react-dom/client");
+    const root = ReactDOM.createRoot(rootElement);
+    root.render(App);
+    return root;
+}
+async function renderWithReact17(App, rootElement) {
+    const ReactDOM = await import("react-dom");
+    ReactDOM.render(App, rootElement);
+    return rootElement;
+}
+async function hydrateWithReact18(App, rootElement) {
+    const ReactDOM = await import("react-dom/client");
+    const root = ReactDOM.hydrateRoot(rootElement, App, {
+        identifierPrefix: constants_namespaceObject.SSR_HYDRATION_ID_PREFIX
+    });
+    return root;
+}
+async function hydrateWithReact17(App, rootElement, callback) {
+    const ReactDOM = await import("react-dom");
+    const root = ReactDOM.hydrate(App, rootElement, callback);
+    return root;
+}
+exports.hydrateWithReact17 = __webpack_exports__.hydrateWithReact17;
+exports.hydrateWithReact18 = __webpack_exports__.hydrateWithReact18;
+exports.render = __webpack_exports__.render;
+exports.renderWithReact17 = __webpack_exports__.renderWithReact17;
+exports.renderWithReact18 = __webpack_exports__.renderWithReact18;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "hydrateWithReact17",
+    "hydrateWithReact18",
+    "render",
+    "renderWithReact17",
+    "renderWithReact18"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/core/browser/withCallback.js

@@ -0,0 +1,47 @@
+"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__, {
+    WithCallback: ()=>WithCallback
+});
+const external_react_namespaceObject = require("react");
+const WithCallback = ({ callback, children })=>{
+    const once = (0, external_react_namespaceObject.useRef)(false);
+    (0, external_react_namespaceObject.useLayoutEffect)(()=>{
+        if (once.current) return;
+        once.current = true;
+        callback();
+    }, [
+        callback
+    ]);
+    return children;
+};
+exports.WithCallback = __webpack_exports__.WithCallback;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "WithCallback"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/core/compat/hooks.js

@@ -0,0 +1,75 @@
+"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__, {
+    getHookRunners: ()=>getHookRunners,
+    handleSetupResult: ()=>handleSetupResult,
+    transformHookRunner: ()=>transformHookRunner
+});
+function transformHookRunner(hookRunnerName) {
+    switch(hookRunnerName){
+        case 'beforeRender':
+            return 'onBeforeRender';
+        default:
+            return hookRunnerName;
+    }
+}
+function handleSetupResult(setupResult, api) {
+    if (!setupResult) return;
+    Object.keys(setupResult).forEach((key)=>{
+        const fn = setupResult[key];
+        if ('function' == typeof fn) {
+            const newAPI = transformHookRunner(key);
+            if (api[newAPI]) if ('beforeRender' === key) api[newAPI](async (...params)=>{
+                await fn(...params);
+            });
+            else api[newAPI]((...params)=>{
+                const res = fn(...params);
+                return res;
+            });
+        }
+    });
+}
+function getHookRunners(runtimeContext) {
+    const { _internalContext } = runtimeContext;
+    const { hooks } = _internalContext;
+    return {
+        beforeRender: async (context)=>hooks.onBeforeRender.call(context),
+        wrapRoot: (App)=>hooks.wrapRoot.call(App),
+        pickContext: (context)=>hooks.pickContext.call(context),
+        config: ()=>hooks.config.call()
+    };
+}
+exports.getHookRunners = __webpack_exports__.getHookRunners;
+exports.handleSetupResult = __webpack_exports__.handleSetupResult;
+exports.transformHookRunner = __webpack_exports__.transformHookRunner;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getHookRunners",
+    "handleSetupResult",
+    "transformHookRunner"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/core/compat/index.js

@@ -0,0 +1,46 @@
+"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__, {
+    compatPlugin: ()=>compatPlugin
+});
+const external_hooks_js_namespaceObject = require("./hooks.js");
+const compatPlugin = ()=>({
+        name: '@modern-js/runtime-plugin-compat',
+        _registryApi: (getRuntimeContext)=>({
+                useRuntimeConfigContext: ()=>{
+                    const { _internalContext } = getRuntimeContext();
+                    return _internalContext.config;
+                },
+                useHookRunners: ()=>(0, external_hooks_js_namespaceObject.getHookRunners)(getRuntimeContext())
+            })
+    });
+exports.compatPlugin = __webpack_exports__.compatPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "compatPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/core/compat/requestContext.js

@@ -0,0 +1,59 @@
+"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__, {
+    makeRequestContext: ()=>makeRequestContext,
+    requestContextPlugin: ()=>requestContextPlugin
+});
+const makeRequestContext = (context)=>{
+    const baseSSRContext = context.ssrContext;
+    if (baseSSRContext) return {
+        request: baseSSRContext.request,
+        response: baseSSRContext.response
+    };
+    return {
+        request: {},
+        response: {}
+    };
+};
+const requestContextPlugin = ()=>({
+        name: '@modern-js/runtime-plugin-request-context',
+        setup (api) {
+            api.onBeforeRender((context)=>{
+                const requestContext = makeRequestContext(context);
+                context.requestContext = requestContext;
+                context.context = requestContext;
+            });
+        }
+    });
+exports.makeRequestContext = __webpack_exports__.makeRequestContext;
+exports.requestContextPlugin = __webpack_exports__.requestContextPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "makeRequestContext",
+    "requestContextPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/core/config.js

@@ -0,0 +1,36 @@
+"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__, {
+    defineRuntimeConfig: ()=>defineRuntimeConfig
+});
+const defineRuntimeConfig = (config)=>config;
+exports.defineRuntimeConfig = __webpack_exports__.defineRuntimeConfig;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "defineRuntimeConfig"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/core/constants.js

@@ -0,0 +1,48 @@
+"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__, {
+    ROUTER_DATA_JSON_ID: ()=>ROUTER_DATA_JSON_ID,
+    RenderLevel: ()=>RenderLevel,
+    SSR_DATA_JSON_ID: ()=>SSR_DATA_JSON_ID
+});
+var RenderLevel = /*#__PURE__*/ function(RenderLevel) {
+    RenderLevel[RenderLevel["CLIENT_RENDER"] = 0] = "CLIENT_RENDER";
+    RenderLevel[RenderLevel["SERVER_RENDER"] = 2] = "SERVER_RENDER";
+    return RenderLevel;
+}({});
+const SSR_DATA_JSON_ID = '__MODERN_SSR_DATA__';
+const ROUTER_DATA_JSON_ID = '__MODERN_ROUTER_DATA__';
+exports.ROUTER_DATA_JSON_ID = __webpack_exports__.ROUTER_DATA_JSON_ID;
+exports.RenderLevel = __webpack_exports__.RenderLevel;
+exports.SSR_DATA_JSON_ID = __webpack_exports__.SSR_DATA_JSON_ID;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ROUTER_DATA_JSON_ID",
+    "RenderLevel",
+    "SSR_DATA_JSON_ID"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/core/context/index.js

@@ -0,0 +1,124 @@
+"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__, {
+    InternalRuntimeContext: ()=>external_runtime_js_namespaceObject.InternalRuntimeContext,
+    RuntimeContext: ()=>external_runtime_js_namespaceObject.RuntimeContext,
+    getCurrentEntryName: ()=>getCurrentEntryName,
+    getGlobalApp: ()=>getGlobalApp,
+    getGlobalBasename: ()=>getGlobalBasename,
+    getGlobalEnableRsc: ()=>getGlobalEnableRsc,
+    getGlobalInternalRuntimeContext: ()=>getGlobalInternalRuntimeContext,
+    getGlobalIsRscClient: ()=>getGlobalIsRscClient,
+    getGlobalLayoutApp: ()=>getGlobalLayoutApp,
+    getGlobalRSCRoot: ()=>getGlobalRSCRoot,
+    getGlobalRoutes: ()=>getGlobalRoutes,
+    getInitialContext: ()=>external_runtime_js_namespaceObject.getInitialContext,
+    getServerPayload: ()=>index_js_namespaceObject.getServerPayload,
+    setGlobalContext: ()=>setGlobalContext,
+    setGlobalInternalRuntimeContext: ()=>setGlobalInternalRuntimeContext,
+    setServerPayload: ()=>index_js_namespaceObject.setServerPayload
+});
+const external_runtime_js_namespaceObject = require("./runtime.js");
+const index_js_namespaceObject = require("./serverPayload/index.js");
+const globalContext = {};
+function getGlobalIsRscClient() {
+    return globalContext.isRscClient;
+}
+function getGlobalEnableRsc() {
+    return globalContext.enableRsc;
+}
+function setGlobalContext(context) {
+    globalContext.entryName = context.entryName;
+    globalContext.App = context.App;
+    globalContext.routes = context.routes;
+    globalContext.appInit = context.appInit;
+    globalContext.layoutApp = context.layoutApp;
+    globalContext.basename = context.basename;
+    globalContext.RSCRoot = context.RSCRoot;
+    globalContext.isRscClient = context.isRscClient;
+    globalContext.enableRsc = context.enableRsc;
+}
+function getCurrentEntryName() {
+    return globalContext.entryName;
+}
+function getGlobalRSCRoot() {
+    return globalContext.RSCRoot;
+}
+function setGlobalInternalRuntimeContext(context) {
+    globalContext.internalRuntimeContext = context;
+}
+function getGlobalInternalRuntimeContext() {
+    return globalContext.internalRuntimeContext;
+}
+function getGlobalApp() {
+    return globalContext.App;
+}
+function getGlobalRoutes() {
+    return globalContext.routes;
+}
+function getGlobalLayoutApp() {
+    return globalContext.layoutApp;
+}
+function getGlobalBasename() {
+    return globalContext.basename;
+}
+exports.InternalRuntimeContext = __webpack_exports__.InternalRuntimeContext;
+exports.RuntimeContext = __webpack_exports__.RuntimeContext;
+exports.getCurrentEntryName = __webpack_exports__.getCurrentEntryName;
+exports.getGlobalApp = __webpack_exports__.getGlobalApp;
+exports.getGlobalBasename = __webpack_exports__.getGlobalBasename;
+exports.getGlobalEnableRsc = __webpack_exports__.getGlobalEnableRsc;
+exports.getGlobalInternalRuntimeContext = __webpack_exports__.getGlobalInternalRuntimeContext;
+exports.getGlobalIsRscClient = __webpack_exports__.getGlobalIsRscClient;
+exports.getGlobalLayoutApp = __webpack_exports__.getGlobalLayoutApp;
+exports.getGlobalRSCRoot = __webpack_exports__.getGlobalRSCRoot;
+exports.getGlobalRoutes = __webpack_exports__.getGlobalRoutes;
+exports.getInitialContext = __webpack_exports__.getInitialContext;
+exports.getServerPayload = __webpack_exports__.getServerPayload;
+exports.setGlobalContext = __webpack_exports__.setGlobalContext;
+exports.setGlobalInternalRuntimeContext = __webpack_exports__.setGlobalInternalRuntimeContext;
+exports.setServerPayload = __webpack_exports__.setServerPayload;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "InternalRuntimeContext",
+    "RuntimeContext",
+    "getCurrentEntryName",
+    "getGlobalApp",
+    "getGlobalBasename",
+    "getGlobalEnableRsc",
+    "getGlobalInternalRuntimeContext",
+    "getGlobalIsRscClient",
+    "getGlobalLayoutApp",
+    "getGlobalRSCRoot",
+    "getGlobalRoutes",
+    "getInitialContext",
+    "getServerPayload",
+    "setGlobalContext",
+    "setGlobalInternalRuntimeContext",
+    "setServerPayload"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/core/context/monitors/default.js

@@ -0,0 +1,44 @@
+"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__, {
+    defaultMonitors: ()=>defaultMonitors
+});
+const defaultMonitors = {
+    counter (name) {},
+    info: console.info,
+    debug: console.debug,
+    trace: console.trace,
+    warn: console.warn,
+    error: console.error,
+    timing (name, dur) {}
+};
+exports.defaultMonitors = __webpack_exports__.defaultMonitors;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "defaultMonitors"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/core/context/monitors/index.js

@@ -0,0 +1,37 @@
+"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__, {
+    getMonitors: ()=>getMonitors
+});
+const external_default_js_namespaceObject = require("./default.js");
+const getMonitors = ()=>external_default_js_namespaceObject.defaultMonitors;
+exports.getMonitors = __webpack_exports__.getMonitors;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getMonitors"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});