@modern-js/runtime 2.69.4 → 3.0.0-alpha.0

package/dist/esm/router/cli/handler.mjs

@@ -0,0 +1,66 @@
+import path from "path";
+import { getMeta } from "@modern-js/utils";
+import { cloneDeep } from "@modern-js/utils/lodash";
+import { runtimeGlobalContext } from "./code/templates";
+import { isPageComponentFile } from "./code/utils";
+import { modifyEntrypoints } from "./entry";
+let originEntrypoints = [];
+async function handleModifyEntrypoints(entrypoints) {
+    return modifyEntrypoints(entrypoints);
+}
+async function handleGeneratorEntryCode(api, entrypoints) {
+    const appContext = api.getAppContext();
+    const { internalDirectory } = appContext;
+    const resolvedConfig = api.getNormalizedConfig();
+    const { generatorRegisterCode, generateCode, generatorServerRegisterCode } = await import("./code");
+    originEntrypoints = cloneDeep(entrypoints);
+    const enableRsc = resolvedConfig?.server?.rsc;
+    await generateCode(appContext, resolvedConfig, entrypoints, api);
+    await Promise.all(entrypoints.map(async (entrypoint)=>{
+        if (entrypoint.nestedRoutesEntry || entrypoint.pageRoutesEntry) {
+            const route = appContext.serverRoutes.find((r)=>r.entryName === entrypoint.entryName);
+            const basename = route?.urlPath || '/';
+            generatorRegisterCode(internalDirectory, entrypoint.entryName, await runtimeGlobalContext({
+                entryName: entrypoint.entryName,
+                metaName: appContext.metaName,
+                srcDirectory: appContext.srcDirectory,
+                nestedRoutesEntry: entrypoint.nestedRoutesEntry,
+                internalSrcAlias: appContext.internalSrcAlias,
+                globalApp: entrypoint.fileSystemRoutes?.globalApp,
+                rscType: enableRsc ? 'client' : void 0,
+                basename
+            }));
+            if (enableRsc) generatorServerRegisterCode(internalDirectory, entrypoint.entryName, await runtimeGlobalContext({
+                entryName: entrypoint.entryName,
+                metaName: appContext.metaName,
+                srcDirectory: appContext.srcDirectory,
+                nestedRoutesEntry: entrypoint.nestedRoutesEntry,
+                internalSrcAlias: appContext.internalSrcAlias,
+                globalApp: entrypoint.fileSystemRoutes?.globalApp,
+                rscType: 'server',
+                basename
+            }));
+        }
+    }));
+    return entrypoints;
+}
+async function handleFileChange(api, e) {
+    const appContext = api.getAppContext();
+    const { appDirectory, entrypoints } = appContext;
+    const { filename, eventType } = e;
+    const nestedRouteEntries = entrypoints.map((point)=>point.nestedRoutesEntry).filter(Boolean);
+    const pagesDir = entrypoints.map((point)=>point.entry).filter((entry)=>entry && !path.extname(entry)).concat(nestedRouteEntries);
+    const isPageFile = (name)=>pagesDir.some((pageDir)=>name.includes(pageDir));
+    const absoluteFilePath = path.resolve(appDirectory, filename);
+    const isRouteComponent = isPageFile(absoluteFilePath) && isPageComponentFile(absoluteFilePath);
+    const meta = getMeta(appContext.metaName);
+    const normalizedFilename = filename.replace(/\\/g, '/');
+    const isConfigRoutesFile = normalizedFilename.includes(`${meta}.routes.`) && /\.(js|ts|jsx|tsx|mjs|mts)$/i.test(path.extname(filename));
+    if (isRouteComponent && ('add' === eventType || 'unlink' === eventType) || isConfigRoutesFile && ('change' === eventType || 'add' === eventType || 'unlink' === eventType)) {
+        const resolvedConfig = api.getNormalizedConfig();
+        const { generateCode } = await import("./code");
+        const entrypoints = cloneDeep(originEntrypoints);
+        await generateCode(appContext, resolvedConfig, entrypoints, api);
+    }
+}
+export { handleFileChange, handleGeneratorEntryCode, handleModifyEntrypoints };

package/dist/esm/router/cli/index.mjs

