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

package/dist/cjs/router/cli/code/utils.js

@@ -1,143 +1,142 @@
 "use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var utils_exports = {};
-__export(utils_exports, {
-  getPathWithoutExt: () => getPathWithoutExt,
-  getServerCombinedModueFile: () => getServerCombinedModueFile,
-  getServerLoadersFile: () => getServerLoadersFile,
-  hasAction: () => hasAction,
-  hasLoader: () => hasLoader,
-  isPageComponentFile: () => isPageComponentFile,
-  parseModule: () => parseModule,
-  replaceWithAlias: () => replaceWithAlias,
-  walkDirectory: () => walkDirectory
+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__, {
+    parseModule: ()=>parseModule,
+    hasLoader: ()=>hasLoader,
+    isPageComponentFile: ()=>isPageComponentFile,
+    getPathWithoutExt: ()=>getPathWithoutExt,
+    getServerCombinedModueFile: ()=>getServerCombinedModueFile,
+    getServerLoadersFile: ()=>getServerLoadersFile,
+    walkDirectory: ()=>walkDirectory,
+    hasAction: ()=>hasAction,
+    replaceWithAlias: ()=>replaceWithAlias
 });
-module.exports = __toCommonJS(utils_exports);
-var import_fs = __toESM(require("fs"));
-var import_path = __toESM(require("path"));
-var import_utils = require("@modern-js/utils");
-var import_es_module_lexer = require("es-module-lexer");
-var import_esbuild = require("esbuild");
-var import_constants = require("../constants");
-const walkDirectory = (dir) => import_fs.default.readdirSync(dir).reduce((previous, filename) => {
-  const filePath = import_path.default.join(dir, filename);
-  if (import_fs.default.statSync(filePath).isDirectory()) {
-    return [
-      ...previous,
-      ...walkDirectory(filePath)
-    ];
-  } else {
-    return [
-      ...previous,
-      filePath
-    ];
-  }
-}, []);
-const isPageComponentFile = (filePath) => {
-  if (/\.(d|test|spec|e2e)\.(js|jsx|ts|tsx)$/.test(filePath)) {
+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 utils_namespaceObject = require("@modern-js/utils");
+const external_es_module_lexer_namespaceObject = require("es-module-lexer");
+const external_esbuild_namespaceObject = require("esbuild");
+const external_constants_js_namespaceObject = require("../constants.js");
+const walkDirectory = (dir)=>external_fs_default().readdirSync(dir).reduce((previous, filename)=>{
+        const filePath = external_path_default().join(dir, filename);
+        if (external_fs_default().statSync(filePath).isDirectory()) return [
+            ...previous,
+            ...walkDirectory(filePath)
+        ];
+        return [
+            ...previous,
+            filePath
+        ];
+    }, []);
+const isPageComponentFile = (filePath)=>{
+    if (/\.(d|test|spec|e2e)\.(js|jsx|ts|tsx)$/.test(filePath)) return false;
+    if ([
+        '.js',
+        '.jsx',
+        '.ts',
+        '.tsx'
+    ].includes(external_path_default().extname(filePath))) return true;
     return false;
-  }
-  if ([
-    ".js",
-    ".jsx",
-    ".ts",
-    ".tsx"
-  ].includes(import_path.default.extname(filePath))) {
-    return true;
-  }
-  return false;
 };
-const replaceWithAlias = (base, filePath, alias) => {
-  if (filePath.includes(base)) {
-    return (0, import_utils.normalizeToPosixPath)(import_path.default.join(alias, import_path.default.relative(base, filePath)));
-  } else {
+const replaceWithAlias = (base, filePath, alias)=>{
+    if (filePath.includes(base)) return (0, utils_namespaceObject.normalizeToPosixPath)(external_path_default().join(alias, external_path_default().relative(base, filePath)));
     return filePath;
-  }
-};
-const parseModule = async ({ source, filename }) => {
-  let content = source;
-  if (import_utils.JS_EXTENSIONS.some((ext) => filename.endsWith(ext))) {
-    const result = await (0, import_esbuild.transform)(content, {
-      loader: import_path.default.extname(filename).slice(1),
-      format: "esm"
-    });
-    content = result.code;
-  }
-  return (0, import_es_module_lexer.parse)(content);
 };
-const hasLoader = async (filename, source) => {
-  let content = source;
-  if (!source) {
-    content = (await import_utils.fs.readFile(filename, "utf-8")).toString();
-  }
-  if (content) {
-    const [, moduleExports] = await parseModule({
-      source: content.toString(),
-      filename
-    });
-    return moduleExports.some((e) => e.n === import_constants.LOADER_EXPORT_NAME);
-  }
-  return false;
+const parseModule = async ({ source, filename })=>{
+    let content = source;
+    if (utils_namespaceObject.JS_EXTENSIONS.some((ext)=>filename.endsWith(ext))) {
+        const result = await (0, external_esbuild_namespaceObject.transform)(content, {
+            loader: external_path_default().extname(filename).slice(1),
+            format: 'esm'
+        });
+        content = result.code;
+    }
+    return (0, external_es_module_lexer_namespaceObject.parse)(content);
 };
-const hasAction = async (filename, source) => {
-  let content = source;
-  if (!source) {
-    content = (await import_utils.fs.readFile(filename, "utf-8")).toString();
-  }
-  if (content) {
-    const [, moduleExports] = await parseModule({
-      source: content.toString(),
-      filename
-    });
-    return moduleExports.some((e) => e.n === import_constants.ACTION_EXPORT_NAME);
-  }
-  return false;
-};
-const getServerLoadersFile = (internalDirectory, entryName) => {
-  return import_path.default.join(internalDirectory, entryName, "route-server-loaders.js");
+const hasLoader = async (filename, source)=>{
+    let content = source;
+    if (!source) content = (await utils_namespaceObject.fs.readFile(filename, 'utf-8')).toString();
+    if (content) {
+        const [, moduleExports] = await parseModule({
+            source: content.toString(),
+            filename
+        });
+        return moduleExports.some((e)=>e.n === external_constants_js_namespaceObject.LOADER_EXPORT_NAME);
+    }
+    return false;
 };
-const getServerCombinedModueFile = (internalDirectory, entryName) => {
-  return import_path.default.join(internalDirectory, entryName, "server-loader-combined.js");
+const hasAction = async (filename, source)=>{
+    let content = source;
+    if (!source) content = (await utils_namespaceObject.fs.readFile(filename, 'utf-8')).toString();
+    if (content) {
+        const [, moduleExports] = await parseModule({
+            source: content.toString(),
+            filename
+        });
+        return moduleExports.some((e)=>e.n === external_constants_js_namespaceObject.ACTION_EXPORT_NAME);
+    }
+    return false;
 };
-const getPathWithoutExt = (filename) => {
-  const extname = import_path.default.extname(filename);
-  return filename.slice(0, -extname.length);
+const getServerLoadersFile = (internalDirectory, entryName)=>external_path_default().join(internalDirectory, entryName, 'route-server-loaders.js');
+const getServerCombinedModueFile = (internalDirectory, entryName)=>external_path_default().join(internalDirectory, entryName, 'server-loader-combined.js');
+const getPathWithoutExt = (filename)=>{
+    const extname = external_path_default().extname(filename);
+    return extname ? filename.slice(0, -extname.length) : filename;
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getPathWithoutExt,
-  getServerCombinedModueFile,
-  getServerLoadersFile,
-  hasAction,
-  hasLoader,
-  isPageComponentFile,
-  parseModule,
-  replaceWithAlias,
-  walkDirectory
+exports.getPathWithoutExt = __webpack_exports__.getPathWithoutExt;
+exports.getServerCombinedModueFile = __webpack_exports__.getServerCombinedModueFile;
+exports.getServerLoadersFile = __webpack_exports__.getServerLoadersFile;
+exports.hasAction = __webpack_exports__.hasAction;
+exports.hasLoader = __webpack_exports__.hasLoader;
+exports.isPageComponentFile = __webpack_exports__.isPageComponentFile;
+exports.parseModule = __webpack_exports__.parseModule;
+exports.replaceWithAlias = __webpack_exports__.replaceWithAlias;
+exports.walkDirectory = __webpack_exports__.walkDirectory;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getPathWithoutExt",
+    "getServerCombinedModueFile",
+    "getServerLoadersFile",
+    "hasAction",
+    "hasLoader",
+    "isPageComponentFile",
+    "parseModule",
+    "replaceWithAlias",
+    "walkDirectory"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });

package/dist/cjs/router/cli/config-routes/converter.js

@@ -0,0 +1,129 @@
+"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__, {
+    normalizeRoutes: ()=>normalizeRoutes,
+    processConfigRoutes: ()=>processConfigRoutes
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const utils_namespaceObject = require("@modern-js/utils");
+const nestedRoutes_js_namespaceObject = require("../code/nestedRoutes.js");
+const utils_js_namespaceObject = require("../code/utils.js");
+async function processConfigRoutes(configRoutes, entryName, isMainEntry, configRoutesDir, alias) {
+    return Promise.all(configRoutes.map((configRoute)=>processConfigRoute(configRoute, entryName, isMainEntry, configRoutesDir, alias)));
+}
+async function processConfigRoute(configRoute, entryName, isMainEntry, configRoutesDir, alias) {
+    if ('config' !== configRoute.origin) {
+        if (configRoute.children && configRoute.children.length > 0) {
+            const processedChildren = await Promise.all(configRoute.children.map((child)=>processConfigRoute(child, entryName, isMainEntry, configRoutesDir, alias)));
+            return {
+                ...configRoute,
+                children: processedChildren
+            };
+        }
+        return configRoute;
+    }
+    const componentPath = configRoute.component;
+    const absoluteComponentPath = componentPath ? external_node_path_default().isAbsolute(componentPath) ? componentPath : external_node_path_default().resolve(configRoutesDir, componentPath) : void 0;
+    const routeId = configRoute.id || (0, nestedRoutes_js_namespaceObject.getRouteId)(componentPath, configRoutesDir, entryName, isMainEntry);
+    const processedRoute = {
+        ...configRoute,
+        id: routeId,
+        path: configRoute.path ?? '',
+        type: 'nested',
+        origin: 'config'
+    };
+    if (absoluteComponentPath) {
+        const componentPathWithAlias = alias ? (0, utils_js_namespaceObject.getPathWithoutExt)((0, utils_js_namespaceObject.replaceWithAlias)(alias.basename, absoluteComponentPath, alias.name)) : (0, utils_js_namespaceObject.getPathWithoutExt)(absoluteComponentPath);
+        processedRoute._component = componentPathWithAlias;
+    }
+    if (configRoute.children && configRoute.children.length > 0) {
+        const processedChildren = await Promise.all(configRoute.children.map((child)=>processConfigRoute(child, entryName, isMainEntry, configRoutesDir, alias)));
+        processedRoute.children = processedChildren;
+    }
+    if ('page' === configRoute.routeType || !configRoute.routeType && !configRoute.children) {
+        const rawPath = configRoute.path;
+        const isIndexPath = '' === rawPath || '/' === rawPath || 'string' == typeof rawPath && '' === rawPath.replace(/^\/+/, '');
+        if (isIndexPath) {
+            processedRoute.index = true;
+            delete processedRoute.path;
+        }
+    }
+    if (absoluteComponentPath) await discoverRelatedFiles(processedRoute, absoluteComponentPath, alias);
+    return processedRoute;
+}
+async function discoverRelatedFiles(nestedRoute, componentPath, alias) {
+    if ('config' !== nestedRoute.origin) return;
+    const componentDir = external_node_path_default().dirname(componentPath);
+    const componentName = external_node_path_default().basename(componentPath, external_node_path_default().extname(componentPath));
+    const relatedFiles = {
+        data: `${componentName}.data.ts`,
+        clientData: `${componentName}.data.client.ts`,
+        error: `${componentName}.error.tsx`,
+        loading: `${componentName}.loading.tsx`,
+        config: `${componentName}.config.ts`
+    };
+    await Promise.all(Object.entries(relatedFiles).map(async ([key, filename])=>{
+        const filePath = external_node_path_default().resolve(componentDir, filename);
+        try {
+            if (await utils_namespaceObject.fs.promises.stat(filePath).then((stat)=>stat.isFile()).catch(()=>false)) {
+                const aliasedPath = alias ? (0, utils_js_namespaceObject.replaceWithAlias)(alias.basename, filePath, alias.name) : filePath;
+                nestedRoute[key] = (0, utils_namespaceObject.normalizeToPosixPath)(aliasedPath);
+            }
+        } catch (e) {}
+    }));
+}
+function normalizeRoutes(generatedRoutes) {
+    return generatedRoutes.map((route)=>normalizeRoute(route));
+}
+function normalizeRoute(route) {
+    const { component, ...rest } = route;
+    const processedRoute = {
+        ...rest,
+        ...route.children && route.children.length > 0 ? {
+            children: route.children.map((child)=>normalizeRoute(child))
+        } : {}
+    };
+    return processedRoute;
+}
+exports.normalizeRoutes = __webpack_exports__.normalizeRoutes;
+exports.processConfigRoutes = __webpack_exports__.processConfigRoutes;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "normalizeRoutes",
+    "processConfigRoutes"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/router/cli/config-routes/parseRouteConfig.js

@@ -0,0 +1,155 @@
+"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__, {
+    discoverAndParseConfigRoutes: ()=>discoverAndParseConfigRoutes,
+    findConfigRoutesFile: ()=>findConfigRoutesFile,
+    parseConfigRoutesFile: ()=>parseConfigRoutesFile
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const utils_namespaceObject = require("@modern-js/utils");
+function createRouteFunctions(basePath) {
+    const resolveComponentPath = (component)=>{
+        if (!component) return component;
+        if (external_node_path_default().isAbsolute(component)) return component;
+        if (component.startsWith('./') || component.startsWith('../') || !component.startsWith('@')) return external_node_path_default().resolve(basePath, component);
+        return component;
+    };
+    const createNestedRoute = (component, routePath, children = [], routeType, wildcard = false)=>{
+        if ('string' == typeof component && component.startsWith('@')) throw new Error('component path must be absolute or relative; alias is not allowed');
+        if (void 0 !== routePath && 'string' != typeof routePath) throw new Error('Route path must be a string');
+        const resolvedComponent = resolveComponentPath(component);
+        if ('page' === routeType || wildcard) {
+            if (!component || '' === component.trim()) throw new Error('page route must specify a non-empty component path');
+            if (!utils_namespaceObject.fs.pathExistsSync(resolvedComponent)) throw new Error(`page component not found: ${resolvedComponent}`);
+        }
+        if (wildcard) return {
+            path: routePath || '*',
+            component: resolvedComponent,
+            routeType: 'page',
+            origin: 'config',
+            type: 'nested',
+            children: children.length > 0 ? children : void 0
+        };
+        if (!routeType) throw new Error('createRouteConfig must specify route type');
+        return {
+            path: routePath,
+            component: resolvedComponent,
+            routeType,
+            origin: 'config',
+            type: 'nested',
+            children: children.length > 0 ? children : void 0
+        };
+    };
+    return {
+        route: (component, pathOrChildren, maybeChildren)=>{
+            const path = Array.isArray(pathOrChildren) ? void 0 : pathOrChildren;
+            const children = Array.isArray(pathOrChildren) ? pathOrChildren : maybeChildren ?? [];
+            const routeType = children.length > 0 ? 'layout' : 'page';
+            return createNestedRoute(component, path, children, routeType);
+        },
+        layout: (component, pathOrChildren, maybeChildren)=>{
+            const path = Array.isArray(pathOrChildren) ? void 0 : pathOrChildren;
+            const children = Array.isArray(pathOrChildren) ? pathOrChildren : maybeChildren ?? [];
+            if (0 === children.length) throw new Error('layout route must have children');
+            return createNestedRoute(component, path, children, 'layout');
+        },
+        page: (component, path)=>createNestedRoute(component, path, [], 'page'),
+        $: (component, path)=>createNestedRoute(component, path, [], void 0, true)
+    };
+}
+async function findConfigRoutesFile(entrypoint, appContext) {
+    const { absoluteEntryDir } = entrypoint;
+    if (!absoluteEntryDir) return null;
+    const { metaName } = appContext;
+    const meta = (0, utils_namespaceObject.getMeta)(metaName);
+    const possibleNames = [
+        `${meta}.routes.ts`,
+        `${meta}.routes.mts`,
+        `${meta}.routes.tsx`,
+        `${meta}.routes.js`,
+        `${meta}.routes.mjs`,
+        `${meta}.routes.jsx`
+    ];
+    for (const filename of possibleNames){
+        const filePath = external_node_path_default().resolve(absoluteEntryDir, filename);
+        if (await utils_namespaceObject.fs.pathExists(filePath)) {
+            const stats = await utils_namespaceObject.fs.stat(filePath);
+            if (stats.isFile()) {
+                utils_namespaceObject.logger.debug(`Found config routes file: ${filePath}`);
+                return filePath;
+            }
+        }
+    }
+    return null;
+}
+async function parseConfigRoutesFile(filePath, entrypoint, fileRoutes) {
+    const { loadTypeScriptFile } = await import("@modern-js/plugin/run");
+    const configModule = loadTypeScriptFile(filePath);
+    if (!configModule.default || 'function' != typeof configModule.default) throw new Error(`Config routes file must export a default function. Found: ${typeof configModule.default}`);
+    const routeFunctions = createRouteFunctions(entrypoint.absoluteEntryDir);
+    let routesConfig;
+    if (!fileRoutes) throw new Error("Routes function expects file routes parameter, but none provided");
+    routesConfig = configModule.default(routeFunctions, fileRoutes);
+    if (!Array.isArray(routesConfig)) throw new Error(`Config routes function must return an array of routes. Received: ${typeof routesConfig}`);
+    return {
+        entryName: entrypoint.entryName,
+        filePath,
+        routes: routesConfig,
+        isMainEntry: entrypoint.isMainEntry || false
+    };
+}
+async function discoverAndParseConfigRoutes(entrypoint, appContext, fileRoutes) {
+    const configFilePath = await findConfigRoutesFile(entrypoint, appContext);
+    if (!configFilePath) {
+        utils_namespaceObject.logger.debug(`No config routes file found for entry: ${entrypoint.entryName}`);
+        return null;
+    }
+    const configRouteFile = await parseConfigRoutesFile(configFilePath, entrypoint, fileRoutes);
+    utils_namespaceObject.logger.debug(`Successfully loaded config routes from: ${configFilePath}`);
+    utils_namespaceObject.logger.debug(`Found ${configRouteFile.routes.length} route(s) for entry: ${entrypoint.entryName}`);
+    return configRouteFile;
+}
+exports.discoverAndParseConfigRoutes = __webpack_exports__.discoverAndParseConfigRoutes;
+exports.findConfigRoutesFile = __webpack_exports__.findConfigRoutesFile;
+exports.parseConfigRoutesFile = __webpack_exports__.parseConfigRoutesFile;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "discoverAndParseConfigRoutes",
+    "findConfigRoutesFile",
+    "parseConfigRoutesFile"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});