@bleedingdev/modern-js-app-tools 3.2.0-ultramodern.0

package/dist/cjs/plugins/analyze/getBundleEntry.js

@@ -0,0 +1,97 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+    getBundleEntry: ()=>getBundleEntry
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_getFileSystemEntry_js_namespaceObject = require("./getFileSystemEntry.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+const ensureExtensions = (file)=>{
+    if (!external_path_default().extname(file)) return (0, utils_namespaceObject.findExists)(utils_namespaceObject.JS_EXTENSIONS.map((ext)=>`${file}${ext}`)) || file;
+    return file;
+};
+const isDirectory = (file)=>!external_path_default().extname(file);
+const ifAlreadyExists = (entrypoints, checked)=>entrypoints.some((entrypoint)=>{
+        if (ensureExtensions(entrypoint.entry) === ensureExtensions(checked.entry)) {
+            checked.entryName = entrypoint.entryName;
+            return true;
+        }
+        if ((0, external_utils_js_namespaceObject.isSubDirOrEqual)(entrypoint.entry, checked.entry) || (0, external_utils_js_namespaceObject.isSubDirOrEqual)(checked.entry, entrypoint.entry)) throw new Error(`Entry configuration conflicts\n Your configuration: ${checked.entry}.\n Default entrypoint: ${entrypoint.entry}\n Please reset source.entries or set source.disableDefaultEntries to disable the default entry rules.`);
+        return false;
+    });
+const getBundleEntry = async (hooks, appContext, config)=>{
+    const { appDirectory, packageName } = appContext;
+    const { disableDefaultEntries, entries, entriesDir, mainEntryName } = config.source;
+    const defaults = disableDefaultEntries ? [] : await (0, external_getFileSystemEntry_js_namespaceObject.getFileSystemEntry)(hooks, appContext, config);
+    if (entries) Object.keys(entries).forEach((name)=>{
+        const value = entries[name];
+        const entryName = 'string' == typeof value ? value : value.entry;
+        const entryFile = (0, utils_namespaceObject.ensureAbsolutePath)(appDirectory, entryName);
+        const entryDir = external_path_default().dirname(entryFile);
+        const customEntryFile = (0, external_getFileSystemEntry_js_namespaceObject.hasEntry)(entryDir);
+        const serverEntryFile = (0, external_getFileSystemEntry_js_namespaceObject.hasServerEntry)(entryDir);
+        const isAutoMount = 'string' == typeof value ? true : !value.disableMount;
+        const entrypoint = {
+            entryName: name,
+            isMainEntry: false,
+            entry: 'string' == typeof value ? entryFile : value.customEntry ? customEntryFile || entryFile : entryFile,
+            absoluteEntryDir: isDirectory(entryFile) ? entryFile : external_path_default().dirname(entryFile),
+            isAutoMount,
+            fileSystemRoutes: utils_namespaceObject.fs.statSync(entryFile).isDirectory() ? {} : void 0,
+            isCustomSourceEntry: true,
+            customEntry: 'string' == typeof value ? false : value.customEntry,
+            customServerEntry: 'string' == typeof value ? false : value.customEntry ? serverEntryFile : false
+        };
+        if (!ifAlreadyExists(defaults, entrypoint)) defaults.push(entrypoint);
+    });
+    if (!disableDefaultEntries) {
+        const entriesDirAbs = (0, utils_namespaceObject.ensureAbsolutePath)(appDirectory, entriesDir || '');
+        const found = defaults.find(({ entryName, entry, nestedRoutesEntry = '' })=>entryName === packageName || external_path_default().dirname(entry) === entriesDirAbs || external_path_default().dirname(nestedRoutesEntry) === entriesDirAbs);
+        if (found) {
+            found.entryName = mainEntryName || utils_namespaceObject.MAIN_ENTRY_NAME;
+            found.isMainEntry = true;
+        }
+    }
+    return defaults;
+};
+exports.getBundleEntry = __webpack_exports__.getBundleEntry;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getBundleEntry"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/analyze/getFileSystemEntry.js