@@ -0,0 +1,80 @@
+import node_path from "node:path";
+import { NESTED_ROUTE_SPEC_FILE, filterRoutesForServer, fs } from "@modern-js/utils";
+import { isRouteEntry } from "./entry";
+import { handleFileChange, handleGeneratorEntryCode, handleModifyEntrypoints } from "./handler";
+const routerPlugin = ()=>({
+        name: '@modern-js/plugin-router',
+        required: [
+            '@modern-js/runtime'
+        ],
+        setup: (api)=>{
+            const nestedRoutes = {};
+            const nestedRoutesForServer = {};
+            const { metaName } = api.getAppContext();
+            api.addCommand(({ program })=>{
+                program.command('routes').description('generate routes inspect report').action(async ()=>{
+                    const { generateRoutesInspectReport } = await import("./code/inspect");
+                    await generateRoutesInspectReport(api);
+                });
+            });
+            api._internalRuntimePlugins(({ entrypoint, plugins })=>{
+                const { nestedRoutesEntry } = entrypoint;
+                const { serverRoutes, metaName } = api.getAppContext();
+                const serverBase = serverRoutes.filter((route)=>route.entryName === entrypoint.entryName).map((route)=>route.urlPath).sort((a, b)=>a.length - b.length > 0 ? -1 : 1);
+                if (nestedRoutesEntry) plugins.push({
+                    name: 'router',
+                    path: `@${metaName}/runtime/router/internal`,
+                    config: {
+                        serverBase
+                    }
+                });
+                return {
+                    entrypoint,
+                    plugins
+                };
+            });
+            api.checkEntryPoint(({ path, entry })=>({
+                    path,
+                    entry: entry || isRouteEntry(path)
+                }));
+            api.config(()=>({
+                    source: {
+                        include: [
+                            /[\\/]node_modules[\\/]react-router[\\/]/,
+                            /[\\/]node_modules[\\/]react-router-dom[\\/]/,
+                            node_path.resolve(__dirname, '../runtime').replace('cjs', 'esm')
+                        ]
+                    }
+                }));
+            api.modifyEntrypoints(async ({ entrypoints })=>{
+                const newEntryPoints = await handleModifyEntrypoints(entrypoints);
+                return {
+                    entrypoints: newEntryPoints
+                };
+            });
+            api.generateEntryCode(async ({ entrypoints })=>{
+                await handleGeneratorEntryCode(api, entrypoints);
+            });
+            api.onFileChanged(async (e)=>{
+                await handleFileChange(api, e);
+            });
+            api.modifyFileSystemRoutes(({ entrypoint, routes })=>{
+                nestedRoutes[entrypoint.entryName] = routes;
+                nestedRoutesForServer[entrypoint.entryName] = filterRoutesForServer(routes);
+                return {
+                    entrypoint,
+                    routes
+                };
+            });
+            api.onBeforeGenerateRoutes(async ({ entrypoint, code })=>{
+                const { distDirectory } = api.getAppContext();
+                await fs.outputJSON(node_path.resolve(distDirectory, NESTED_ROUTE_SPEC_FILE), nestedRoutesForServer);
+                return {
+                    entrypoint,
+                    code
+                };
+            });
+        }
+    });
+const cli = routerPlugin;
+export { cli as default, handleFileChange, handleModifyEntrypoints, isRouteEntry, routerPlugin };

package/dist/{esm-node/router/internal.js → esm/router/internal.mjs}

@@ -1,5 +1,3 @@
-export * from "./runtime/internal";
 import { routerPlugin } from "./runtime/internal";
-export {
-  routerPlugin as default
-};
+export * from "./runtime/internal";
+export { routerPlugin as default };

package/dist/esm/router/runtime/DefaultNotFound.mjs

@@ -0,0 +1,13 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+const DefaultNotFound = ()=>/*#__PURE__*/ jsx("div", {
+        style: {
+            margin: '150px auto',
+            textAlign: 'center',
+            display: 'flex',
+            alignItems: 'center',
+            justifyContent: 'center'
+        },
+        children: "404"
+    });
+export { DefaultNotFound };

package/dist/esm/router/runtime/DeferredDataScripts.mjs

@@ -0,0 +1,2 @@
+const DeferredDataScripts = ()=>null;
+export { DeferredDataScripts as default };

