function _define_property(obj, key, value) {
    if (key in obj) {
        Object.defineProperty(obj, key, {
            value: value,
            enumerable: true,
            configurable: true,
            writable: true
        });
    } else {
        obj[key] = value;
    }
    return obj;
}
import { SecurityUtils, SecurityError, ValidationError, logger } from "../../../utils";
/**
 * LRU 缓存实现
 */ let LRUCache = class LRUCache {
    get(key) {
        const item = this.cache.get(key);
        if (item) {
            // 更新访问时间
            item.accessTime = Date.now();
            // 移动到末尾（最近使用）
            this.cache.delete(key);
            this.cache.set(key, item);
        }
        return item;
    }
    set(key, value) {
        // 如果已存在，先删除
        if (this.cache.has(key)) {
            this.cache.delete(key);
        } else if (this.cache.size >= this.maxSize) {
            // 如果达到最大大小，删除最久未使用的项（第一个）
            const firstKey = this.cache.keys().next().value;
            if (firstKey) {
                this.cache.delete(firstKey);
            }
        }
        value.accessTime = Date.now();
        this.cache.set(key, value);
    }
    delete(key) {
        return this.cache.delete(key);
    }
    clear() {
        this.cache.clear();
    }
    size() {
        return this.cache.size;
    }
    cleanupExpired(cacheTTL) {
        const now = Date.now();
        for (const [key, item] of this.cache.entries()){
            if (now - item.timestamp > cacheTTL) {
                this.cache.delete(key);
            }
        }
    }
    constructor(maxSize = 50){
        _define_property(this, "cache", new Map());
        _define_property(this, "maxSize", void 0);
        this.maxSize = maxSize;
    }
};
/**
 * 转换缓存（使用 LRU 缓存）
 */ let transformCache = null;
/**
 * 默认配置
 */ const DEFAULT_OPTIONS = {
    pathValidation: {
        enablePathValidation: true,
        allowedPathPrefixes: [],
        maxPathLength: 500,
        allowAbsolutePaths: false
    },
    performance: {
        enableCache: true,
        cacheTTL: 5 * 60 * 1000,
        maxCacheSize: 50,
        maxRecursionDepth: 100,
        enableParallelProcessing: true,
        parallelBatchSize: 10
    },
    enableDebugLog: false
};
/**
 * 优化的字符串哈希函数（用于缓存键）
 * 使用更高效的哈希算法，支持大字符串
 */ function optimizedHash(str) {
    // 对于小字符串，使用快速哈希
    if (str.length < 100) {
        let hash = 0;
        for(let i = 0; i < str.length; i++){
            const char = str.charCodeAt(i);
            hash = (hash << 5) - hash + char;
            hash = hash & hash; // 转换为 32 位整数
        }
        return Math.abs(hash).toString(36);
    }
    // 对于大字符串，使用分段哈希
    let hash = 0;
    const step = Math.max(1, Math.floor(str.length / 100));
    for(let i = 0; i < str.length; i += step){
        const char = str.charCodeAt(i);
        hash = (hash << 5) - hash + char;
        hash = hash & hash;
    }
    return Math.abs(hash).toString(36);
}
/**
 * 使用 crypto API 的哈希函数（如果可用）
 * 保留此函数供未来使用（异步哈希场景）
 */ // async function cryptoHash(str: string): Promise<string> {
//   // 检查是否支持 crypto API
//   if (typeof crypto !== 'undefined' && crypto.subtle && crypto.subtle.digest) {
//     try {
//       const encoder = new TextEncoder();
//       const data = encoder.encode(str);
//       const hashBuffer = await crypto.subtle.digest('SHA-256', data);
//       const hashArray = Array.from(new Uint8Array(hashBuffer));
//       return hashArray.map(b => b.toString(16).padStart(2, '0')).join('').substring(0, 16);
//     } catch {
//       // 如果 crypto API 失败，回退到优化哈希
//       return optimizedHash(str);
//     }
//   }
//   return optimizedHash(str);
// }
/**
 * 同步哈希函数（用于同步场景）
 */ function simpleHash(str) {
    return optimizedHash(str);
}
/**
 * 配置序列化缓存（避免重复序列化）
 */ const configStringCache = new Map();