@@ -0,0 +1,117 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+    getFileSystemEntry: ()=>getFileSystemEntry,
+    hasEntry: ()=>hasEntry,
+    hasServerEntry: ()=>hasServerEntry
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_fs_namespaceObject = require("fs");
+var external_fs_default = /*#__PURE__*/ __webpack_require__.n(external_fs_namespaceObject);
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_constants_js_namespaceObject = require("./constants.js");
+const hasEntry = (dir)=>(0, utils_namespaceObject.findExists)(utils_namespaceObject.JS_EXTENSIONS.map((ext)=>external_path_default().resolve(dir, `${external_constants_js_namespaceObject.ENTRY_FILE_NAME}${ext}`)));
+const hasServerEntry = (dir)=>(0, utils_namespaceObject.findExists)(utils_namespaceObject.JS_EXTENSIONS.map((ext)=>external_path_default().resolve(dir, `${external_constants_js_namespaceObject.ENTRY_FILE_NAME}.server${ext}`)));
+const isBundleEntry = async (hooks, dir)=>{
+    const { entry } = await hooks.checkEntryPoint.call({
+        path: dir,
+        entry: false
+    });
+    if (entry) return entry;
+    const customEntry = hasEntry(dir);
+    if (customEntry) return customEntry;
+    return false;
+};
+const scanDir = async (hooks, dirs)=>{
+    const entries = await Promise.all(dirs.map(async (dir)=>{
+        const entryName = external_path_default().basename(dir);
+        const customEntryFile = hasEntry(dir);
+        const customServerEntry = hasServerEntry(dir);
+        const entryFile = (await hooks.checkEntryPoint.call({
+            path: dir,
+            entry: false
+        })).entry;
+        if (entryFile) return {
+            entryName,
+            isMainEntry: false,
+            entry: customEntryFile || entryFile,
+            customServerEntry,
+            absoluteEntryDir: external_path_default().resolve(dir),
+            isAutoMount: true,
+            customEntry: Boolean(customEntryFile)
+        };
+        if (customEntryFile) return {
+            entryName,
+            isMainEntry: false,
+            entry: customEntryFile,
+            customServerEntry,
+            absoluteEntryDir: external_path_default().resolve(dir),
+            isAutoMount: false,
+            customEntry: Boolean(customEntryFile)
+        };
+        return false;
+    })).then((entries)=>entries.filter(Boolean));
+    if (0 === entries.length) throw Error('There is no valid entry point in the current project!');
+    return entries;
+};
+const getFileSystemEntry = async (hooks, appContext, config)=>{
+    const { appDirectory } = appContext;
+    const { source: { entriesDir } } = config;
+    const src = (0, utils_namespaceObject.ensureAbsolutePath)(appDirectory, entriesDir || '');
+    if (external_fs_default().existsSync(src)) if (external_fs_default().statSync(src).isDirectory()) {
+        if (await isBundleEntry(hooks, src)) return scanDir(hooks, [
+            src
+        ]);
+        const dirs = [];
+        await Promise.all(external_fs_default().readdirSync(src).map(async (filename)=>{
+            const file = external_path_default().join(src, filename);
+            if (external_fs_default().statSync(file).isDirectory() && await isBundleEntry(hooks, file)) dirs.push(file);
+        }));
+        return scanDir(hooks, dirs);
+    } else throw Error("source.entriesDir accept a directory.");
+    throw Error(`src dir ${entriesDir} not found.`);
+};
+exports.getFileSystemEntry = __webpack_exports__.getFileSystemEntry;
+exports.hasEntry = __webpack_exports__.hasEntry;
+exports.hasServerEntry = __webpack_exports__.hasServerEntry;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getFileSystemEntry",
+    "hasEntry",
+    "hasServerEntry"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/analyze/getHtmlTemplate.js