package/dist/esm/router/runtime/DeferredDataScripts.node.mjs

@@ -0,0 +1,120 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { serializeJson, storage } from "@modern-js/runtime-utils/node";
+import { useEffect, useMemo, useRef } from "react";
+import { ROUTER_DATA_JSON_ID } from "../../core/constants";
+import { modernInline, runWindowFnStr } from "./constants";
+import { serializeErrors } from "./utils";
+const DeferredDataScripts = (props)=>{
+    const staticContext = props?.context;
+    const useJsonScript = props?.useJsonScript;
+    const hydratedRef = useRef(false);
+    useEffect(()=>{
+        hydratedRef.current = true;
+    }, []);
+    const deferredScripts = useMemo(()=>{
+        if (!staticContext) return null;
+        const activeDeferreds = storage.useContext().activeDeferreds;
+        const _ROUTER_DATA = {
+            loaderData: staticContext.loaderData,
+            errors: serializeErrors(staticContext.errors)
+        };
+        const initialScript0 = useJsonScript ? `${serializeJson(_ROUTER_DATA)}` : '';
+        const initialScript1 = useJsonScript ? modernInline : [
+            `_ROUTER_DATA = ${serializeJson(_ROUTER_DATA)};`,
+            modernInline
+        ].join('\n');
+        const deferredDataScripts = [];
+        const initialScripts = Array.from(activeDeferreds.entries()).map(([routeId, deferredData])=>{
+            const pendingKeys = new Set(deferredData.pendingKeys);
+            const { deferredKeys } = deferredData;
+            const deferredKeyPromiseManifests = deferredKeys.map((key)=>{
+                if (pendingKeys.has(key)) return {
+                    key,
+                    routerDataFnName: 's',
+                    routerDataFnArgs: [
+                        serializeJson(routeId),
+                        serializeJson(key)
+                    ]
+                };
+                {
+                    const trackedPromise = deferredData.data[key];
+                    if (void 0 !== trackedPromise._error) {
+                        const error = {
+                            message: trackedPromise._error.message,
+                            stack: 'production' !== process.env.NODE_ENV ? trackedPromise._error.stack : void 0
+                        };
+                        return {
+                            key,
+                            routerDataFnName: 'p',
+                            routerDataFnArgs: [
+                                serializeJson(void 0),
+                                serializeJson(error)
+                            ]
+                        };
+                    }
+                    if (void 0 === trackedPromise._data) throw new Error(`The deferred data for ${key} was not resolved, did you forget to return data from a deferred promise`);
+                    return {
+                        key,
+                        routerDataFnName: 'p',
+                        routerDataFnArgs: [
+                            serializeJson(trackedPromise._data)
+                        ]
+                    };
+                }
+            });
+            return {
+                fnName: "mergeLoaderData",
+                fnRun: runWindowFnStr,
+                fnArgs: [
+                    routeId,
+                    deferredKeyPromiseManifests
+                ],
+                fnScriptSrc: 'modern-run-window-fn'
+            };
+        });
+        return [
+            initialScript0,
+            initialScript1,
+            initialScripts,
+            deferredDataScripts
+        ];
+    }, []);
+    if (!deferredScripts) return null;
+    return /*#__PURE__*/ jsx(Fragment, {
+        children: !hydratedRef.current && /*#__PURE__*/ jsxs(Fragment, {
+            children: [
+                0 !== deferredScripts[0].length && /*#__PURE__*/ jsx("script", {
+                    type: "application/json",
+                    id: ROUTER_DATA_JSON_ID,
+                    nonce: props?.nonce,
+                    suppressHydrationWarning: true,
+                    dangerouslySetInnerHTML: {
+                        __html: deferredScripts[0]
+                    }
+                }),
+                /*#__PURE__*/ jsx("script", {
+                    async: true,
+                    nonce: props?.nonce,
+                    "data-script-src": "modern-inline",
+                    suppressHydrationWarning: true,
+                    dangerouslySetInnerHTML: {
+                        __html: deferredScripts[1]
+                    }
+                }),
+                deferredScripts[2].map(({ fnName, fnArgs, fnRun, fnScriptSrc })=>/*#__PURE__*/ jsx("script", {
+                        async: true,
+                        "data-script-src": fnScriptSrc,
+                        "data-fn-name": fnName,
+                        "data-fn-args": JSON.stringify(fnArgs),
+                        nonce: props?.nonce,
+                        suppressHydrationWarning: true,
+                        dangerouslySetInnerHTML: {
+                            __html: fnRun
+                        }
+                    }, fnName))
+            ]
+        })
+    });
+};
+const DeferredDataScripts_node = DeferredDataScripts;
+export { DeferredDataScripts_node as default };