/**
 * 生成配置哈希（用于缓存键）
 * 优化：缓存序列化结果，避免重复序列化
 */ function generateConfigHash(routes) {
    try {
        // 快速检查：如果路由数量为 0，直接返回
        if (routes.length === 0) {
            return 'empty';
        }
        // 使用路由数量作为快速键的一部分
        const quickKey = `${routes.length}_${routes[0]?.name || ''}_${routes[routes.length - 1]?.name || ''}`;
        // 检查序列化缓存
        if (configStringCache.has(quickKey)) {
            const cachedStr = configStringCache.get(quickKey);
            // 验证缓存是否仍然有效（简单检查）
            const currentStr = JSON.stringify(routes, null, 0).substring(0, 100);
            if (cachedStr.startsWith(currentStr.substring(0, 50))) {
                return simpleHash(cachedStr);
            }
        }
        // 使用 JSON.stringify 生成配置的字符串表示
        // 只包含影响转换结果的字段
        const configStr = JSON.stringify(routes, (key, value)=>{
            // 只序列化相关字段
            if ([
                'name',
                'path',
                'page',
                'layout',
                'errors',
                'loading',
                'isGroup',
                'enableRedirection',
                'children'
            ].includes(key)) {
                return value;
            }
            if (key === 'handle' && value && typeof value === 'object') {
                // 只序列化 handle 的基本字段
                return {
                    title: value.title,
                    order: value.order
                };
            }
            return undefined;
        });
        // 缓存序列化结果（限制缓存大小）
        if (configStringCache.size < 20) {
            configStringCache.set(quickKey, configStr);
        }
        return simpleHash(configStr);
    } catch  {
        // 如果序列化失败，返回空字符串（不使用缓存）
        return '';
    }
}
/**
 * 路径验证缓存（已验证的路径）
 */ const validatedPathCache = new Set();
/**
 * 预编译的正则表达式（用于路径验证）
 */ const PATH_TRAVERSAL_REGEX = /\.\.(\/|\\)|\.\.%2[Ff]|\.\.%5[Cc]|%2[Ee]%2[Ee]%2[Ff]|%2[Ee]%2[Ee]%5[Cc]/i;