@@ -0,0 +1,144 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+    getHtmlTemplate: ()=>getHtmlTemplate,
+    getModifyHtmlPartials: ()=>getModifyHtmlPartials
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_constants_js_namespaceObject = require("./constants.js");
+const external_templates_js_namespaceObject = require("./templates.js");
+const findPartials = (dir, entryName, position)=>{
+    if (utils_namespaceObject.fs.existsSync(dir)) {
+        const base = (0, utils_namespaceObject.findExists)(external_constants_js_namespaceObject.HTML_PARTIALS_EXTENSIONS.map((ext)=>external_path_default().resolve(dir, `${position}${ext}`)));
+        const file = entryName ? (0, utils_namespaceObject.findExists)(external_constants_js_namespaceObject.HTML_PARTIALS_EXTENSIONS.map((ext)=>external_path_default().resolve(dir, entryName, `${position}${ext}`))) || base : base;
+        return file ? {
+            file,
+            content: utils_namespaceObject.fs.readFileSync(file, 'utf8')
+        } : null;
+    }
+    return null;
+};
+const getModifyHtmlPartials = (partials)=>{
+    const append = (type, ...script)=>{
+        script.forEach((item)=>{
+            partials[type].push(item);
+        });
+    };
+    const prepend = (type, ...script)=>{
+        script.forEach((item)=>{
+            partials[type].unshift(item);
+        });
+    };
+    return {
+        top: {
+            append: (...script)=>append("top", ...script),
+            prepend: (...script)=>prepend("top", ...script),
+            current: partials.top
+        },
+        head: {
+            append: (...script)=>append("head", ...script),
+            prepend: (...script)=>prepend("head", ...script),
+            current: partials.head
+        },
+        body: {
+            append: (...script)=>append("body", ...script),
+            prepend: (...script)=>prepend("body", ...script),
+            current: partials.body
+        }
+    };
+};
+const resolveConfiguredTemplate = (template, entryName, appDirectory)=>{
+    const filepath = 'function' == typeof template ? template({
+        entryName
+    }) : template;
+    if ('string' != typeof filepath || 0 === filepath.length) return null;
+    return external_path_default().isAbsolute(filepath) ? filepath.replace(/\\/g, '/') : external_path_default().resolve(appDirectory, filepath).replace(/\\/g, '/');
+};
+const getHtmlTemplate = async (entrypoints, hooks, { appContext, config })=>{
+    const { appDirectory, internalDirectory } = appContext;
+    const { source: { configDir } } = config;
+    const htmlDir = external_path_default().resolve(appDirectory, configDir || '', external_constants_js_namespaceObject.HTML_PARTIALS_FOLDER);
+    const htmlTemplates = {};
+    const partialsByEntrypoint = {};
+    for (const entrypoint of entrypoints){
+        const { entryName, isMainEntry } = entrypoint;
+        const name = 1 === entrypoints.length && isMainEntry ? '' : entryName;
+        const configuredTemplate = resolveConfiguredTemplate(config.html.template, entryName, appDirectory);
+        if (configuredTemplate) {
+            htmlTemplates[entryName] = configuredTemplate;
+            continue;
+        }
+        const customIndexTemplate = findPartials(htmlDir, name, "index");
+        if (customIndexTemplate) htmlTemplates[entryName] = customIndexTemplate.file.replace(/\\/g, '/');
+        else {
+            const getPartialInitValue = (position)=>{
+                const partial = findPartials(htmlDir, name, position);
+                return partial ? [
+                    partial.content
+                ] : [];
+            };
+            const partials = {
+                top: getPartialInitValue("top"),
+                head: getPartialInitValue("head"),
+                body: getPartialInitValue("body")
+            };
+            await hooks.modifyHtmlPartials.call({
+                entrypoint,
+                partials: getModifyHtmlPartials(partials)
+            });
+            const templatePath = external_path_default().resolve(internalDirectory, entryName, 'index.html');
+            utils_namespaceObject.fs.outputFileSync(templatePath, external_templates_js_namespaceObject.html(partials), 'utf8');
+            htmlTemplates[entryName] = templatePath.replace(/\\/g, '/');
+            partialsByEntrypoint[entryName] = partials;
+            const bottomTemplate = findPartials(htmlDir, name, "bottom");
+            if (bottomTemplate) htmlTemplates[`__${entryName}-bottom__`] = bottomTemplate.content;
+        }
+    }
+    return {
+        partialsByEntrypoint,
+        htmlTemplates
+    };
+};
+exports.getHtmlTemplate = __webpack_exports__.getHtmlTemplate;
+exports.getModifyHtmlPartials = __webpack_exports__.getModifyHtmlPartials;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getHtmlTemplate",
+    "getModifyHtmlPartials"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/analyze/getServerRoutes.js