package/dist/esm/router/runtime/PrefetchLink.mjs

@@ -0,0 +1,161 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Link as router_Link, NavLink, matchRoutes, useHref, useMatches, useResolvedPath } from "@modern-js/runtime-utils/router";
+import react, { useContext, useMemo } from "react";
+import { InternalRuntimeContext } from "../../core/context";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.e = ()=>Promise.resolve();
+})();
+function composeEventHandlers(theirHandler, ourHandler) {
+    return (event)=>{
+        theirHandler?.(event);
+        if (!event.defaultPrevented) ourHandler(event);
+    };
+}
+const ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
+function usePrefetchBehavior(prefetch, theirElementProps) {
+    const [maybePrefetch, setMaybePrefetch] = react.useState(false);
+    const [shouldPrefetch, setShouldPrefetch] = react.useState(false);
+    const { onFocus, onBlur, onMouseEnter, onMouseLeave, onTouchStart } = theirElementProps;
+    react.useEffect(()=>{
+        if ('render' === prefetch) setShouldPrefetch(true);
+    }, [
+        prefetch
+    ]);
+    const setIntent = ()=>{
+        if ('intent' === prefetch) setMaybePrefetch(true);
+    };
+    const cancelIntent = ()=>{
+        if ('intent' === prefetch) {
+            setMaybePrefetch(false);
+            setShouldPrefetch(false);
+        }
+    };
+    react.useEffect(()=>{
+        if (maybePrefetch) {
+            const id = setTimeout(()=>{
+                setShouldPrefetch(true);
+            }, 100);
+            return ()=>{
+                clearTimeout(id);
+            };
+        }
+    }, [
+        maybePrefetch
+    ]);
+    return [
+        shouldPrefetch,
+        {
+            onFocus: composeEventHandlers(onFocus, setIntent),
+            onBlur: composeEventHandlers(onBlur, cancelIntent),
+            onMouseEnter: composeEventHandlers(onMouseEnter, setIntent),
+            onMouseLeave: composeEventHandlers(onMouseLeave, cancelIntent),
+            onTouchStart: composeEventHandlers(onTouchStart, setIntent)
+        }
+    ];
+}
+async function loadRouteModule(route, routeAssets) {
+    const routeId = route.id;
+    if (!routeId) return;
+    if (!routeAssets[routeId]) return;
+    const { chunkIds } = routeAssets[routeId];
+    if (!chunkIds) return;
+    try {
+        await Promise.all(chunkIds.map((chunkId)=>{
+            if ('test' === process.env.NODE_ENV) return __webpack_require__.e?.(chunkId);
+            return __webpack_chunk_load__?.(chunkId);
+        }));
+    } catch (error) {
+        console.error(error);
+    }
+}
+const getRequestUrl = (pathname, routeId)=>{
+    const LOADER_ID_PARAM = '__loader';
+    const DIRECT_PARAM = '__ssrDirect';
+    const { protocol, host } = window.location;
+    const url = new URL(pathname, `${protocol}//${host}`);
+    url.searchParams.append(LOADER_ID_PARAM, routeId);
+    url.searchParams.append(DIRECT_PARAM, 'true');
+    return url;
+};
+const createDataHref = (href)=>/*#__PURE__*/ jsx("link", {
+        rel: "prefetch",
+        as: "fetch",
+        href: href
+    }, href);
+const getDataHref = (route, pathname, basename)=>{
+    const { id } = route;
+    const path = '/' === basename ? pathname : `${basename}${pathname}`;
+    const url = getRequestUrl(path, id);
+    return createDataHref(url.toString());
+};
+const PrefetchPageLinks = ({ path })=>{
+    const { pathname } = path;
+    const context = useContext(InternalRuntimeContext);
+    const { routeManifest, routes } = context;
+    const { routeAssets } = routeManifest || {};
+    const matches = Array.isArray(routes) ? matchRoutes(routes, pathname) : [];
+    if (Array.isArray(matches) && routeAssets) matches?.forEach((match)=>loadRouteModule(match.route, routeAssets));
+    if (!window._SSR_DATA) return null;
+    return /*#__PURE__*/ jsx(PrefetchDataLinks, {
+        matches: matches,
+        path: path,
+        routeManifest: routeManifest
+    });
+};
+const PrefetchDataLinks = ({ matches, path, routeManifest })=>{
+    const { pathname, search, hash } = path;
+    const currentMatches = useMatches();
+    const basename = useHref('/');
+    const dataHrefs = useMemo(()=>matches?.filter((match, index)=>{
+            if (!match.route.loader || 'function' != typeof match.route.loader || 0 === match.route.loader.length) return false;
+            if (match.route.shouldRevalidate) {
+                const currentUrl = new URL(location.pathname + location.search + location.hash, window.origin);
+                const nextUrl = new URL(pathname + search + hash, window.origin);
+                const shouldLoad = match.route.shouldRevalidate({
+                    currentUrl,
+                    currentParams: currentMatches[0]?.params || {},
+                    nextUrl,
+                    nextParams: match.params,
+                    defaultShouldRevalidate: true
+                });
+                if ('boolean' == typeof shouldLoad) return shouldLoad;
+            }
+            const currentMatch = currentMatches[index];
+            if (!currentMatch || currentMatch.id !== match.route.id) return true;
+            if (currentMatch.pathname !== match.pathname) return true;
+            if (currentMatch.pathname.endsWith('*') && currentMatch.params['*'] !== match.params['*']) return true;
+            return false;
+        }).map((match)=>getDataHref(match.route, pathname, basename)), [
+        matches,
+        pathname,
+        routeManifest
+    ]);
+    return /*#__PURE__*/ jsx(Fragment, {
+        children: dataHrefs
+    });
+};
+const createPrefetchLink = (Link)=>/*#__PURE__*/ react.forwardRef(({ to, prefetch = 'none', ...props }, forwardedRef)=>{
+        const isAbsolute = 'string' == typeof to && ABSOLUTE_URL_REGEX.test(to);
+        const [shouldPrefetch, prefetchHandlers] = usePrefetchBehavior(prefetch, props);
+        const resolvedPath = useResolvedPath(to);
+        return /*#__PURE__*/ jsxs(Fragment, {
+            children: [
+                /*#__PURE__*/ jsx(Link, {
+                    ref: forwardedRef,
+                    to: to,
+                    ...props,
+                    ...prefetchHandlers
+                }),
+                shouldPrefetch && __webpack_require__.e && !isAbsolute ? /*#__PURE__*/ jsx(PrefetchPageLinks, {
+                    path: resolvedPath
+                }) : null
+            ]
+        });
+    });
+const PrefetchLink_Link = createPrefetchLink(router_Link);
+PrefetchLink_Link.displayName = 'Link';
+const PrefetchLink_NavLink = createPrefetchLink(NavLink);
+PrefetchLink_NavLink.displayName = 'NavLink';
+export { PrefetchLink_Link as Link, PrefetchLink_NavLink as NavLink };