const ABSOLUTE_PATH_REGEX = /^\/|^[A-Za-z]:\\/;
const CONTROL_CHAR_REGEX = /[\x00-\x1f\x7f]/;
const NULL_BYTE_REGEX = /%00|\\0|\x00/;
// 保留供未来使用（命令注入检测）
// const COMMAND_INJECTION_REGEX = /[;|&$`]/;
// const ALLOWED_CHARS_REGEX = /^[a-zA-Z0-9\/\-_.@]+$/;
/**
 * 验证路径是否安全
 * 优化：添加验证缓存、预编译正则、早期返回
 */ function validatePath(path, config) {
    // 早期返回：检查缓存
    if (validatedPathCache.has(path)) {
        return {
            valid: true
        };
    }
    // 早期返回：检查路径长度（最快检查）
    if (path.length > config.maxPathLength) {
        return {
            valid: false,
            error: process.env.NODE_ENV === 'development' ? `路径长度超过最大限制 ${config.maxPathLength} 字符` : '路径验证失败'
        };
    }
    // 早期返回：检查空字符串
    if (path.length === 0) {
        return {
            valid: false,
            error: '路径不能为空'
        };
    }
    // 检查路径遍历攻击（使用预编译正则）
    if (PATH_TRAVERSAL_REGEX.test(path)) {
        return {
            valid: false,
            error: process.env.NODE_ENV === 'development' ? '路径包含路径遍历字符（../），可能存在安全风险' : '路径验证失败'
        };
    }
    // 检查空字节注入
    if (NULL_BYTE_REGEX.test(path)) {
        return {
            valid: false,
            error: process.env.NODE_ENV === 'development' ? '路径包含空字节，可能存在安全风险' : '路径验证失败'
        };
    }
    // 检查控制字符
    if (CONTROL_CHAR_REGEX.test(path)) {
        return {
            valid: false,
            error: process.env.NODE_ENV === 'development' ? '路径包含控制字符，可能存在安全风险' : '路径验证失败'
        };
    }
    // 检查命令注入字符（可选，根据需求决定是否启用）
    // if (COMMAND_INJECTION_REGEX.test(path)) {
    //   return {
    //     valid: false,
    //     error: process.env.NODE_ENV === 'development'
    //       ? '路径包含潜在的命令注入字符'
    //       : '路径验证失败',
    //   };
    // }
    // 检查绝对路径（使用预编译正则）
    if (!config.allowAbsolutePaths && ABSOLUTE_PATH_REGEX.test(path)) {
        return {
            valid: false,
            error: process.env.NODE_ENV === 'development' ? '不允许使用绝对路径' : '路径验证失败'
        };
    }
    // 检查路径前缀白名单（优化：使用 Set 提高查找速度）
    if (config.allowedPathPrefixes.length > 0) {
        const prefixSet = new Set(config.allowedPathPrefixes);
        const isAllowed = Array.from(prefixSet).some((prefix)=>path.startsWith(prefix));
        if (!isAllowed) {
            return {
                valid: false,
                error: process.env.NODE_ENV === 'development' ? `路径不在允许的前缀列表中: ${config.allowedPathPrefixes.join(', ')}` : '路径验证失败'
            };
        }
    }
    // 使用 SecurityUtils 验证输入（最后检查，因为可能较慢）
    const validation = SecurityUtils.validateInput(path);
    if (!validation.safe) {
        return {
            valid: false,
            error: process.env.NODE_ENV === 'development' ? validation.reason || '路径包含潜在的危险内容' : '路径验证失败'
        };
    }
    // 验证通过，添加到缓存（限制缓存大小）
    if (validatedPathCache.size < 1000) {
        validatedPathCache.add(path);
    }
    return {
        valid: true
    };
}
/**
 * 预编译的正则表达式（用于路径规范化）
 */ const NORMALIZE_REGEX = {
    multipleSlashes: /\/+/g,
    dotSlash: /\/\.\//g,
    trailingDot: /\/\.$/
};
/**
 * 规范化路径
 * 优化：合并正则表达式，减少替换次数
 */ function normalizePath(path) {
    // 合并多个替换操作，减少字符串遍历次数
    return path.replace(NORMALIZE_REGEX.multipleSlashes, '/').replace(NORMALIZE_REGEX.dotSlash, '/').replace(NORMALIZE_REGEX.trailingDot, '').trim();
}
/**
 * 类型守卫：检查是否为有效路径字符串
 */ function isValidPathString(path) {
    return typeof path === 'string' && path.length > 0;
}
/**
 * 类型守卫：检查是否为动态导入函数
 */ function isComponentImport(path) {
    return typeof path === 'function';
}
/**
 * 创建动态导入函数
 * 
 * 将组件路径字符串转换为动态导入函数，用于代码分割和懒加载
 * 
 * @param path - 组件路径字符串，支持相对路径和别名路径（如 '@/pages/home.tsx'）
 * @returns 返回动态导入函数，调用后会返回 Promise，resolve 后的值为组件模块对象
 * 
 * @remarks
 * - 使用 `@vite-ignore` 注释告诉 Vite 忽略此动态导入的静态分析
 * - 使用类型断言 `as any` 是因为 TypeScript 的 `import()` 需要静态字符串字面量
 * - 在运行时，我们可以使用动态路径进行导入
 * - 组件必须使用默认导出（export default）
 * 
 * @example
 * ```typescript
 * const importFn = createDynamicImport('@/pages/home.tsx');
 * const module = await importFn();
 * const HomePage = module.default;
 * ```
 */ function createDynamicImport(path) {
    // 使用类型断言，因为 TypeScript 的 import() 需要静态字符串
    // 但在运行时，我们可以使用动态路径
    return ()=>import(path);
}
/**
 * 提取并验证组件路径到 Map 中
 * 
 * 如果路径有效且 Map 中不存在，则创建动态导入函数并存储到 Map 中
 * 这样可以避免重复创建相同路径的动态导入函数，提高性能
 * 
 * @param path - 组件路径，可能是字符串、动态导入函数、null 或 undefined
 * @param map - 目标 Map，用于存储路径到动态导入函数的映射
 * @param config - 路径验证配置
 * @param options - 转换选项
 * @returns 如果成功提取，返回动态导入函数；否则返回 null
 * 
 * @remarks
 * - 如果 path 是函数，直接返回，不添加到 Map（函数本身就可以直接使用）
 * - 只有当路径是有效的非空字符串时才会处理并添加到 Map
 * - 如果 Map 中已存在该路径，则直接返回已有的导入函数
 * - 优化：使用 `get()` 一次获取，判断是否为 undefined，减少函数调用
 * - 会进行路径验证和清理
 * 
 * @example
 * ```typescript
 * const pages = new Map<string, () => Promise<any>>();
 * const importFn1 = extractAndValidatePath('@/pages/home.tsx', pages, config, options);
 * const importFn2 = extractAndValidatePath(() => import('@/pages/home.tsx'), pages, config, options);
 * ```
 */ function extractAndValidatePath(path, map, config, options) {
    // 早期返回：如果是函数，直接返回，不添加到 Map
    if (isComponentImport(path)) {
        return path;
    }
    // 早期返回：检查是否为有效路径字符串
    if (!isValidPathString(path)) {
        return null;
    }
    // 规范化路径
    const normalizedPath = normalizePath(path);
    // 优化：先检查 Map 中是否已存在（避免不必要的验证）
    const existingImport = map.get(normalizedPath);
    if (existingImport !== undefined) {
        return existingImport;
    }
    // 路径验证（仅在 Map 中不存在时进行）
    if (config.enablePathValidation) {
        const validation = validatePath(normalizedPath, config);
        if (!validation.valid) {
            // 生产环境错误信息脱敏
            const errorMessage = process.env.NODE_ENV === 'development' ? `路径验证失败: ${validation.error}` : '路径验证失败';
            const error = new SecurityError(errorMessage, undefined, process.env.NODE_ENV === 'development' ? {
                path: normalizedPath
            } : {});
            if (options.enableDebugLog) {
                logger.error('路径验证失败:', error);
            }
            // 开发环境抛出错误，生产环境记录警告并跳过
            if (process.env.NODE_ENV === 'development') {
                throw error;
            } else {
                // 生产环境日志脱敏
                logger.warn('路径验证失败，已跳过');
                return null;
            }
        }
    }
    // 创建动态导入函数并存储
    const importFn = createDynamicImport(normalizedPath);
    map.set(normalizedPath, importFn);
    if (options.enableDebugLog) {
        logger.debug('提取路径:', normalizedPath);
    }
    return importFn;
}
/**
 * 对象池：复用栈节点对象，减少 GC 压力
 */ let StackNodePool = class StackNodePool {
    acquire(route, depth) {
        if (this.pool.length > 0) {
            const node = this.pool.pop();
            node.route = route;
            node.depth = depth;
            return node;
        }
        return {
            route,
            depth
        };
    }
    release(node) {
        if (this.pool.length < this.maxPoolSize) {
            this.pool.push(node);
        }
    }
    constructor(){
        _define_property(this, "pool", []);
        _define_property(this, "maxPoolSize", 100);
    }
};
const stackNodePool = new StackNodePool();
/**
 * 只提取组件路径到 Map 中，不转换路由配置
 * 
 * 使用迭代方式遍历所有路由（包括子路由），提取组件路径到对应的 Map 中
 * 这种设计可以确保：
 * - 相同的组件路径只会创建一个动态导入函数
 * - 使用迭代而非递归，避免栈溢出
 * - 优化：支持并行处理、使用对象池、预分配数组
 * 
 * @param routes - 原始路由配置列表
 * @param result - 结果对象，用于累积收集的组件路径
 * @param config - 路径验证配置
 * @param options - 转换选项
 * @param maxDepth - 最大递归深度
 */ async function extractPathsOnly(routes, result, config, options, maxDepth) {
    const enableParallel = options.performance?.enableParallelProcessing ?? true;
    const batchSize = options.performance?.parallelBatchSize ?? 10;
    // 如果启用并行处理且路由数量较多，使用并行处理
    if (enableParallel && routes.length > batchSize) {
        // 收集所有需要处理的路径（只收集字符串类型，函数类型不需要处理）
        const pathsToProcess = [];
        // 遍历所有路由，收集路径
        const stack = [];
        for(let i = routes.length - 1; i >= 0; i--){
            stack.push({
                route: routes[i],
                depth: 0
            });
        }
        while(stack.length > 0){
            const { route, depth } = stack.pop();
            if (depth > maxDepth) {
                logger.warn(`路径提取达到最大深度 ${maxDepth}，跳过路由:`, route.name);
                continue;
            }
            // 收集路径（只收集字符串类型，函数类型不需要处理，会直接使用）
            if (route.page && typeof route.page === 'string') {
                pathsToProcess.push({
                    path: route.page,
                    map: result.pages
                });
            }
            if (route.layout && typeof route.layout === 'string') {
                pathsToProcess.push({
                    path: route.layout,
                    map: result.layouts
                });
            }
            if (route.errors && typeof route.errors === 'string') {
                pathsToProcess.push({
                    path: route.errors,
                    map: result.errors
                });
            }
            if (route.loading && typeof route.loading === 'string') {
                pathsToProcess.push({
                    path: route.loading,
                    map: result.loadings
                });
            }
            // 处理子路由
            if (route.children && Array.isArray(route.children) && route.children.length > 0) {
                for(let i = route.children.length - 1; i >= 0; i--){
                    stack.push({
                        route: route.children[i],
                        depth: depth + 1
                    });
                }
            }
        }
        // 并行处理路径（分批处理）
        for(let i = 0; i < pathsToProcess.length; i += batchSize){
            const batch = pathsToProcess.slice(i, i + batchSize);
            await Promise.all(batch.map(({ path, map })=>Promise.resolve(extractAndValidatePath(path, map, config, options))));
        }
    } else {
        // 串行处理（原有逻辑，优化：使用对象池）
        const stack = [];
        // 初始化栈：将所有路由推入栈中
        for(let i = routes.length - 1; i >= 0; i--){
            stack.push(stackNodePool.acquire(routes[i], 0));
        }
        // 迭代处理栈中的路由
        while(stack.length > 0){
            const node = stack.pop();
            const { route, depth } = node;
            // 检查递归深度
            if (depth > maxDepth) {
                logger.warn(`路径提取达到最大深度 ${maxDepth}，跳过路由:`, route.name);
                stackNodePool.release(node);
                continue;
            }
            // 提取组件路径到 Map 中（同时进行验证）
            extractAndValidatePath(route.page, result.pages, config, options);
            extractAndValidatePath(route.layout, result.layouts, config, options);
            extractAndValidatePath(route.errors, result.errors, config, options);
            extractAndValidatePath(route.loading, result.loadings, config, options);
            // 处理子路由
            if (route.children && Array.isArray(route.children) && route.children.length > 0) {
                // 将子路由推入栈中（逆序推入，保证处理顺序正确）
                for(let i = route.children.length - 1; i >= 0; i--){
                    stack.push(stackNodePool.acquire(route.children[i], depth + 1));
                }
            }
            // 释放节点到对象池
            stackNodePool.release(node);
        }
    }
}
/**
 * 清理过期缓存
 * 优化：使用 LRU 缓存的清理方法
 */ function cleanupExpiredCache(cacheTTL) {
    if (transformCache) {
        transformCache.cleanupExpired(cacheTTL);
    }
}
/**
 * 转换路由配置：提取组件路径到 Map 中，返回原始路由配置
 * 
 * 此函数是路由转换的核心函数，主要完成以下任务：
 * 1. 递归提取路由配置中的所有组件路径（page、layout、errors、loading）
 * 2. 将组件路径字符串转换为动态导入函数
 * 3. 将动态导入函数存储在对应的 Map 中，key 为路径字符串，确保不重复
 * 4. 返回原始路由配置列表，不进行转换
 * 
 * @param routes - 路由配置列表，可以是：
 *   - 路由配置数组（RouteConfig[]）
 *   - 返回路由配置数组的异步函数（() => Promise<RouteConfig[]>）
 *   支持异步函数是为了支持动态加载路由配置（如从服务器获取）
 * @param options - 转换配置选项
 * @returns 包含以下内容的结果对象：
 *   - `pages`: 页面组件路径到动态导入函数的 Map
 *   - `layouts`: 布局组件路径到动态导入函数的 Map
 *   - `errors`: 错误组件路径到动态导入函数的 Map
 *   - `loadings`: 加载组件路径到动态导入函数的 Map
 *   - `routes`: 原始路由配置列表，不进行转换
 * 
 * @remarks
 * - 如果 `routes` 为 null、undefined 或空数组，返回空结果对象
 * - 如果 `routes` 是函数但返回的不是数组，返回空结果对象
 * - 相同的组件路径只会创建一个动态导入函数，存储在 Map 中复用
 * - 路由配置保持原始格式，组件路径仍为字符串
 * - 支持嵌套路由，会递归处理所有层级的子路由
 * - 支持缓存，相同配置会直接返回缓存结果
 * 
 * @example
 * ```typescript
 * // 示例 1: 使用数组配置
 * const result = await transformRoutes([
 *   {
 *     name: 'home',
 *     path: '/',
 *     page: '@/pages/home.tsx',
 *     errors: '@/pages/error.tsx',
 *     handle: { title: '首页', order: 1 },
 *   },
 * ]);
 * 
 * // 示例 2: 使用异步函数配置
 * const result = await transformRoutes(async () => {
 *   const response = await fetch('/api/routes');
 *   return response.json();
 * });
 * 
 * // 示例 3: 使用配置选项
 * const result = await transformRoutes(routes, {
 *   pathValidation: {
 *     enablePathValidation: true,
 *     allowedPathPrefixes: ['@/pages', '@/components'],
 *   },
 *   performance: {
 *     enableCache: true,
 *     cacheTTL: 10 * 60 * 1000, // 10 分钟
 *   },
 * });
 * ```
 */ export async function transformRoutes(routes, options = {}) {
    const startTime = performance.now();
    const mergedOptions = {
        pathValidation: {
            ...DEFAULT_OPTIONS.pathValidation,
            ...options.pathValidation
        },
        performance: {
            ...DEFAULT_OPTIONS.performance,
            ...options.performance
        },
        enableDebugLog: options.enableDebugLog ?? DEFAULT_OPTIONS.enableDebugLog
    };
    // 早期返回：如果 routes 为空或未定义，直接返回空结果
    if (!routes) {
        if (mergedOptions.enableDebugLog) {
            logger.debug('路由配置为空，返回空结果');
        }
        return {
            pages: new Map(),
            layouts: new Map(),
            errors: new Map(),
            loadings: new Map(),
            routes: []
        };
    }
    // 处理 routes 可能是函数的情况
    let routesArray;
    try {
        routesArray = typeof routes === 'function' ? await routes() : routes;
    } catch (error) {
        const err = error instanceof Error ? error : new Error('路由配置加载失败');
        logger.error('路由配置加载失败:', err);
        throw new ValidationError('路由配置加载失败', {
            originalError: err
        });
    }
    // 早期返回：如果 routesArray 不是数组，直接返回空结果
    if (!Array.isArray(routesArray) || routesArray.length === 0) {
        if (mergedOptions.enableDebugLog) {
            logger.debug('路由配置不是数组或为空，返回空结果');
        }
        return {
            pages: new Map(),
            layouts: new Map(),
            errors: new Map(),
            loadings: new Map(),
            routes: []
        };
    }
    // 检查缓存
    const cacheTTL = mergedOptions.performance.cacheTTL ?? DEFAULT_OPTIONS.performance.cacheTTL;
    const maxCacheSize = mergedOptions.performance.maxCacheSize ?? DEFAULT_OPTIONS.performance.maxCacheSize;
    if (mergedOptions.performance.enableCache) {
        // 初始化 LRU 缓存（如果尚未初始化或大小发生变化）
        if (!transformCache || transformCache.size() !== maxCacheSize) {
            transformCache = new LRUCache(maxCacheSize);
        }
        const configHash = generateConfigHash(routesArray);
        if (configHash) {
            const cached = transformCache.get(configHash);
            if (cached && Date.now() - cached.timestamp < cacheTTL) {
                if (mergedOptions.enableDebugLog) {
                    logger.debug('使用缓存结果');
                }
                // 直接返回缓存结果（LRU 缓存已处理访问时间更新）
                return cached.result;
            }
        }
        // 清理过期缓存
        cleanupExpiredCache(cacheTTL);
    }
    // 初始化结果对象
    const result = {
        pages: new Map(),
        layouts: new Map(),
        errors: new Map(),
        loadings: new Map(),
        routes: []
    };
    try {
        // 性能监控：记录各阶段耗时
        const extractStartTime = performance.now();
        // 提取组件路径到 Map 中（不转换路由配置）
        const pathValidation = {
            enablePathValidation: mergedOptions.pathValidation.enablePathValidation ?? DEFAULT_OPTIONS.pathValidation.enablePathValidation,
            allowedPathPrefixes: mergedOptions.pathValidation.allowedPathPrefixes ?? DEFAULT_OPTIONS.pathValidation.allowedPathPrefixes,
            maxPathLength: mergedOptions.pathValidation.maxPathLength ?? DEFAULT_OPTIONS.pathValidation.maxPathLength,
            allowAbsolutePaths: mergedOptions.pathValidation.allowAbsolutePaths ?? DEFAULT_OPTIONS.pathValidation.allowAbsolutePaths
        };
        const maxRecursionDepth = mergedOptions.performance.maxRecursionDepth ?? DEFAULT_OPTIONS.performance.maxRecursionDepth;
        // 异步提取路径（支持并行处理）
        await extractPathsOnly(routesArray, result, pathValidation, mergedOptions, maxRecursionDepth);
        const extractEndTime = performance.now();
        const extractDuration = extractEndTime - extractStartTime;
        // 直接使用原始路由配置，不进行转换
        result.routes = routesArray;
        // 缓存结果
        const cacheStartTime = performance.now();
        if (mergedOptions.performance.enableCache && transformCache) {
            const configHash = generateConfigHash(routesArray);
            if (configHash) {
                // 使用结构化克隆（如果可用）或浅拷贝 + 深拷贝 routes
                let cachedResult;
                if (typeof structuredClone !== 'undefined') {
                    // 使用结构化克隆（更快且更安全）
                    cachedResult = structuredClone(result);
                    // Map 需要手动克隆（structuredClone 可能不支持 Map）
                    cachedResult.pages = new Map(result.pages);
                    cachedResult.layouts = new Map(result.layouts);
                    cachedResult.errors = new Map(result.errors);
                    cachedResult.loadings = new Map(result.loadings);
                } else {
                    // 回退到手动深拷贝
                    cachedResult = {
                        pages: new Map(result.pages),
                        layouts: new Map(result.layouts),
                        errors: new Map(result.errors),
                        loadings: new Map(result.loadings),
                        routes: JSON.parse(JSON.stringify(result.routes))
                    };
                }
                transformCache.set(configHash, {
                    result: cachedResult,
                    timestamp: Date.now(),
                    hash: configHash,
                    accessTime: Date.now()
                });
            }
        }
        const cacheEndTime = performance.now();
        const cacheDuration = cacheEndTime - cacheStartTime;
        const endTime = performance.now();
        const totalDuration = endTime - startTime;
        if (mergedOptions.enableDebugLog) {
            // 详细的性能报告
            logger.debug(`路由转换完成，总耗时: ${totalDuration.toFixed(2)}ms`, {
                routeCount: result.routes.length,
                pageCount: result.pages.size,
                layoutCount: result.layouts.size,
                errorCount: result.errors.size,
                loadingCount: result.loadings.size,
                performance: {
                    extractDuration: `${extractDuration.toFixed(2)}ms`,
                    cacheDuration: `${cacheDuration.toFixed(2)}ms`,
                    totalDuration: `${totalDuration.toFixed(2)}ms`
                },
                cache: {
                    hit: transformCache ? 'miss' : 'disabled',
                    size: transformCache?.size() ?? 0
                }
            });
        }
        return result;
    } catch (error) {
        const err = error instanceof Error ? error : new Error('路由转换失败');
        logger.error('路由转换失败:', err);
        throw new ValidationError('路由转换失败', {
            originalError: err
        });
    }
}

//# sourceMappingURL=transform.js.map