@@ -0,0 +1,177 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+    getProdServerRoutes: ()=>getProdServerRoutes,
+    getServerRoutes: ()=>getServerRoutes
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const routes_js_namespaceObject = require("../../utils/routes.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+const applyBaseUrl = (baseUrl, routes)=>{
+    if (baseUrl) if (Array.isArray(baseUrl)) return baseUrl.reduce((previous, current)=>[
+            ...previous,
+            ...applyBaseUrl(current, routes)
+        ], []);
+    else return routes.map((route)=>{
+        const urlPath = (0, utils_namespaceObject.urlJoin)(baseUrl, route.urlPath);
+        return {
+            ...route,
+            urlPath: '/' === urlPath ? urlPath : (0, utils_namespaceObject.removeTailSlash)(urlPath)
+        };
+    });
+    return routes;
+};
+const applyRouteOptions = (original, routeOptions)=>{
+    const { route, disableSpa } = routeOptions;
+    original.isSPA = !disableSpa;
+    original.isSPA || (original.entryPath = external_path_default().dirname(original.entryPath));
+    let routes;
+    if (route) if (Array.isArray(route)) routes = route.map((url)=>{
+        if (!(0, utils_namespaceObject.isPlainObject)(url)) return {
+            ...original,
+            urlPath: url
+        };
+        {
+            const { path: urlPath, ...other } = url;
+            return {
+                ...original,
+                ...other,
+                urlPath
+            };
+        }
+    });
+    else if ((0, utils_namespaceObject.isPlainObject)(route)) {
+        const { path: urlPath, ...other } = route;
+        routes = [
+            {
+                ...original,
+                ...other,
+                urlPath
+            }
+        ];
+    } else routes = [
+        {
+            ...original,
+            urlPath: route
+        }
+    ];
+    else routes = [
+        original
+    ];
+    return routes;
+};
+const collectHtmlRoutes = (entrypoints, appContext, config)=>{
+    const { source: { mainEntryName }, html: { outputStructure }, output: { distPath: { html: htmlPath } = {} }, server: { baseUrl, routes, ssr, ssrByEntries, rsc }, deploy } = config;
+    const { packageName } = appContext;
+    const workerSSR = deploy?.worker?.ssr;
+    let htmlRoutes = entrypoints.reduce((previous, { entryName })=>{
+        const isMain = (0, routes_js_namespaceObject.isMainEntry)(entryName, mainEntryName);
+        const entryOptions = (0, utils_namespaceObject.getEntryOptions)(entryName, isMain, ssr, ssrByEntries, packageName);
+        const isSSR = Boolean(entryOptions);
+        const isWorker = Boolean(workerSSR);
+        const isStream = 'object' == typeof entryOptions && 'stream' === entryOptions.mode;
+        const { resHeaders } = routes?.[entryName] || {};
+        const isRSC = !!rsc;
+        let route = {
+            urlPath: `/${isMain ? '' : entryName}`,
+            entryName,
+            entryPath: (0, utils_namespaceObject.removeLeadingSlash)(external_path_default().posix.normalize(`${htmlPath}/${entryName}${'flat' === outputStructure ? '.html' : '/index.html'}`)),
+            isSPA: true,
+            isStream: isStream || isRSC,
+            isSSR,
+            isRSC,
+            responseHeaders: resHeaders,
+            worker: isWorker ? `${utils_namespaceObject.SERVER_WORKER_BUNDLE_DIRECTORY}/${entryName}.js` : void 0,
+            bundle: isSSR || isRSC ? `${utils_namespaceObject.SERVER_BUNDLE_DIRECTORY}/${entryName}.js` : void 0
+        };
+        if (routes?.hasOwnProperty(entryName)) {
+            const routeOptions = (0, utils_namespaceObject.isPlainObject)(routes[entryName]) ? routes[entryName] : {
+                route: routes[entryName]
+            };
+            route = applyRouteOptions(route, routeOptions);
+        }
+        return Array.isArray(route) ? [
+            ...previous,
+            ...route
+        ] : [
+            ...previous,
+            route
+        ];
+    }, []);
+    htmlRoutes = applyBaseUrl(baseUrl, htmlRoutes);
+    return htmlRoutes;
+};
+const collectStaticRoutes = (appContext, config)=>{
+    const { appDirectory } = appContext;
+    const { source: { configDir }, server: { publicRoutes = {} } } = config;
+    const publicFolder = external_path_default().resolve(appDirectory, configDir || '', 'public');
+    const ignoreFiles = [
+        '.gitkeep'
+    ];
+    return utils_namespaceObject.fs.existsSync(publicFolder) ? (0, external_utils_js_namespaceObject.walkDirectory)(publicFolder).filter((filePath)=>!ignoreFiles.includes(external_path_default().basename(filePath))).map((filePath)=>{
+        const urlPath = `${(0, utils_namespaceObject.urlJoin)(toPosix(filePath).slice(toPosix(publicFolder).length))}`;
+        return {
+            urlPath: publicRoutes[(0, utils_namespaceObject.removeLeadingSlash)(urlPath)] || urlPath,
+            isSPA: true,
+            isSSR: false,
+            entryPath: toPosix(external_path_default().relative(external_path_default().resolve(appDirectory, configDir || ''), filePath))
+        };
+    }) : [];
+};
+const getServerRoutes = (entrypoints, { appContext, config })=>[
+        ...collectHtmlRoutes(entrypoints, appContext, config),
+        ...collectStaticRoutes(appContext, config)
+    ];
+const toPosix = (pathStr)=>pathStr.split(external_path_default().sep).join(external_path_default().posix.sep);
+const getProdServerRoutes = (distDirectory)=>{
+    const routeJSON = external_path_default().join(distDirectory, utils_namespaceObject.ROUTE_SPEC_FILE);
+    try {
+        const { routes } = utils_namespaceObject.fs.readJSONSync(routeJSON);
+        return routes;
+    } catch (e) {
+        throw new Error(`Failed to read routes from ${routeJSON}, please check if the file exists.`);
+    }
+};
+exports.getProdServerRoutes = __webpack_exports__.getProdServerRoutes;
+exports.getServerRoutes = __webpack_exports__.getServerRoutes;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getProdServerRoutes",
+    "getServerRoutes"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});