package/dist/{esm-node/router/runtime/constants.js → esm/router/runtime/constants.mjs}

@@ -1,19 +1,10 @@
 import { ROUTER_DATA_JSON_ID } from "../../core/constants";
-const setupFnStr = `function s(r,e){_ROUTER_DATA.r=_ROUTER_DATA.r||{},_ROUTER_DATA.r[r]=_ROUTER_DATA.r[r]||{};return new Promise((function(A,R){_ROUTER_DATA.r[r][e]={resolve:A,reject:R}}))};`;
-const resolveFnStr = `function r(e,r,o,A){A?_ROUTER_DATA.r[e][r].reject(A):_ROUTER_DATA.r[e][r].resolve(o)};`;
-const preResolvedFnStr = `function p(e,r){return void 0!==r?Promise.reject(new Error(r.message)):Promise.resolve(e)};`;
-const mergeLoaderDataStr = `function mergeLoaderData(e,n){var r=n.reduce((function(e,{key:n,routerDataFnName:r,routerDataFnArgs:a}){var t=a.map((e=>{if("undefined"!==e&&null!==e)return JSON.parse(e)}));return console.info("args",t),{...e,[n]:_ROUTER_DATA[r](...t)}}),{});Object.assign(_ROUTER_DATA.loaderData[e],r)}`;
+const setupFnStr = "function s(r,e){_ROUTER_DATA.r=_ROUTER_DATA.r||{},_ROUTER_DATA.r[r]=_ROUTER_DATA.r[r]||{};return new Promise((function(A,R){_ROUTER_DATA.r[r][e]={resolve:A,reject:R}}))};";
+const resolveFnStr = "function r(e,r,o,A){A?_ROUTER_DATA.r[e][r].reject(A):_ROUTER_DATA.r[e][r].resolve(o)};";
+const preResolvedFnStr = "function p(e,r){return void 0!==r?Promise.reject(new Error(r.message)):Promise.resolve(e)};";
+const mergeLoaderDataStr = 'function mergeLoaderData(e,n){var r=n.reduce((function(e,{key:n,routerDataFnName:r,routerDataFnArgs:a}){var t=a.map((e=>{if("undefined"!==e&&null!==e)return JSON.parse(e)}));return console.info("args",t),{...e,[n]:_ROUTER_DATA[r](...t)}}),{});Object.assign(_ROUTER_DATA.loaderData[e],r)}';
 const initRouterDataAttrs = `_ROUTER_DATA.s = ${setupFnStr}_ROUTER_DATA.r = ${resolveFnStr}_ROUTER_DATA.p = ${preResolvedFnStr}${mergeLoaderDataStr}`;
 const modernInline = `function runWindowFn(){window[document.currentScript.getAttribute("data-fn-name")].apply(window,JSON.parse(document.currentScript.getAttribute("data-fn-args")))}function runRouterDataFn(){_ROUTER_DATA[document.currentScript.getAttribute("data-fn-name")].apply(_ROUTER_DATA,JSON.parse(document.currentScript.getAttribute("data-fn-args")))}function initRouterData(e){var r=document.getElementById(e);if(r)try{_ROUTER_DATA=JSON.parse(r.textContent)}catch(r){console.error("parse ".concat(e," error"),t),_ROUTER_DATA={}}};initRouterData('${ROUTER_DATA_JSON_ID}');${initRouterDataAttrs}`;
-const runRouterDataFnStr = `runRouterDataFn();`;
-const runWindowFnStr = `runWindowFn();`;
-export {
-  initRouterDataAttrs,
-  mergeLoaderDataStr,
-  modernInline,
-  preResolvedFnStr,
-  resolveFnStr,
-  runRouterDataFnStr,
-  runWindowFnStr,
-  setupFnStr
-};
+const runRouterDataFnStr = "runRouterDataFn();";
+const runWindowFnStr = "runWindowFn();";
+export { initRouterDataAttrs, mergeLoaderDataStr, modernInline, preResolvedFnStr, resolveFnStr, runRouterDataFnStr, runWindowFnStr, setupFnStr };

package/dist/esm/router/runtime/hooks.mjs

@@ -0,0 +1,4 @@
+import { createSyncHook } from "@modern-js/plugin";
+const modifyRoutes = createSyncHook();
+const onBeforeCreateRoutes = createSyncHook();
+export { modifyRoutes, onBeforeCreateRoutes };

package/dist/esm/router/runtime/index.mjs

@@ -0,0 +1,9 @@
+import { useRouteLoaderData } from "@modern-js/runtime-utils/router";
+import { Link, NavLink } from "./PrefetchLink";
+export * from "@modern-js/runtime-utils/router";
+export * from "./withRouter";
+const runtime_useRouteLoaderData = (routeId)=>{
+    const realRouteId = routeId.replace(/\[(.*?)\]/g, '($1)');
+    return useRouteLoaderData(realRouteId);
+};
+export { Link, NavLink, runtime_useRouteLoaderData as useRouteLoaderData };

package/dist/esm/router/runtime/internal.mjs

@@ -0,0 +1,4 @@
+import { modifyRoutes, routerPlugin } from "./plugin";
+import { renderRoutes } from "./utils";
+const internal = routerPlugin;
+export { internal as default, modifyRoutes, renderRoutes, routerPlugin };