@vlian/framework 1.0.0

package/dist/core/router/utils/transform.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/core/router/utils/transform.tsx"],"sourcesContent":["import type { RouterConfig, RouteConfig } from '../types';\nimport { SecurityUtils, SecurityError, ValidationError, logger } from '../../../utils';\n\n/**\n * 路径验证配置\n */\nexport interface PathValidationConfig {\n  /**\n   * 是否启用路径验证（默认 true）\n   */\n  enablePathValidation?: boolean;\n\n  /**\n   * 允许的路径前缀列表\n   * 例如：['@/pages', '@/components', './pages']\n   */\n  allowedPathPrefixes?: string[];\n\n  /**\n   * 最大路径长度（默认 500）\n   */\n  maxPathLength?: number;\n\n  /**\n   * 是否允许绝对路径（默认 false）\n   */\n  allowAbsolutePaths?: boolean;\n}\n\n/**\n * 转换性能配置\n */\nexport interface TransformPerformanceConfig {\n  /**\n   * 是否启用缓存（默认 true）\n   */\n  enableCache?: boolean;\n\n  /**\n   * 缓存过期时间（毫秒，默认 5 分钟）\n   */\n  cacheTTL?: number;\n\n  /**\n   * 最大缓存数量（默认 50，LRU 缓存）\n   */\n  maxCacheSize?: number;\n\n  /**\n   * 最大递归深度（默认 100）\n   */\n  maxRecursionDepth?: number;\n\n  /**\n   * 是否启用并行处理（默认 true）\n   */\n  enableParallelProcessing?: boolean;\n\n  /**\n   * 并行处理批次大小（默认 10）\n   */\n  parallelBatchSize?: number;\n}\n\n/**\n * 转换配置选项\n */\nexport interface TransformOptions {\n  /**\n   * 路径验证配置\n   */\n  pathValidation?: PathValidationConfig;\n\n  /**\n   * 性能配置\n   */\n  performance?: TransformPerformanceConfig;\n\n  /**\n   * 是否启用调试日志（默认 false）\n   */\n  enableDebugLog?: boolean;\n}\n\n/**\n * 转换后的路由项\n * \n * 与 RouteConfig 的区别：\n * - `page`、`layout`、`errors`、`loading` 字段的值是对应 Map 中的动态导入函数，而不是路径字符串\n * - 这些字段可以直接用于动态加载组件，无需再次查找 Map\n * - 所有组件路径字符串都已转换为对应的动态导入函数\n * \n * @example\n * ```typescript\n * const transformedRoute: TransformedRoute = {\n *   name: 'home',\n *   path: '/',\n *   page: () => import('@/pages/home.tsx'),  // 动态导入函数\n *   handle: { title: '首页', order: 1 },\n * };\n * \n * // 使用动态导入函数加载组件\n * if (transformedRoute.page) {\n *   const pageModule = await transformedRoute.page();\n *   const PageComponent = pageModule?.default;\n * }\n * ```\n */\nexport interface TransformedRoute {\n  /**\n   * 页面组件的动态导入函数\n   * \n   * 如果路由配置中指定了 `page` 路径，则此字段为对应的动态导入函数\n   * 如果未指定或为 null，则此字段为 null\n   * \n   * 调用此函数会返回一个 Promise，resolve 后的值为组件模块对象\n   * 组件必须使用默认导出（export default）\n   */\n  page?: (() => Promise<any>) | null;\n\n  /**\n   * 布局组件的动态导入函数\n   * \n   * 如果路由配置中指定了 `layout` 路径，则此字段为对应的动态导入函数\n   * 如果未指定或为 null，则此字段为 null\n   * \n   * 调用此函数会返回一个 Promise，resolve 后的值为组件模块对象\n   * 组件必须使用默认导出（export default）\n   */\n  layout?: (() => Promise<any>) | null;\n\n  /**\n   * 错误组件的动态导入函数\n   * \n   * 如果路由配置中指定了 `errors` 路径，则此字段为对应的动态导入函数\n   * 如果未指定或为 null，则此字段为 null\n   * \n   * 调用此函数会返回一个 Promise，resolve 后的值为组件模块对象\n   * 组件必须使用默认导出（export default）\n   */\n  errors?: (() => Promise<any>) | null;\n\n  /**\n   * 加载组件的动态导入函数\n   * \n   * 如果路由配置中指定了 `loading` 路径，则此字段为对应的动态导入函数\n   * 如果未指定或为 null，则此字段为 null\n   * \n   * 调用此函数会返回一个 Promise，resolve 后的值为组件模块对象\n   * 组件必须使用默认导出（export default）\n   */\n  loading?: (() => Promise<any>) | null;\n\n  /**\n   * 路由名称（唯一标识）\n   * \n   * 用于标识路由的唯一名称，通常用于路由导航和权限控制\n   */\n  name: string;\n\n  /**\n   * 路由路径\n   * \n   * URL 路径，例如：'/'、'/about'、'/user/:id'\n   * 如果路由是路由组（isGroup: true），则可能为 undefined\n   */\n  path: string | undefined;\n\n  /**\n   * 是否为路由组\n   * \n   * 路由组用于组织子路由，本身不匹配任何路径\n   * 路由组的 path 通常为 undefined\n   */\n  isGroup?: boolean;\n\n  /**\n   * 是否启用重定向\n   * \n   * 如果为 true，表示此路由用于重定向到其他路由\n   */\n  enableRedirection?: boolean;\n\n  /**\n   * 路由元数据\n   * \n   * 包含路由的标题、图标、排序、权限等信息\n   * 用于菜单生成、权限控制、SEO 等场景\n   */\n  handle: {\n    /**\n     * 路由标题\n     */\n    title: string;\n    \n    /**\n     * 国际化键名\n     * 如果提供，会使用 i18n 系统进行翻译\n     */\n    i18nKey?: string;\n    \n    /**\n     * 排序值\n     * 用于菜单排序，数值越小越靠前\n     */\n    order: number;\n    \n    /**\n     * 图标名称或路径\n     */\n    icon?: string;\n    \n    /**\n     * 是否在菜单中隐藏\n     */\n    hideInMenu?: boolean;\n    \n    /**\n     * 是否隐藏页脚\n     */\n    hideFooter?: boolean;\n    \n    /**\n     * 是否启用 KeepAlive 缓存\n     */\n    keepAlive?: boolean;\n    \n    /**\n     * 是否需要登录\n     */\n    needLogin?: boolean;\n    \n    /**\n     * 允许访问的角色列表\n     */\n    roles?: Array<string>;\n    \n    /**\n     * 路由名称（与 name 字段相同，用于兼容）\n     */\n    name?: string;\n    \n    /**\n     * 其他自定义元数据\n     */\n    [key: string]: unknown;\n  };\n\n  /**\n   * 子路由配置\n   * \n   * 如果路由有子路由，则此字段包含转换后的子路由列表\n   * 子路由会继承父路由的某些配置（如 layout）\n   */\n  children?: TransformedRoute[];\n}\n\n/**\n * 路由转换结果\n * \n * 包含所有提取的组件路径 Map 和原始路由配置列表\n * \n * @example\n * ```typescript\n * const result: TransformRoutesResult = {\n *   pages: new Map([\n *     ['@/pages/home.tsx', () => import('@/pages/home.tsx')],\n *     ['@/pages/about.tsx', () => import('@/pages/about.tsx')],\n *   ]),\n *   layouts: new Map([\n *     ['@/layouts/MainLayout.tsx', () => import('@/layouts/MainLayout.tsx')],\n *   ]),\n *   errors: new Map(),\n *   loadings: new Map(),\n *   routes: [], // 原始路由配置列表\n * };\n * ```\n */\nexport interface TransformRoutesResult {\n  /**\n   * 页面组件路径 Map\n   * \n   * key: 组件路径字符串（如 '@/pages/home.tsx'）\n   * value: 动态导入函数，调用后返回 Promise，resolve 后的值为组件模块对象\n   * \n   * 用于存储所有路由配置中出现的页面组件路径\n   * 相同的路径只会存储一次，避免重复创建动态导入函数\n   */\n  pages: Map<string, () => Promise<any>>;\n\n  /**\n   * 布局组件路径 Map\n   * \n   * key: 组件路径字符串（如 '@/layouts/MainLayout.tsx'）\n   * value: 动态导入函数，调用后返回 Promise，resolve 后的值为组件模块对象\n   * \n   * 用于存储所有路由配置中出现的布局组件路径\n   * 相同的路径只会存储一次，避免重复创建动态导入函数\n   */\n  layouts: Map<string, () => Promise<any>>;\n\n  /**\n   * 错误组件路径 Map\n   * \n   * key: 组件路径字符串（如 '@/components/ErrorBoundary.tsx'）\n   * value: 动态导入函数，调用后返回 Promise，resolve 后的值为组件模块对象\n   * \n   * 用于存储所有路由配置中出现的错误组件路径\n   * 相同的路径只会存储一次，避免重复创建动态导入函数\n   */\n  errors: Map<string, () => Promise<any>>;\n\n  /**\n   * 加载组件路径 Map\n   * \n   * key: 组件路径字符串（如 '@/components/Loading.tsx'）\n   * value: 动态导入函数，调用后返回 Promise，resolve 后的值为组件模块对象\n   * \n   * 用于存储所有路由配置中出现的加载组件路径\n   * 相同的路径只会存储一次，避免重复创建动态导入函数\n   */\n  loadings: Map<string, () => Promise<any>>;\n\n  routes: RouteConfig[];\n}\n\n/**\n * 缓存项\n */\ninterface CacheItem {\n  result: TransformRoutesResult;\n  timestamp: number;\n  hash: string;\n  accessTime: number; // LRU 使用\n}\n\n/**\n * LRU 缓存实现\n */\nclass LRUCache {\n  private cache = new Map<string, CacheItem>();\n  private maxSize: number;\n\n  constructor(maxSize: number = 50) {\n    this.maxSize = maxSize;\n  }\n\n  get(key: string): CacheItem | undefined {\n    const item = this.cache.get(key);\n    if (item) {\n      // 更新访问时间\n      item.accessTime = Date.now();\n      // 移动到末尾（最近使用）\n      this.cache.delete(key);\n      this.cache.set(key, item);\n    }\n    return item;\n  }\n\n  set(key: string, value: CacheItem): void {\n    // 如果已存在，先删除\n    if (this.cache.has(key)) {\n      this.cache.delete(key);\n    } else if (this.cache.size >= this.maxSize) {\n      // 如果达到最大大小，删除最久未使用的项（第一个）\n      const firstKey = this.cache.keys().next().value;\n      if (firstKey) {\n        this.cache.delete(firstKey);\n      }\n    }\n    value.accessTime = Date.now();\n    this.cache.set(key, value);\n  }\n\n  delete(key: string): boolean {\n    return this.cache.delete(key);\n  }\n\n  clear(): void {\n    this.cache.clear();\n  }\n\n  size(): number {\n    return this.cache.size;\n  }\n\n  cleanupExpired(cacheTTL: number): void {\n    const now = Date.now();\n    for (const [key, item] of this.cache.entries()) {\n      if (now - item.timestamp > cacheTTL) {\n        this.cache.delete(key);\n      }\n    }\n  }\n}\n\n/**\n * 转换缓存（使用 LRU 缓存）\n */\nlet transformCache: LRUCache | null = null;\n\n/**\n * 默认配置\n */\nconst DEFAULT_OPTIONS: Required<TransformOptions> = {\n  pathValidation: {\n    enablePathValidation: true,\n    allowedPathPrefixes: [],\n    maxPathLength: 500,\n    allowAbsolutePaths: false,\n  },\n  performance: {\n    enableCache: true,\n    cacheTTL: 5 * 60 * 1000, // 5 分钟\n    maxCacheSize: 50, // LRU 缓存最大数量\n    maxRecursionDepth: 100,\n    enableParallelProcessing: true,\n    parallelBatchSize: 10, // 并行处理批次大小\n  },\n  enableDebugLog: false,\n};\n\n/**\n * 优化的字符串哈希函数（用于缓存键）\n * 使用更高效的哈希算法，支持大字符串\n */\nfunction optimizedHash(str: string): string {\n  // 对于小字符串，使用快速哈希\n  if (str.length < 100) {\n    let hash = 0;\n    for (let i = 0; i < str.length; i++) {\n      const char = str.charCodeAt(i);\n      hash = ((hash << 5) - hash) + char;\n      hash = hash & hash; // 转换为 32 位整数\n    }\n    return Math.abs(hash).toString(36);\n  }\n\n  // 对于大字符串，使用分段哈希\n  let hash = 0;\n  const step = Math.max(1, Math.floor(str.length / 100));\n  for (let i = 0; i < str.length; i += step) {\n    const char = str.charCodeAt(i);\n    hash = ((hash << 5) - hash) + char;\n    hash = hash & hash;\n  }\n  return Math.abs(hash).toString(36);\n}\n\n/**\n * 使用 crypto API 的哈希函数（如果可用）\n * 保留此函数供未来使用（异步哈希场景）\n */\n// async function cryptoHash(str: string): Promise<string> {\n//   // 检查是否支持 crypto API\n//   if (typeof crypto !== 'undefined' && crypto.subtle && crypto.subtle.digest) {\n//     try {\n//       const encoder = new TextEncoder();\n//       const data = encoder.encode(str);\n//       const hashBuffer = await crypto.subtle.digest('SHA-256', data);\n//       const hashArray = Array.from(new Uint8Array(hashBuffer));\n//       return hashArray.map(b => b.toString(16).padStart(2, '0')).join('').substring(0, 16);\n//     } catch {\n//       // 如果 crypto API 失败，回退到优化哈希\n//       return optimizedHash(str);\n//     }\n//   }\n//   return optimizedHash(str);\n// }\n\n/**\n * 同步哈希函数（用于同步场景）\n */\nfunction simpleHash(str: string): string {\n  return optimizedHash(str);\n}\n\n/**\n * 配置序列化缓存（避免重复序列化）\n */\nconst configStringCache = new Map<string, string>();\n\n/**\n * 生成配置哈希（用于缓存键）\n * 优化：缓存序列化结果，避免重复序列化\n */\nfunction generateConfigHash(routes: RouteConfig[]): string {\n  try {\n    // 快速检查：如果路由数量为 0，直接返回\n    if (routes.length === 0) {\n      return 'empty';\n    }\n\n    // 使用路由数量作为快速键的一部分\n    const quickKey = `${routes.length}_${routes[0]?.name || ''}_${routes[routes.length - 1]?.name || ''}`;\n    \n    // 检查序列化缓存\n    if (configStringCache.has(quickKey)) {\n      const cachedStr = configStringCache.get(quickKey)!;\n      // 验证缓存是否仍然有效（简单检查）\n      const currentStr = JSON.stringify(routes, null, 0).substring(0, 100);\n      if (cachedStr.startsWith(currentStr.substring(0, 50))) {\n        return simpleHash(cachedStr);\n      }\n    }\n\n    // 使用 JSON.stringify 生成配置的字符串表示\n    // 只包含影响转换结果的字段\n    const configStr = JSON.stringify(routes, (key, value) => {\n      // 只序列化相关字段\n      if (['name', 'path', 'page', 'layout', 'errors', 'loading', 'isGroup', 'enableRedirection', 'children'].includes(key)) {\n        return value;\n      }\n      if (key === 'handle' && value && typeof value === 'object') {\n        // 只序列化 handle 的基本字段\n        return {\n          title: (value as { title?: string }).title,\n          order: (value as { order?: number }).order,\n        };\n      }\n      return undefined;\n    });\n\n    // 缓存序列化结果（限制缓存大小）\n    if (configStringCache.size < 20) {\n      configStringCache.set(quickKey, configStr);\n    }\n\n    return simpleHash(configStr);\n  } catch {\n    // 如果序列化失败，返回空字符串（不使用缓存）\n    return '';\n  }\n}\n\n/**\n * 路径验证缓存（已验证的路径）\n */\nconst validatedPathCache = new Set<string>();\n\n/**\n * 预编译的正则表达式（用于路径验证）\n */\nconst PATH_TRAVERSAL_REGEX = /\\.\\.(\\/|\\\\)|\\.\\.%2[Ff]|\\.\\.%5[Cc]|%2[Ee]%2[Ee]%2[Ff]|%2[Ee]%2[Ee]%5[Cc]/i;\nconst ABSOLUTE_PATH_REGEX = /^\\/|^[A-Za-z]:\\\\/;\nconst CONTROL_CHAR_REGEX = /[\\x00-\\x1f\\x7f]/;\nconst NULL_BYTE_REGEX = /%00|\\\\0|\\x00/;\n// 保留供未来使用（命令注入检测）\n// const COMMAND_INJECTION_REGEX = /[;|&$`]/;\n// const ALLOWED_CHARS_REGEX = /^[a-zA-Z0-9\\/\\-_.@]+$/;\n\n/**\n * 验证路径是否安全\n * 优化：添加验证缓存、预编译正则、早期返回\n */\nfunction validatePath(\n  path: string,\n  config: Required<PathValidationConfig>\n): { valid: boolean; error?: string } {\n  // 早期返回：检查缓存\n  if (validatedPathCache.has(path)) {\n    return { valid: true };\n  }\n\n  // 早期返回：检查路径长度（最快检查）\n  if (path.length > config.maxPathLength) {\n    return {\n      valid: false,\n      error: process.env.NODE_ENV === 'development' \n        ? `路径长度超过最大限制 ${config.maxPathLength} 字符`\n        : '路径验证失败',\n    };\n  }\n\n  // 早期返回：检查空字符串\n  if (path.length === 0) {\n    return {\n      valid: false,\n      error: '路径不能为空',\n    };\n  }\n\n  // 检查路径遍历攻击（使用预编译正则）\n  if (PATH_TRAVERSAL_REGEX.test(path)) {\n    return {\n      valid: false,\n      error: process.env.NODE_ENV === 'development'\n        ? '路径包含路径遍历字符（../），可能存在安全风险'\n        : '路径验证失败',\n    };\n  }\n\n  // 检查空字节注入\n  if (NULL_BYTE_REGEX.test(path)) {\n    return {\n      valid: false,\n      error: process.env.NODE_ENV === 'development'\n        ? '路径包含空字节，可能存在安全风险'\n        : '路径验证失败',\n    };\n  }\n\n  // 检查控制字符\n  if (CONTROL_CHAR_REGEX.test(path)) {\n    return {\n      valid: false,\n      error: process.env.NODE_ENV === 'development'\n        ? '路径包含控制字符，可能存在安全风险'\n        : '路径验证失败',\n    };\n  }\n\n  // 检查命令注入字符（可选，根据需求决定是否启用）\n  // if (COMMAND_INJECTION_REGEX.test(path)) {\n  //   return {\n  //     valid: false,\n  //     error: process.env.NODE_ENV === 'development'\n  //       ? '路径包含潜在的命令注入字符'\n  //       : '路径验证失败',\n  //   };\n  // }\n\n  // 检查绝对路径（使用预编译正则）\n  if (!config.allowAbsolutePaths && ABSOLUTE_PATH_REGEX.test(path)) {\n    return {\n      valid: false,\n      error: process.env.NODE_ENV === 'development'\n        ? '不允许使用绝对路径'\n        : '路径验证失败',\n    };\n  }\n\n  // 检查路径前缀白名单（优化：使用 Set 提高查找速度）\n  if (config.allowedPathPrefixes.length > 0) {\n    const prefixSet = new Set(config.allowedPathPrefixes);\n    const isAllowed = Array.from(prefixSet).some((prefix) => path.startsWith(prefix));\n    if (!isAllowed) {\n      return {\n        valid: false,\n        error: process.env.NODE_ENV === 'development'\n          ? `路径不在允许的前缀列表中: ${config.allowedPathPrefixes.join(', ')}`\n          : '路径验证失败',\n      };\n    }\n  }\n\n  // 使用 SecurityUtils 验证输入（最后检查，因为可能较慢）\n  const validation = SecurityUtils.validateInput(path);\n  if (!validation.safe) {\n    return {\n      valid: false,\n      error: process.env.NODE_ENV === 'development'\n        ? (validation.reason || '路径包含潜在的危险内容')\n        : '路径验证失败',\n    };\n  }\n\n  // 验证通过，添加到缓存（限制缓存大小）\n  if (validatedPathCache.size < 1000) {\n    validatedPathCache.add(path);\n  }\n\n  return { valid: true };\n}\n\n/**\n * 预编译的正则表达式（用于路径规范化）\n */\nconst NORMALIZE_REGEX = {\n  multipleSlashes: /\\/+/g,\n  dotSlash: /\\/\\.\\//g,\n  trailingDot: /\\/\\.$/,\n};\n\n/**\n * 规范化路径\n * 优化：合并正则表达式，减少替换次数\n */\nfunction normalizePath(path: string): string {\n  // 合并多个替换操作，减少字符串遍历次数\n  return path\n    .replace(NORMALIZE_REGEX.multipleSlashes, '/')\n    .replace(NORMALIZE_REGEX.dotSlash, '/')\n    .replace(NORMALIZE_REGEX.trailingDot, '')\n    .trim();\n}\n\n/**\n * 类型守卫：检查是否为有效路径字符串\n */\nfunction isValidPathString(path: unknown): path is string {\n  return typeof path === 'string' && path.length > 0;\n}\n\n/**\n * 类型守卫：检查是否为动态导入函数\n */\nfunction isComponentImport(path: unknown): path is () => Promise<any> {\n  return typeof path === 'function';\n}\n\n/**\n * 创建动态导入函数\n * \n * 将组件路径字符串转换为动态导入函数，用于代码分割和懒加载\n * \n * @param path - 组件路径字符串，支持相对路径和别名路径（如 '@/pages/home.tsx'）\n * @returns 返回动态导入函数，调用后会返回 Promise，resolve 后的值为组件模块对象\n * \n * @remarks\n * - 使用 `@vite-ignore` 注释告诉 Vite 忽略此动态导入的静态分析\n * - 使用类型断言 `as any` 是因为 TypeScript 的 `import()` 需要静态字符串字面量\n * - 在运行时，我们可以使用动态路径进行导入\n * - 组件必须使用默认导出（export default）\n * \n * @example\n * ```typescript\n * const importFn = createDynamicImport('@/pages/home.tsx');\n * const module = await importFn();\n * const HomePage = module.default;\n * ```\n */\nfunction createDynamicImport(path: string): () => Promise<any> {\n  // 使用类型断言，因为 TypeScript 的 import() 需要静态字符串\n  // 但在运行时，我们可以使用动态路径\n  return () => import( path as any);\n}\n\n/**\n * 提取并验证组件路径到 Map 中\n * \n * 如果路径有效且 Map 中不存在，则创建动态导入函数并存储到 Map 中\n * 这样可以避免重复创建相同路径的动态导入函数，提高性能\n * \n * @param path - 组件路径，可能是字符串、动态导入函数、null 或 undefined\n * @param map - 目标 Map，用于存储路径到动态导入函数的映射\n * @param config - 路径验证配置\n * @param options - 转换选项\n * @returns 如果成功提取，返回动态导入函数；否则返回 null\n * \n * @remarks\n * - 如果 path 是函数，直接返回，不添加到 Map（函数本身就可以直接使用）\n * - 只有当路径是有效的非空字符串时才会处理并添加到 Map\n * - 如果 Map 中已存在该路径，则直接返回已有的导入函数\n * - 优化：使用 `get()` 一次获取，判断是否为 undefined，减少函数调用\n * - 会进行路径验证和清理\n * \n * @example\n * ```typescript\n * const pages = new Map<string, () => Promise<any>>();\n * const importFn1 = extractAndValidatePath('@/pages/home.tsx', pages, config, options);\n * const importFn2 = extractAndValidatePath(() => import('@/pages/home.tsx'), pages, config, options);\n * ```\n */\nfunction extractAndValidatePath(\n  path: string | (() => Promise<any>) | null | undefined,\n  map: Map<string, () => Promise<any>>,\n  config: Required<PathValidationConfig>,\n  options: TransformOptions,\n): (() => Promise<any>) | null {\n  // 早期返回：如果是函数，直接返回，不添加到 Map\n  if (isComponentImport(path)) {\n    return path;\n  }\n\n  // 早期返回：检查是否为有效路径字符串\n  if (!isValidPathString(path)) {\n    return null;\n  }\n\n  // 规范化路径\n  const normalizedPath = normalizePath(path);\n\n  // 优化：先检查 Map 中是否已存在（避免不必要的验证）\n  const existingImport = map.get(normalizedPath);\n  if (existingImport !== undefined) {\n    return existingImport;\n  }\n\n  // 路径验证（仅在 Map 中不存在时进行）\n  if (config.enablePathValidation) {\n    const validation = validatePath(normalizedPath, config);\n    if (!validation.valid) {\n      // 生产环境错误信息脱敏\n      const errorMessage = process.env.NODE_ENV === 'development'\n        ? `路径验证失败: ${validation.error}`\n        : '路径验证失败';\n      \n      const error = new SecurityError(\n        errorMessage,\n        undefined,\n        process.env.NODE_ENV === 'development' ? { path: normalizedPath } : {}\n      );\n      \n      if (options.enableDebugLog) {\n        logger.error('路径验证失败:', error);\n      }\n      \n      // 开发环境抛出错误，生产环境记录警告并跳过\n      if (process.env.NODE_ENV === 'development') {\n        throw error;\n      } else {\n        // 生产环境日志脱敏\n        logger.warn('路径验证失败，已跳过');\n        return null;\n      }\n    }\n  }\n\n  // 创建动态导入函数并存储\n  const importFn = createDynamicImport(normalizedPath);\n  map.set(normalizedPath, importFn);\n  \n  if (options.enableDebugLog) {\n    logger.debug('提取路径:', normalizedPath);\n  }\n\n  return importFn;\n}\n\n/**\n * 对象池：复用栈节点对象，减少 GC 压力\n */\nclass StackNodePool {\n  private pool: Array<{ route: RouteConfig; depth: number }> = [];\n  private maxPoolSize = 100;\n\n  acquire(route: RouteConfig, depth: number): { route: RouteConfig; depth: number } {\n    if (this.pool.length > 0) {\n      const node = this.pool.pop()!;\n      node.route = route;\n      node.depth = depth;\n      return node;\n    }\n    return { route, depth };\n  }\n\n  release(node: { route: RouteConfig; depth: number }): void {\n    if (this.pool.length < this.maxPoolSize) {\n      this.pool.push(node);\n    }\n  }\n}\n\nconst stackNodePool = new StackNodePool();\n\n/**\n * 只提取组件路径到 Map 中，不转换路由配置\n * \n * 使用迭代方式遍历所有路由（包括子路由），提取组件路径到对应的 Map 中\n * 这种设计可以确保：\n * - 相同的组件路径只会创建一个动态导入函数\n * - 使用迭代而非递归，避免栈溢出\n * - 优化：支持并行处理、使用对象池、预分配数组\n * \n * @param routes - 原始路由配置列表\n * @param result - 结果对象，用于累积收集的组件路径\n * @param config - 路径验证配置\n * @param options - 转换选项\n * @param maxDepth - 最大递归深度\n */\nasync function extractPathsOnly(\n  routes: RouteConfig[],\n  result: TransformRoutesResult,\n  config: Required<PathValidationConfig>,\n  options: TransformOptions,\n  maxDepth: number,\n): Promise<void> {\n  const enableParallel = options.performance?.enableParallelProcessing ?? true;\n  const batchSize = options.performance?.parallelBatchSize ?? 10;\n\n  // 如果启用并行处理且路由数量较多，使用并行处理\n  if (enableParallel && routes.length > batchSize) {\n    // 收集所有需要处理的路径（只收集字符串类型，函数类型不需要处理）\n    const pathsToProcess: Array<{\n      path: string | null | undefined;\n      map: Map<string, () => Promise<any>>;\n    }> = [];\n\n    // 遍历所有路由，收集路径\n    const stack: Array<{ route: RouteConfig; depth: number }> = [];\n    for (let i = routes.length - 1; i >= 0; i--) {\n      stack.push({ route: routes[i], depth: 0 });\n    }\n\n    while (stack.length > 0) {\n      const { route, depth } = stack.pop()!;\n\n      if (depth > maxDepth) {\n        logger.warn(`路径提取达到最大深度 ${maxDepth}，跳过路由:`, route.name);\n        continue;\n      }\n\n      // 收集路径（只收集字符串类型，函数类型不需要处理，会直接使用）\n      if (route.page && typeof route.page === 'string') {\n        pathsToProcess.push({ path: route.page, map: result.pages });\n      }\n      if (route.layout && typeof route.layout === 'string') {\n        pathsToProcess.push({ path: route.layout, map: result.layouts });\n      }\n      if (route.errors && typeof route.errors === 'string') {\n        pathsToProcess.push({ path: route.errors, map: result.errors });\n      }\n      if (route.loading && typeof route.loading === 'string') {\n        pathsToProcess.push({ path: route.loading, map: result.loadings });\n      }\n\n      // 处理子路由\n      if (route.children && Array.isArray(route.children) && route.children.length > 0) {\n        for (let i = route.children.length - 1; i >= 0; i--) {\n          stack.push({ route: route.children[i], depth: depth + 1 });\n        }\n      }\n    }\n\n    // 并行处理路径（分批处理）\n    for (let i = 0; i < pathsToProcess.length; i += batchSize) {\n      const batch = pathsToProcess.slice(i, i + batchSize);\n      await Promise.all(\n        batch.map(({ path, map }) =>\n          Promise.resolve(extractAndValidatePath(path, map, config, options))\n        )\n      );\n    }\n  } else {\n    // 串行处理（原有逻辑，优化：使用对象池）\n    const stack: Array<{ route: RouteConfig; depth: number }> = [];\n\n    // 初始化栈：将所有路由推入栈中\n    for (let i = routes.length - 1; i >= 0; i--) {\n      stack.push(stackNodePool.acquire(routes[i], 0));\n    }\n\n    // 迭代处理栈中的路由\n    while (stack.length > 0) {\n      const node = stack.pop()!;\n      const { route, depth } = node;\n\n      // 检查递归深度\n      if (depth > maxDepth) {\n        logger.warn(`路径提取达到最大深度 ${maxDepth}，跳过路由:`, route.name);\n        stackNodePool.release(node);\n        continue;\n      }\n\n      // 提取组件路径到 Map 中（同时进行验证）\n      extractAndValidatePath(route.page, result.pages, config, options);\n      extractAndValidatePath(route.layout, result.layouts, config, options);\n      extractAndValidatePath(route.errors, result.errors, config, options);\n      extractAndValidatePath(route.loading, result.loadings, config, options);\n\n      // 处理子路由\n      if (route.children && Array.isArray(route.children) && route.children.length > 0) {\n        // 将子路由推入栈中（逆序推入，保证处理顺序正确）\n        for (let i = route.children.length - 1; i >= 0; i--) {\n          stack.push(stackNodePool.acquire(route.children[i], depth + 1));\n        }\n      }\n\n      // 释放节点到对象池\n      stackNodePool.release(node);\n    }\n  }\n}\n\n/**\n * 清理过期缓存\n * 优化：使用 LRU 缓存的清理方法\n */\nfunction cleanupExpiredCache(cacheTTL: number): void {\n  if (transformCache) {\n    transformCache.cleanupExpired(cacheTTL);\n  }\n}\n\n/**\n * 转换路由配置：提取组件路径到 Map 中，返回原始路由配置\n * \n * 此函数是路由转换的核心函数，主要完成以下任务：\n * 1. 递归提取路由配置中的所有组件路径（page、layout、errors、loading）\n * 2. 将组件路径字符串转换为动态导入函数\n * 3. 将动态导入函数存储在对应的 Map 中，key 为路径字符串，确保不重复\n * 4. 返回原始路由配置列表，不进行转换\n * \n * @param routes - 路由配置列表，可以是：\n *   - 路由配置数组（RouteConfig[]）\n *   - 返回路由配置数组的异步函数（() => Promise<RouteConfig[]>）\n *   支持异步函数是为了支持动态加载路由配置（如从服务器获取）\n * @param options - 转换配置选项\n * @returns 包含以下内容的结果对象：\n *   - `pages`: 页面组件路径到动态导入函数的 Map\n *   - `layouts`: 布局组件路径到动态导入函数的 Map\n *   - `errors`: 错误组件路径到动态导入函数的 Map\n *   - `loadings`: 加载组件路径到动态导入函数的 Map\n *   - `routes`: 原始路由配置列表，不进行转换\n * \n * @remarks\n * - 如果 `routes` 为 null、undefined 或空数组，返回空结果对象\n * - 如果 `routes` 是函数但返回的不是数组，返回空结果对象\n * - 相同的组件路径只会创建一个动态导入函数，存储在 Map 中复用\n * - 路由配置保持原始格式，组件路径仍为字符串\n * - 支持嵌套路由，会递归处理所有层级的子路由\n * - 支持缓存，相同配置会直接返回缓存结果\n * \n * @example\n * ```typescript\n * // 示例 1: 使用数组配置\n * const result = await transformRoutes([\n *   {\n *     name: 'home',\n *     path: '/',\n *     page: '@/pages/home.tsx',\n *     errors: '@/pages/error.tsx',\n *     handle: { title: '首页', order: 1 },\n *   },\n * ]);\n * \n * // 示例 2: 使用异步函数配置\n * const result = await transformRoutes(async () => {\n *   const response = await fetch('/api/routes');\n *   return response.json();\n * });\n * \n * // 示例 3: 使用配置选项\n * const result = await transformRoutes(routes, {\n *   pathValidation: {\n *     enablePathValidation: true,\n *     allowedPathPrefixes: ['@/pages', '@/components'],\n *   },\n *   performance: {\n *     enableCache: true,\n *     cacheTTL: 10 * 60 * 1000, // 10 分钟\n *   },\n * });\n * ```\n */\nexport async function transformRoutes(\n  routes: RouterConfig['routes'],\n  options: TransformOptions = {},\n): Promise<TransformRoutesResult> {\n  const startTime = performance.now();\n  const mergedOptions: Required<TransformOptions> = {\n    pathValidation: { ...DEFAULT_OPTIONS.pathValidation, ...options.pathValidation },\n    performance: { ...DEFAULT_OPTIONS.performance, ...options.performance },\n    enableDebugLog: options.enableDebugLog ?? DEFAULT_OPTIONS.enableDebugLog,\n  };\n\n  // 早期返回：如果 routes 为空或未定义，直接返回空结果\n  if (!routes) {\n    if (mergedOptions.enableDebugLog) {\n      logger.debug('路由配置为空，返回空结果');\n    }\n    return {\n      pages: new Map<string, () => Promise<any>>(),\n      layouts: new Map<string, () => Promise<any>>(),\n      errors: new Map<string, () => Promise<any>>(),\n      loadings: new Map<string, () => Promise<any>>(),\n      routes: [],\n    };\n  }\n\n  // 处理 routes 可能是函数的情况\n  let routesArray: RouteConfig[];\n  try {\n    routesArray = typeof routes === 'function' ? await routes() : routes;\n  } catch (error) {\n    const err = error instanceof Error ? error : new Error('路由配置加载失败');\n    logger.error('路由配置加载失败:', err);\n    throw new ValidationError('路由配置加载失败', { originalError: err });\n  }\n\n  // 早期返回：如果 routesArray 不是数组，直接返回空结果\n  if (!Array.isArray(routesArray) || routesArray.length === 0) {\n    if (mergedOptions.enableDebugLog) {\n      logger.debug('路由配置不是数组或为空，返回空结果');\n    }\n    return {\n      pages: new Map<string, () => Promise<any>>(),\n      layouts: new Map<string, () => Promise<any>>(),\n      errors: new Map<string, () => Promise<any>>(),\n      loadings: new Map<string, () => Promise<any>>(),\n      routes: [],\n    };\n  }\n\n  // 检查缓存\n  const cacheTTL: number = (mergedOptions.performance.cacheTTL ?? DEFAULT_OPTIONS.performance.cacheTTL) as number;\n  const maxCacheSize: number = (mergedOptions.performance.maxCacheSize ?? DEFAULT_OPTIONS.performance.maxCacheSize) as number;\n  \n  if (mergedOptions.performance.enableCache) {\n    // 初始化 LRU 缓存（如果尚未初始化或大小发生变化）\n    if (!transformCache || transformCache.size() !== maxCacheSize) {\n      transformCache = new LRUCache(maxCacheSize);\n    }\n\n    const configHash = generateConfigHash(routesArray);\n    if (configHash) {\n      const cached = transformCache.get(configHash);\n      if (cached && Date.now() - cached.timestamp < cacheTTL) {\n        if (mergedOptions.enableDebugLog) {\n          logger.debug('使用缓存结果');\n        }\n        // 直接返回缓存结果（LRU 缓存已处理访问时间更新）\n        return cached.result;\n      }\n    }\n\n    // 清理过期缓存\n    cleanupExpiredCache(cacheTTL);\n  }\n\n  // 初始化结果对象\n  const result: TransformRoutesResult = {\n    pages: new Map<string, () => Promise<any>>(),\n    layouts: new Map<string, () => Promise<any>>(),\n    errors: new Map<string, () => Promise<any>>(),\n    loadings: new Map<string, () => Promise<any>>(),\n    routes: [],\n  };\n\n  try {\n    // 性能监控：记录各阶段耗时\n    const extractStartTime = performance.now();\n    \n    // 提取组件路径到 Map 中（不转换路由配置）\n    const pathValidation: Required<PathValidationConfig> = {\n      enablePathValidation: (mergedOptions.pathValidation.enablePathValidation ?? DEFAULT_OPTIONS.pathValidation.enablePathValidation) as boolean,\n      allowedPathPrefixes: (mergedOptions.pathValidation.allowedPathPrefixes ?? DEFAULT_OPTIONS.pathValidation.allowedPathPrefixes) as string[],\n      maxPathLength: (mergedOptions.pathValidation.maxPathLength ?? DEFAULT_OPTIONS.pathValidation.maxPathLength) as number,\n      allowAbsolutePaths: (mergedOptions.pathValidation.allowAbsolutePaths ?? DEFAULT_OPTIONS.pathValidation.allowAbsolutePaths) as boolean,\n    };\n    const maxRecursionDepth: number = (mergedOptions.performance.maxRecursionDepth ?? DEFAULT_OPTIONS.performance.maxRecursionDepth) as number;\n    \n    // 异步提取路径（支持并行处理）\n    await extractPathsOnly(\n      routesArray,\n      result,\n      pathValidation,\n      mergedOptions as TransformOptions,\n      maxRecursionDepth,\n    );\n    \n    const extractEndTime = performance.now();\n    const extractDuration = extractEndTime - extractStartTime;\n    \n    // 直接使用原始路由配置，不进行转换\n    result.routes = routesArray;\n\n    // 缓存结果\n    const cacheStartTime = performance.now();\n    if (mergedOptions.performance.enableCache && transformCache) {\n      const configHash = generateConfigHash(routesArray);\n      if (configHash) {\n        // 使用结构化克隆（如果可用）或浅拷贝 + 深拷贝 routes\n        let cachedResult: TransformRoutesResult;\n        if (typeof structuredClone !== 'undefined') {\n          // 使用结构化克隆（更快且更安全）\n          cachedResult = structuredClone(result);\n          // Map 需要手动克隆（structuredClone 可能不支持 Map）\n          cachedResult.pages = new Map(result.pages);\n          cachedResult.layouts = new Map(result.layouts);\n          cachedResult.errors = new Map(result.errors);\n          cachedResult.loadings = new Map(result.loadings);\n        } else {\n          // 回退到手动深拷贝\n          cachedResult = {\n            pages: new Map(result.pages),\n            layouts: new Map(result.layouts),\n            errors: new Map(result.errors),\n            loadings: new Map(result.loadings),\n            routes: JSON.parse(JSON.stringify(result.routes)),\n          };\n        }\n\n        transformCache.set(configHash, {\n          result: cachedResult,\n          timestamp: Date.now(),\n          hash: configHash,\n          accessTime: Date.now(),\n        });\n      }\n    }\n    const cacheEndTime = performance.now();\n    const cacheDuration = cacheEndTime - cacheStartTime;\n\n    const endTime = performance.now();\n    const totalDuration = endTime - startTime;\n    \n    if (mergedOptions.enableDebugLog) {\n      // 详细的性能报告\n      logger.debug(`路由转换完成，总耗时: ${totalDuration.toFixed(2)}ms`, {\n        routeCount: result.routes.length,\n        pageCount: result.pages.size,\n        layoutCount: result.layouts.size,\n        errorCount: result.errors.size,\n        loadingCount: result.loadings.size,\n        performance: {\n          extractDuration: `${extractDuration.toFixed(2)}ms`,\n          cacheDuration: `${cacheDuration.toFixed(2)}ms`,\n          totalDuration: `${totalDuration.toFixed(2)}ms`,\n        },\n        cache: {\n          hit: transformCache ? 'miss' : 'disabled',\n          size: transformCache?.size() ?? 0,\n        },\n      });\n    }\n\n    return result;\n  } catch (error) {\n    const err = error instanceof Error ? error : new Error('路由转换失败');\n    logger.error('路由转换失败:', err);\n    throw new ValidationError('路由转换失败', { originalError: err });\n  }\n}\n"],"names":["SecurityUtils","SecurityError","ValidationError","logger","LRUCache","get","key","item","cache","accessTime","Date","now","delete","set","value","has","size","maxSize","firstKey","keys","next","clear","cleanupExpired","cacheTTL","entries","timestamp","Map","transformCache","DEFAULT_OPTIONS","pathValidation","enablePathValidation","allowedPathPrefixes","maxPathLength","allowAbsolutePaths","performance","enableCache","maxCacheSize","maxRecursionDepth","enableParallelProcessing","parallelBatchSize","enableDebugLog","optimizedHash","str","length","hash","i","char","charCodeAt","Math","abs","toString","step","max","floor","simpleHash","configStringCache","generateConfigHash","routes","quickKey","name","cachedStr","currentStr","JSON","stringify","substring","startsWith","configStr","includes","title","order","undefined","validatedPathCache","Set","PATH_TRAVERSAL_REGEX","ABSOLUTE_PATH_REGEX","CONTROL_CHAR_REGEX","NULL_BYTE_REGEX","validatePath","path","config","valid","error","process","env","NODE_ENV","test","prefixSet","isAllowed","Array","from","some","prefix","join","validation","validateInput","safe","reason","add","NORMALIZE_REGEX","multipleSlashes","dotSlash","trailingDot","normalizePath","replace","trim","isValidPathString","isComponentImport","createDynamicImport","extractAndValidatePath","map","options","normalizedPath","existingImport","errorMessage","warn","importFn","debug","StackNodePool","acquire","route","depth","pool","node","pop","release","maxPoolSize","push","stackNodePool","extractPathsOnly","result","maxDepth","enableParallel","batchSize","pathsToProcess","stack","page","pages","layout","layouts","errors","loading","loadings","children","isArray","batch","slice","Promise","all","resolve","cleanupExpiredCache","transformRoutes","startTime","mergedOptions","routesArray","err","Error","originalError","configHash","cached","extractStartTime","extractEndTime","extractDuration","cacheStartTime","cachedResult","structuredClone","parse","cacheEndTime","cacheDuration","endTime","totalDuration","toFixed","routeCount","pageCount","layoutCount","errorCount","loadingCount","hit"],"mappings":";;;;;;;;;;;;;AACA,SAASA,aAAa,EAAEC,aAAa,EAAEC,eAAe,EAAEC,MAAM,QAAQ,iBAAiB;AA+UvF;;CAEC,GACD,IAAA,AAAMC,WAAN,MAAMA;IAQJC,IAAIC,GAAW,EAAyB;QACtC,MAAMC,OAAO,IAAI,CAACC,KAAK,CAACH,GAAG,CAACC;QAC5B,IAAIC,MAAM;YACR,SAAS;YACTA,KAAKE,UAAU,GAAGC,KAAKC,GAAG;YAC1B,cAAc;YACd,IAAI,CAACH,KAAK,CAACI,MAAM,CAACN;YAClB,IAAI,CAACE,KAAK,CAACK,GAAG,CAACP,KAAKC;QACtB;QACA,OAAOA;IACT;IAEAM,IAAIP,GAAW,EAAEQ,KAAgB,EAAQ;QACvC,YAAY;QACZ,IAAI,IAAI,CAACN,KAAK,CAACO,GAAG,CAACT,MAAM;YACvB,IAAI,CAACE,KAAK,CAACI,MAAM,CAACN;QACpB,OAAO,IAAI,IAAI,CAACE,KAAK,CAACQ,IAAI,IAAI,IAAI,CAACC,OAAO,EAAE;YAC1C,0BAA0B;YAC1B,MAAMC,WAAW,IAAI,CAACV,KAAK,CAACW,IAAI,GAAGC,IAAI,GAAGN,KAAK;YAC/C,IAAII,UAAU;gBACZ,IAAI,CAACV,KAAK,CAACI,MAAM,CAACM;YACpB;QACF;QACAJ,MAAML,UAAU,GAAGC,KAAKC,GAAG;QAC3B,IAAI,CAACH,KAAK,CAACK,GAAG,CAACP,KAAKQ;IACtB;IAEAF,OAAON,GAAW,EAAW;QAC3B,OAAO,IAAI,CAACE,KAAK,CAACI,MAAM,CAACN;IAC3B;IAEAe,QAAc;QACZ,IAAI,CAACb,KAAK,CAACa,KAAK;IAClB;IAEAL,OAAe;QACb,OAAO,IAAI,CAACR,KAAK,CAACQ,IAAI;IACxB;IAEAM,eAAeC,QAAgB,EAAQ;QACrC,MAAMZ,MAAMD,KAAKC,GAAG;QACpB,KAAK,MAAM,CAACL,KAAKC,KAAK,IAAI,IAAI,CAACC,KAAK,CAACgB,OAAO,GAAI;YAC9C,IAAIb,MAAMJ,KAAKkB,SAAS,GAAGF,UAAU;gBACnC,IAAI,CAACf,KAAK,CAACI,MAAM,CAACN;YACpB;QACF;IACF;IAlDA,YAAYW,UAAkB,EAAE,CAAE;QAHlC,uBAAQT,SAAQ,IAAIkB;QACpB,uBAAQT,WAAR,KAAA;QAGE,IAAI,CAACA,OAAO,GAAGA;IACjB;AAiDF;AAEA;;CAEC,GACD,IAAIU,iBAAkC;AAEtC;;CAEC,GACD,MAAMC,kBAA8C;IAClDC,gBAAgB;QACdC,sBAAsB;QACtBC,qBAAqB,EAAE;QACvBC,eAAe;QACfC,oBAAoB;IACtB;IACAC,aAAa;QACXC,aAAa;QACbZ,UAAU,IAAI,KAAK;QACnBa,cAAc;QACdC,mBAAmB;QACnBC,0BAA0B;QAC1BC,mBAAmB;IACrB;IACAC,gBAAgB;AAClB;AAEA;;;CAGC,GACD,SAASC,cAAcC,GAAW;IAChC,gBAAgB;IAChB,IAAIA,IAAIC,MAAM,GAAG,KAAK;QACpB,IAAIC,OAAO;QACX,IAAK,IAAIC,IAAI,GAAGA,IAAIH,IAAIC,MAAM,EAAEE,IAAK;YACnC,MAAMC,OAAOJ,IAAIK,UAAU,CAACF;YAC5BD,OAAO,AAAEA,CAAAA,QAAQ,CAAA,IAAKA,OAAQE;YAC9BF,OAAOA,OAAOA,MAAM,aAAa;QACnC;QACA,OAAOI,KAAKC,GAAG,CAACL,MAAMM,QAAQ,CAAC;IACjC;IAEA,gBAAgB;IAChB,IAAIN,OAAO;IACX,MAAMO,OAAOH,KAAKI,GAAG,CAAC,GAAGJ,KAAKK,KAAK,CAACX,IAAIC,MAAM,GAAG;IACjD,IAAK,IAAIE,IAAI,GAAGA,IAAIH,IAAIC,MAAM,EAAEE,KAAKM,KAAM;QACzC,MAAML,OAAOJ,IAAIK,UAAU,CAACF;QAC5BD,OAAO,AAAEA,CAAAA,QAAQ,CAAA,IAAKA,OAAQE;QAC9BF,OAAOA,OAAOA;IAChB;IACA,OAAOI,KAAKC,GAAG,CAACL,MAAMM,QAAQ,CAAC;AACjC;AAEA;;;CAGC,GACD,4DAA4D;AAC5D,yBAAyB;AACzB,kFAAkF;AAClF,YAAY;AACZ,2CAA2C;AAC3C,0CAA0C;AAC1C,wEAAwE;AACxE,kEAAkE;AAClE,8FAA8F;AAC9F,gBAAgB;AAChB,oCAAoC;AACpC,mCAAmC;AACnC,QAAQ;AACR,MAAM;AACN,+BAA+B;AAC/B,IAAI;AAEJ;;CAEC,GACD,SAASI,WAAWZ,GAAW;IAC7B,OAAOD,cAAcC;AACvB;AAEA;;CAEC,GACD,MAAMa,oBAAoB,IAAI7B;AAE9B;;;CAGC,GACD,SAAS8B,mBAAmBC,MAAqB;IAC/C,IAAI;QACF,sBAAsB;QACtB,IAAIA,OAAOd,MAAM,KAAK,GAAG;YACvB,OAAO;QACT;QAEA,kBAAkB;QAClB,MAAMe,WAAW,GAAGD,OAAOd,MAAM,CAAC,CAAC,EAAEc,MAAM,CAAC,EAAE,EAAEE,QAAQ,GAAG,CAAC,EAAEF,MAAM,CAACA,OAAOd,MAAM,GAAG,EAAE,EAAEgB,QAAQ,IAAI;QAErG,UAAU;QACV,IAAIJ,kBAAkBxC,GAAG,CAAC2C,WAAW;YACnC,MAAME,YAAYL,kBAAkBlD,GAAG,CAACqD;YACxC,mBAAmB;YACnB,MAAMG,aAAaC,KAAKC,SAAS,CAACN,QAAQ,MAAM,GAAGO,SAAS,CAAC,GAAG;YAChE,IAAIJ,UAAUK,UAAU,CAACJ,WAAWG,SAAS,CAAC,GAAG,MAAM;gBACrD,OAAOV,WAAWM;YACpB;QACF;QAEA,+BAA+B;QAC/B,eAAe;QACf,MAAMM,YAAYJ,KAAKC,SAAS,CAACN,QAAQ,CAACnD,KAAKQ;YAC7C,WAAW;YACX,IAAI;gBAAC;gBAAQ;gBAAQ;gBAAQ;gBAAU;gBAAU;gBAAW;gBAAW;gBAAqB;aAAW,CAACqD,QAAQ,CAAC7D,MAAM;gBACrH,OAAOQ;YACT;YACA,IAAIR,QAAQ,YAAYQ,SAAS,OAAOA,UAAU,UAAU;gBAC1D,oBAAoB;gBACpB,OAAO;oBACLsD,OAAO,AAACtD,MAA6BsD,KAAK;oBAC1CC,OAAO,AAACvD,MAA6BuD,KAAK;gBAC5C;YACF;YACA,OAAOC;QACT;QAEA,kBAAkB;QAClB,IAAIf,kBAAkBvC,IAAI,GAAG,IAAI;YAC/BuC,kBAAkB1C,GAAG,CAAC6C,UAAUQ;QAClC;QAEA,OAAOZ,WAAWY;IACpB,EAAE,OAAM;QACN,wBAAwB;QACxB,OAAO;IACT;AACF;AAEA;;CAEC,GACD,MAAMK,qBAAqB,IAAIC;AAE/B;;CAEC,GACD,MAAMC,uBAAuB;AAC7B,MAAMC,sBAAsB;AAC5B,MAAMC,qBAAqB;AAC3B,MAAMC,kBAAkB;AACxB,kBAAkB;AAClB,6CAA6C;AAC7C,uDAAuD;AAEvD;;;CAGC,GACD,SAASC,aACPC,IAAY,EACZC,MAAsC;IAEtC,YAAY;IACZ,IAAIR,mBAAmBxD,GAAG,CAAC+D,OAAO;QAChC,OAAO;YAAEE,OAAO;QAAK;IACvB;IAEA,oBAAoB;IACpB,IAAIF,KAAKnC,MAAM,GAAGoC,OAAO/C,aAAa,EAAE;QACtC,OAAO;YACLgD,OAAO;YACPC,OAAOC,QAAQC,GAAG,CAACC,QAAQ,KAAK,gBAC5B,CAAC,WAAW,EAAEL,OAAO/C,aAAa,CAAC,GAAG,CAAC,GACvC;QACN;IACF;IAEA,cAAc;IACd,IAAI8C,KAAKnC,MAAM,KAAK,GAAG;QACrB,OAAO;YACLqC,OAAO;YACPC,OAAO;QACT;IACF;IAEA,oBAAoB;IACpB,IAAIR,qBAAqBY,IAAI,CAACP,OAAO;QACnC,OAAO;YACLE,OAAO;YACPC,OAAOC,QAAQC,GAAG,CAACC,QAAQ,KAAK,gBAC5B,6BACA;QACN;IACF;IAEA,UAAU;IACV,IAAIR,gBAAgBS,IAAI,CAACP,OAAO;QAC9B,OAAO;YACLE,OAAO;YACPC,OAAOC,QAAQC,GAAG,CAACC,QAAQ,KAAK,gBAC5B,qBACA;QACN;IACF;IAEA,SAAS;IACT,IAAIT,mBAAmBU,IAAI,CAACP,OAAO;QACjC,OAAO;YACLE,OAAO;YACPC,OAAOC,QAAQC,GAAG,CAACC,QAAQ,KAAK,gBAC5B,sBACA;QACN;IACF;IAEA,0BAA0B;IAC1B,4CAA4C;IAC5C,aAAa;IACb,oBAAoB;IACpB,oDAAoD;IACpD,0BAA0B;IAC1B,oBAAoB;IACpB,OAAO;IACP,IAAI;IAEJ,kBAAkB;IAClB,IAAI,CAACL,OAAO9C,kBAAkB,IAAIyC,oBAAoBW,IAAI,CAACP,OAAO;QAChE,OAAO;YACLE,OAAO;YACPC,OAAOC,QAAQC,GAAG,CAACC,QAAQ,KAAK,gBAC5B,cACA;QACN;IACF;IAEA,8BAA8B;IAC9B,IAAIL,OAAOhD,mBAAmB,CAACY,MAAM,GAAG,GAAG;QACzC,MAAM2C,YAAY,IAAId,IAAIO,OAAOhD,mBAAmB;QACpD,MAAMwD,YAAYC,MAAMC,IAAI,CAACH,WAAWI,IAAI,CAAC,CAACC,SAAWb,KAAKb,UAAU,CAAC0B;QACzE,IAAI,CAACJ,WAAW;YACd,OAAO;gBACLP,OAAO;gBACPC,OAAOC,QAAQC,GAAG,CAACC,QAAQ,KAAK,gBAC5B,CAAC,cAAc,EAAEL,OAAOhD,mBAAmB,CAAC6D,IAAI,CAAC,OAAO,GACxD;YACN;QACF;IACF;IAEA,qCAAqC;IACrC,MAAMC,aAAa7F,cAAc8F,aAAa,CAAChB;IAC/C,IAAI,CAACe,WAAWE,IAAI,EAAE;QACpB,OAAO;YACLf,OAAO;YACPC,OAAOC,QAAQC,GAAG,CAACC,QAAQ,KAAK,gBAC3BS,WAAWG,MAAM,IAAI,gBACtB;QACN;IACF;IAEA,qBAAqB;IACrB,IAAIzB,mBAAmBvD,IAAI,GAAG,MAAM;QAClCuD,mBAAmB0B,GAAG,CAACnB;IACzB;IAEA,OAAO;QAAEE,OAAO;IAAK;AACvB;AAEA;;CAEC,GACD,MAAMkB,kBAAkB;IACtBC,iBAAiB;IACjBC,UAAU;IACVC,aAAa;AACf;AAEA;;;CAGC,GACD,SAASC,cAAcxB,IAAY;IACjC,qBAAqB;IACrB,OAAOA,KACJyB,OAAO,CAACL,gBAAgBC,eAAe,EAAE,KACzCI,OAAO,CAACL,gBAAgBE,QAAQ,EAAE,KAClCG,OAAO,CAACL,gBAAgBG,WAAW,EAAE,IACrCG,IAAI;AACT;AAEA;;CAEC,GACD,SAASC,kBAAkB3B,IAAa;IACtC,OAAO,OAAOA,SAAS,YAAYA,KAAKnC,MAAM,GAAG;AACnD;AAEA;;CAEC,GACD,SAAS+D,kBAAkB5B,IAAa;IACtC,OAAO,OAAOA,SAAS;AACzB;AAEA;;;;;;;;;;;;;;;;;;;;CAoBC,GACD,SAAS6B,oBAAoB7B,IAAY;IACvC,0CAA0C;IAC1C,mBAAmB;IACnB,OAAO,IAAM,MAAM,CAAEA;AACvB;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;CAyBC,GACD,SAAS8B,uBACP9B,IAAsD,EACtD+B,GAAoC,EACpC9B,MAAsC,EACtC+B,OAAyB;IAEzB,2BAA2B;IAC3B,IAAIJ,kBAAkB5B,OAAO;QAC3B,OAAOA;IACT;IAEA,oBAAoB;IACpB,IAAI,CAAC2B,kBAAkB3B,OAAO;QAC5B,OAAO;IACT;IAEA,QAAQ;IACR,MAAMiC,iBAAiBT,cAAcxB;IAErC,8BAA8B;IAC9B,MAAMkC,iBAAiBH,IAAIxG,GAAG,CAAC0G;IAC/B,IAAIC,mBAAmB1C,WAAW;QAChC,OAAO0C;IACT;IAEA,uBAAuB;IACvB,IAAIjC,OAAOjD,oBAAoB,EAAE;QAC/B,MAAM+D,aAAahB,aAAakC,gBAAgBhC;QAChD,IAAI,CAACc,WAAWb,KAAK,EAAE;YACrB,aAAa;YACb,MAAMiC,eAAe/B,QAAQC,GAAG,CAACC,QAAQ,KAAK,gBAC1C,CAAC,QAAQ,EAAES,WAAWZ,KAAK,EAAE,GAC7B;YAEJ,MAAMA,QAAQ,IAAIhF,cAChBgH,cACA3C,WACAY,QAAQC,GAAG,CAACC,QAAQ,KAAK,gBAAgB;gBAAEN,MAAMiC;YAAe,IAAI,CAAC;YAGvE,IAAID,QAAQtE,cAAc,EAAE;gBAC1BrC,OAAO8E,KAAK,CAAC,WAAWA;YAC1B;YAEA,uBAAuB;YACvB,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,eAAe;gBAC1C,MAAMH;YACR,OAAO;gBACL,WAAW;gBACX9E,OAAO+G,IAAI,CAAC;gBACZ,OAAO;YACT;QACF;IACF;IAEA,cAAc;IACd,MAAMC,WAAWR,oBAAoBI;IACrCF,IAAIhG,GAAG,CAACkG,gBAAgBI;IAExB,IAAIL,QAAQtE,cAAc,EAAE;QAC1BrC,OAAOiH,KAAK,CAAC,SAASL;IACxB;IAEA,OAAOI;AACT;AAEA;;CAEC,GACD,IAAA,AAAME,gBAAN,MAAMA;IAIJC,QAAQC,KAAkB,EAAEC,KAAa,EAAyC;QAChF,IAAI,IAAI,CAACC,IAAI,CAAC9E,MAAM,GAAG,GAAG;YACxB,MAAM+E,OAAO,IAAI,CAACD,IAAI,CAACE,GAAG;YAC1BD,KAAKH,KAAK,GAAGA;YACbG,KAAKF,KAAK,GAAGA;YACb,OAAOE;QACT;QACA,OAAO;YAAEH;YAAOC;QAAM;IACxB;IAEAI,QAAQF,IAA2C,EAAQ;QACzD,IAAI,IAAI,CAACD,IAAI,CAAC9E,MAAM,GAAG,IAAI,CAACkF,WAAW,EAAE;YACvC,IAAI,CAACJ,IAAI,CAACK,IAAI,CAACJ;QACjB;IACF;;QAjBA,uBAAQD,QAAqD,EAAE;QAC/D,uBAAQI,eAAc;;AAiBxB;AAEA,MAAME,gBAAgB,IAAIV;AAE1B;;;;;;;;;;;;;;CAcC,GACD,eAAeW,iBACbvE,MAAqB,EACrBwE,MAA6B,EAC7BlD,MAAsC,EACtC+B,OAAyB,EACzBoB,QAAgB;IAEhB,MAAMC,iBAAiBrB,QAAQ5E,WAAW,EAAEI,4BAA4B;IACxE,MAAM8F,YAAYtB,QAAQ5E,WAAW,EAAEK,qBAAqB;IAE5D,yBAAyB;IACzB,IAAI4F,kBAAkB1E,OAAOd,MAAM,GAAGyF,WAAW;QAC/C,kCAAkC;QAClC,MAAMC,iBAGD,EAAE;QAEP,cAAc;QACd,MAAMC,QAAsD,EAAE;QAC9D,IAAK,IAAIzF,IAAIY,OAAOd,MAAM,GAAG,GAAGE,KAAK,GAAGA,IAAK;YAC3CyF,MAAMR,IAAI,CAAC;gBAAEP,OAAO9D,MAAM,CAACZ,EAAE;gBAAE2E,OAAO;YAAE;QAC1C;QAEA,MAAOc,MAAM3F,MAAM,GAAG,EAAG;YACvB,MAAM,EAAE4E,KAAK,EAAEC,KAAK,EAAE,GAAGc,MAAMX,GAAG;YAElC,IAAIH,QAAQU,UAAU;gBACpB/H,OAAO+G,IAAI,CAAC,CAAC,WAAW,EAAEgB,SAAS,MAAM,CAAC,EAAEX,MAAM5D,IAAI;gBACtD;YACF;YAEA,iCAAiC;YACjC,IAAI4D,MAAMgB,IAAI,IAAI,OAAOhB,MAAMgB,IAAI,KAAK,UAAU;gBAChDF,eAAeP,IAAI,CAAC;oBAAEhD,MAAMyC,MAAMgB,IAAI;oBAAE1B,KAAKoB,OAAOO,KAAK;gBAAC;YAC5D;YACA,IAAIjB,MAAMkB,MAAM,IAAI,OAAOlB,MAAMkB,MAAM,KAAK,UAAU;gBACpDJ,eAAeP,IAAI,CAAC;oBAAEhD,MAAMyC,MAAMkB,MAAM;oBAAE5B,KAAKoB,OAAOS,OAAO;gBAAC;YAChE;YACA,IAAInB,MAAMoB,MAAM,IAAI,OAAOpB,MAAMoB,MAAM,KAAK,UAAU;gBACpDN,eAAeP,IAAI,CAAC;oBAAEhD,MAAMyC,MAAMoB,MAAM;oBAAE9B,KAAKoB,OAAOU,MAAM;gBAAC;YAC/D;YACA,IAAIpB,MAAMqB,OAAO,IAAI,OAAOrB,MAAMqB,OAAO,KAAK,UAAU;gBACtDP,eAAeP,IAAI,CAAC;oBAAEhD,MAAMyC,MAAMqB,OAAO;oBAAE/B,KAAKoB,OAAOY,QAAQ;gBAAC;YAClE;YAEA,QAAQ;YACR,IAAItB,MAAMuB,QAAQ,IAAItD,MAAMuD,OAAO,CAACxB,MAAMuB,QAAQ,KAAKvB,MAAMuB,QAAQ,CAACnG,MAAM,GAAG,GAAG;gBAChF,IAAK,IAAIE,IAAI0E,MAAMuB,QAAQ,CAACnG,MAAM,GAAG,GAAGE,KAAK,GAAGA,IAAK;oBACnDyF,MAAMR,IAAI,CAAC;wBAAEP,OAAOA,MAAMuB,QAAQ,CAACjG,EAAE;wBAAE2E,OAAOA,QAAQ;oBAAE;gBAC1D;YACF;QACF;QAEA,eAAe;QACf,IAAK,IAAI3E,IAAI,GAAGA,IAAIwF,eAAe1F,MAAM,EAAEE,KAAKuF,UAAW;YACzD,MAAMY,QAAQX,eAAeY,KAAK,CAACpG,GAAGA,IAAIuF;YAC1C,MAAMc,QAAQC,GAAG,CACfH,MAAMnC,GAAG,CAAC,CAAC,EAAE/B,IAAI,EAAE+B,GAAG,EAAE,GACtBqC,QAAQE,OAAO,CAACxC,uBAAuB9B,MAAM+B,KAAK9B,QAAQ+B;QAGhE;IACF,OAAO;QACL,sBAAsB;QACtB,MAAMwB,QAAsD,EAAE;QAE9D,iBAAiB;QACjB,IAAK,IAAIzF,IAAIY,OAAOd,MAAM,GAAG,GAAGE,KAAK,GAAGA,IAAK;YAC3CyF,MAAMR,IAAI,CAACC,cAAcT,OAAO,CAAC7D,MAAM,CAACZ,EAAE,EAAE;QAC9C;QAEA,YAAY;QACZ,MAAOyF,MAAM3F,MAAM,GAAG,EAAG;YACvB,MAAM+E,OAAOY,MAAMX,GAAG;YACtB,MAAM,EAAEJ,KAAK,EAAEC,KAAK,EAAE,GAAGE;YAEzB,SAAS;YACT,IAAIF,QAAQU,UAAU;gBACpB/H,OAAO+G,IAAI,CAAC,CAAC,WAAW,EAAEgB,SAAS,MAAM,CAAC,EAAEX,MAAM5D,IAAI;gBACtDoE,cAAcH,OAAO,CAACF;gBACtB;YACF;YAEA,wBAAwB;YACxBd,uBAAuBW,MAAMgB,IAAI,EAAEN,OAAOO,KAAK,EAAEzD,QAAQ+B;YACzDF,uBAAuBW,MAAMkB,MAAM,EAAER,OAAOS,OAAO,EAAE3D,QAAQ+B;YAC7DF,uBAAuBW,MAAMoB,MAAM,EAAEV,OAAOU,MAAM,EAAE5D,QAAQ+B;YAC5DF,uBAAuBW,MAAMqB,OAAO,EAAEX,OAAOY,QAAQ,EAAE9D,QAAQ+B;YAE/D,QAAQ;YACR,IAAIS,MAAMuB,QAAQ,IAAItD,MAAMuD,OAAO,CAACxB,MAAMuB,QAAQ,KAAKvB,MAAMuB,QAAQ,CAACnG,MAAM,GAAG,GAAG;gBAChF,0BAA0B;gBAC1B,IAAK,IAAIE,IAAI0E,MAAMuB,QAAQ,CAACnG,MAAM,GAAG,GAAGE,KAAK,GAAGA,IAAK;oBACnDyF,MAAMR,IAAI,CAACC,cAAcT,OAAO,CAACC,MAAMuB,QAAQ,CAACjG,EAAE,EAAE2E,QAAQ;gBAC9D;YACF;YAEA,WAAW;YACXO,cAAcH,OAAO,CAACF;QACxB;IACF;AACF;AAEA;;;CAGC,GACD,SAAS2B,oBAAoB9H,QAAgB;IAC3C,IAAII,gBAAgB;QAClBA,eAAeL,cAAc,CAACC;IAChC;AACF;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4DC,GACD,OAAO,eAAe+H,gBACpB7F,MAA8B,EAC9BqD,UAA4B,CAAC,CAAC;IAE9B,MAAMyC,YAAYrH,YAAYvB,GAAG;IACjC,MAAM6I,gBAA4C;QAChD3H,gBAAgB;YAAE,GAAGD,gBAAgBC,cAAc;YAAE,GAAGiF,QAAQjF,cAAc;QAAC;QAC/EK,aAAa;YAAE,GAAGN,gBAAgBM,WAAW;YAAE,GAAG4E,QAAQ5E,WAAW;QAAC;QACtEM,gBAAgBsE,QAAQtE,cAAc,IAAIZ,gBAAgBY,cAAc;IAC1E;IAEA,gCAAgC;IAChC,IAAI,CAACiB,QAAQ;QACX,IAAI+F,cAAchH,cAAc,EAAE;YAChCrC,OAAOiH,KAAK,CAAC;QACf;QACA,OAAO;YACLoB,OAAO,IAAI9G;YACXgH,SAAS,IAAIhH;YACbiH,QAAQ,IAAIjH;YACZmH,UAAU,IAAInH;YACd+B,QAAQ,EAAE;QACZ;IACF;IAEA,qBAAqB;IACrB,IAAIgG;IACJ,IAAI;QACFA,cAAc,OAAOhG,WAAW,aAAa,MAAMA,WAAWA;IAChE,EAAE,OAAOwB,OAAO;QACd,MAAMyE,MAAMzE,iBAAiB0E,QAAQ1E,QAAQ,IAAI0E,MAAM;QACvDxJ,OAAO8E,KAAK,CAAC,aAAayE;QAC1B,MAAM,IAAIxJ,gBAAgB,YAAY;YAAE0J,eAAeF;QAAI;IAC7D;IAEA,mCAAmC;IACnC,IAAI,CAAClE,MAAMuD,OAAO,CAACU,gBAAgBA,YAAY9G,MAAM,KAAK,GAAG;QAC3D,IAAI6G,cAAchH,cAAc,EAAE;YAChCrC,OAAOiH,KAAK,CAAC;QACf;QACA,OAAO;YACLoB,OAAO,IAAI9G;YACXgH,SAAS,IAAIhH;YACbiH,QAAQ,IAAIjH;YACZmH,UAAU,IAAInH;YACd+B,QAAQ,EAAE;QACZ;IACF;IAEA,OAAO;IACP,MAAMlC,WAAoBiI,cAActH,WAAW,CAACX,QAAQ,IAAIK,gBAAgBM,WAAW,CAACX,QAAQ;IACpG,MAAMa,eAAwBoH,cAActH,WAAW,CAACE,YAAY,IAAIR,gBAAgBM,WAAW,CAACE,YAAY;IAEhH,IAAIoH,cAActH,WAAW,CAACC,WAAW,EAAE;QACzC,6BAA6B;QAC7B,IAAI,CAACR,kBAAkBA,eAAeX,IAAI,OAAOoB,cAAc;YAC7DT,iBAAiB,IAAIvB,SAASgC;QAChC;QAEA,MAAMyH,aAAarG,mBAAmBiG;QACtC,IAAII,YAAY;YACd,MAAMC,SAASnI,eAAetB,GAAG,CAACwJ;YAClC,IAAIC,UAAUpJ,KAAKC,GAAG,KAAKmJ,OAAOrI,SAAS,GAAGF,UAAU;gBACtD,IAAIiI,cAAchH,cAAc,EAAE;oBAChCrC,OAAOiH,KAAK,CAAC;gBACf;gBACA,4BAA4B;gBAC5B,OAAO0C,OAAO7B,MAAM;YACtB;QACF;QAEA,SAAS;QACToB,oBAAoB9H;IACtB;IAEA,UAAU;IACV,MAAM0G,SAAgC;QACpCO,OAAO,IAAI9G;QACXgH,SAAS,IAAIhH;QACbiH,QAAQ,IAAIjH;QACZmH,UAAU,IAAInH;QACd+B,QAAQ,EAAE;IACZ;IAEA,IAAI;QACF,eAAe;QACf,MAAMsG,mBAAmB7H,YAAYvB,GAAG;QAExC,yBAAyB;QACzB,MAAMkB,iBAAiD;YACrDC,sBAAuB0H,cAAc3H,cAAc,CAACC,oBAAoB,IAAIF,gBAAgBC,cAAc,CAACC,oBAAoB;YAC/HC,qBAAsByH,cAAc3H,cAAc,CAACE,mBAAmB,IAAIH,gBAAgBC,cAAc,CAACE,mBAAmB;YAC5HC,eAAgBwH,cAAc3H,cAAc,CAACG,aAAa,IAAIJ,gBAAgBC,cAAc,CAACG,aAAa;YAC1GC,oBAAqBuH,cAAc3H,cAAc,CAACI,kBAAkB,IAAIL,gBAAgBC,cAAc,CAACI,kBAAkB;QAC3H;QACA,MAAMI,oBAA6BmH,cAActH,WAAW,CAACG,iBAAiB,IAAIT,gBAAgBM,WAAW,CAACG,iBAAiB;QAE/H,iBAAiB;QACjB,MAAM2F,iBACJyB,aACAxB,QACApG,gBACA2H,eACAnH;QAGF,MAAM2H,iBAAiB9H,YAAYvB,GAAG;QACtC,MAAMsJ,kBAAkBD,iBAAiBD;QAEzC,mBAAmB;QACnB9B,OAAOxE,MAAM,GAAGgG;QAEhB,OAAO;QACP,MAAMS,iBAAiBhI,YAAYvB,GAAG;QACtC,IAAI6I,cAActH,WAAW,CAACC,WAAW,IAAIR,gBAAgB;YAC3D,MAAMkI,aAAarG,mBAAmBiG;YACtC,IAAII,YAAY;gBACd,iCAAiC;gBACjC,IAAIM;gBACJ,IAAI,OAAOC,oBAAoB,aAAa;oBAC1C,kBAAkB;oBAClBD,eAAeC,gBAAgBnC;oBAC/B,wCAAwC;oBACxCkC,aAAa3B,KAAK,GAAG,IAAI9G,IAAIuG,OAAOO,KAAK;oBACzC2B,aAAazB,OAAO,GAAG,IAAIhH,IAAIuG,OAAOS,OAAO;oBAC7CyB,aAAaxB,MAAM,GAAG,IAAIjH,IAAIuG,OAAOU,MAAM;oBAC3CwB,aAAatB,QAAQ,GAAG,IAAInH,IAAIuG,OAAOY,QAAQ;gBACjD,OAAO;oBACL,WAAW;oBACXsB,eAAe;wBACb3B,OAAO,IAAI9G,IAAIuG,OAAOO,KAAK;wBAC3BE,SAAS,IAAIhH,IAAIuG,OAAOS,OAAO;wBAC/BC,QAAQ,IAAIjH,IAAIuG,OAAOU,MAAM;wBAC7BE,UAAU,IAAInH,IAAIuG,OAAOY,QAAQ;wBACjCpF,QAAQK,KAAKuG,KAAK,CAACvG,KAAKC,SAAS,CAACkE,OAAOxE,MAAM;oBACjD;gBACF;gBAEA9B,eAAed,GAAG,CAACgJ,YAAY;oBAC7B5B,QAAQkC;oBACR1I,WAAWf,KAAKC,GAAG;oBACnBiC,MAAMiH;oBACNpJ,YAAYC,KAAKC,GAAG;gBACtB;YACF;QACF;QACA,MAAM2J,eAAepI,YAAYvB,GAAG;QACpC,MAAM4J,gBAAgBD,eAAeJ;QAErC,MAAMM,UAAUtI,YAAYvB,GAAG;QAC/B,MAAM8J,gBAAgBD,UAAUjB;QAEhC,IAAIC,cAAchH,cAAc,EAAE;YAChC,UAAU;YACVrC,OAAOiH,KAAK,CAAC,CAAC,YAAY,EAAEqD,cAAcC,OAAO,CAAC,GAAG,EAAE,CAAC,EAAE;gBACxDC,YAAY1C,OAAOxE,MAAM,CAACd,MAAM;gBAChCiI,WAAW3C,OAAOO,KAAK,CAACxH,IAAI;gBAC5B6J,aAAa5C,OAAOS,OAAO,CAAC1H,IAAI;gBAChC8J,YAAY7C,OAAOU,MAAM,CAAC3H,IAAI;gBAC9B+J,cAAc9C,OAAOY,QAAQ,CAAC7H,IAAI;gBAClCkB,aAAa;oBACX+H,iBAAiB,GAAGA,gBAAgBS,OAAO,CAAC,GAAG,EAAE,CAAC;oBAClDH,eAAe,GAAGA,cAAcG,OAAO,CAAC,GAAG,EAAE,CAAC;oBAC9CD,eAAe,GAAGA,cAAcC,OAAO,CAAC,GAAG,EAAE,CAAC;gBAChD;gBACAlK,OAAO;oBACLwK,KAAKrJ,iBAAiB,SAAS;oBAC/BX,MAAMW,gBAAgBX,UAAU;gBAClC;YACF;QACF;QAEA,OAAOiH;IACT,EAAE,OAAOhD,OAAO;QACd,MAAMyE,MAAMzE,iBAAiB0E,QAAQ1E,QAAQ,IAAI0E,MAAM;QACvDxJ,OAAO8E,KAAK,CAAC,WAAWyE;QACxB,MAAM,IAAIxJ,gBAAgB,UAAU;YAAE0J,eAAeF;QAAI;IAC3D;AACF"}

package/dist/core/router/validation/RouterConfigValidator.cjs

@@ -0,0 +1,85 @@
+/**
+ * 路由配置验证器
+ * 使用 Zod 进行配置验证，并提供友好的错误信息
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "RouterConfigValidator", {
+    enumerable: true,
+    get: function() {
+        return RouterConfigValidator;
+    }
+});
+const _ConfigValidator = require("../../config/ConfigValidator");
+const _utils = require("../../../utils");
+const _schema = require("./schema");
+let RouterConfigValidator = class RouterConfigValidator {
+    /**
+   * 验证路由配置
+   * 
+   * @param config - 要验证的路由配置
+   * @returns 验证后的路由配置
+   * @throws ConfigValidationError 如果配置验证失败
+   */ static validate(config) {
+        const result = (0, _schema.safeValidateRouterConfig)(config);
+        if (!result.success) {
+            // 构建友好的错误信息
+            const errorMessages = result.error.issues.map((issue)=>{
+                const path = issue.path.length > 0 ? issue.path.join('.') : 'root';
+                return `路由配置项 "${path}": ${issue.message}`;
+            });
+            const friendlyMessage = `路由配置验证失败:\n${errorMessages.join('\n')}`;
+            _utils.logger.error('路由配置验证失败', {
+                errors: result.error.issues,
+                config
+            });
+            throw new _ConfigValidator.ConfigValidationError(friendlyMessage, result.error);
+        }
+        return result.data;
+    }
+    /**
+   * 安全验证路由配置（不抛出异常）
+   * 
+   * @param config - 要验证的路由配置
+   * @returns 验证结果
+   */ static safeValidate(config) {
+        return (0, _schema.safeValidateRouterConfig)(config);
+    }
+    /**
+   * 验证路由配置并提供修复建议
+   * 
+   * @param config - 要验证的路由配置
+   * @returns 验证结果和修复建议
+   */ static validateWithSuggestions(config) {
+        const result = (0, _schema.safeValidateRouterConfig)(config);
+        if (!result.success) {
+            const suggestions = [];
+            result.error.issues.forEach((issue)=>{
+                const path = issue.path.join('.');
+                // 根据错误类型提供修复建议
+                if (issue.code === 'invalid_type') {
+                    const invalidTypeIssue = issue;
+                    suggestions.push(`配置项 "${path}" 类型错误: 期望 ${invalidTypeIssue.expected}，实际 ${invalidTypeIssue.received}`);
+                } else if (issue.code === 'too_small') {
+                    suggestions.push(`配置项 "${path}" 值太小: ${issue.message}`);
+                } else if (issue.code === 'too_big') {
+                    suggestions.push(`配置项 "${path}" 值太大: ${issue.message}`);
+                } else {
+                    suggestions.push(`配置项 "${path}": ${issue.message}`);
+                }
+            });
+            return {
+                success: false,
+                errors: result.error.issues,
+                suggestions
+            };
+        }
+        return {
+            success: true,
+            data: result.data
+        };
+    }
+};
+
+//# sourceMappingURL=RouterConfigValidator.js.map

package/dist/core/router/validation/RouterConfigValidator.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/core/router/validation/RouterConfigValidator.ts"],"sourcesContent":["/**\n * 路由配置验证器\n * 使用 Zod 进行配置验证，并提供友好的错误信息\n */\n\nimport { z } from 'zod';\nimport { ConfigValidationError } from '../../config/ConfigValidator';\nimport { logger } from '../../../utils';\nimport { safeValidateRouterConfig } from './schema';\n\n/**\n * 路由配置验证器\n */\nexport class RouterConfigValidator {\n  /**\n   * 验证路由配置\n   * \n   * @param config - 要验证的路由配置\n   * @returns 验证后的路由配置\n   * @throws ConfigValidationError 如果配置验证失败\n   */\n  static validate(config: unknown) {\n    const result = safeValidateRouterConfig(config);\n\n    if (!result.success) {\n      // 构建友好的错误信息\n      const errorMessages = result.error.issues.map((issue: z.ZodIssue) => {\n        const path = issue.path.length > 0 ? issue.path.join('.') : 'root';\n        return `路由配置项 \"${path}\": ${issue.message}`;\n      });\n\n      const friendlyMessage = `路由配置验证失败:\\n${errorMessages.join('\\n')}`;\n\n      logger.error('路由配置验证失败', {\n        errors: result.error.issues,\n        config,\n      });\n\n      throw new ConfigValidationError(friendlyMessage, result.error);\n    }\n\n    return result.data;\n  }\n\n  /**\n   * 安全验证路由配置（不抛出异常）\n   * \n   * @param config - 要验证的路由配置\n   * @returns 验证结果\n   */\n  static safeValidate(config: unknown) {\n    return safeValidateRouterConfig(config);\n  }\n\n  /**\n   * 验证路由配置并提供修复建议\n   * \n   * @param config - 要验证的路由配置\n   * @returns 验证结果和修复建议\n   */\n  static validateWithSuggestions(config: unknown): {\n    success: boolean;\n    data?: unknown;\n    errors?: z.ZodIssue[];\n    suggestions?: string[];\n  } {\n    const result = safeValidateRouterConfig(config);\n\n    if (!result.success) {\n      const suggestions: string[] = [];\n\n      result.error.issues.forEach((issue: z.ZodIssue) => {\n        const path = issue.path.join('.');\n\n        // 根据错误类型提供修复建议\n        if (issue.code === 'invalid_type') {\n          const invalidTypeIssue = issue as z.ZodIssue & { expected: string; received: string };\n          suggestions.push(\n            `配置项 \"${path}\" 类型错误: 期望 ${invalidTypeIssue.expected}，实际 ${invalidTypeIssue.received}`\n          );\n        } else if (issue.code === 'too_small') {\n          suggestions.push(\n            `配置项 \"${path}\" 值太小: ${issue.message}`\n          );\n        } else if (issue.code === 'too_big') {\n          suggestions.push(\n            `配置项 \"${path}\" 值太大: ${issue.message}`\n          );\n        } else {\n          suggestions.push(`配置项 \"${path}\": ${issue.message}`);\n        }\n      });\n\n      return {\n        success: false,\n        errors: result.error.issues,\n        suggestions,\n      };\n    }\n\n    return {\n      success: true,\n      data: result.data,\n    };\n  }\n}\n"],"names":["RouterConfigValidator","validate","config","result","safeValidateRouterConfig","success","errorMessages","error","issues","map","issue","path","length","join","message","friendlyMessage","logger","errors","ConfigValidationError","data","safeValidate","validateWithSuggestions","suggestions","forEach","code","invalidTypeIssue","push","expected","received"],"mappings":"AAAA;;;CAGC;;;;+BAUYA;;;eAAAA;;;iCAPyB;uBACf;wBACkB;AAKlC,IAAA,AAAMA,wBAAN,MAAMA;IACX;;;;;;GAMC,GACD,OAAOC,SAASC,MAAe,EAAE;QAC/B,MAAMC,SAASC,IAAAA,gCAAwB,EAACF;QAExC,IAAI,CAACC,OAAOE,OAAO,EAAE;YACnB,YAAY;YACZ,MAAMC,gBAAgBH,OAAOI,KAAK,CAACC,MAAM,CAACC,GAAG,CAAC,CAACC;gBAC7C,MAAMC,OAAOD,MAAMC,IAAI,CAACC,MAAM,GAAG,IAAIF,MAAMC,IAAI,CAACE,IAAI,CAAC,OAAO;gBAC5D,OAAO,CAAC,OAAO,EAAEF,KAAK,GAAG,EAAED,MAAMI,OAAO,EAAE;YAC5C;YAEA,MAAMC,kBAAkB,CAAC,WAAW,EAAET,cAAcO,IAAI,CAAC,OAAO;YAEhEG,aAAM,CAACT,KAAK,CAAC,YAAY;gBACvBU,QAAQd,OAAOI,KAAK,CAACC,MAAM;gBAC3BN;YACF;YAEA,MAAM,IAAIgB,sCAAqB,CAACH,iBAAiBZ,OAAOI,KAAK;QAC/D;QAEA,OAAOJ,OAAOgB,IAAI;IACpB;IAEA;;;;;GAKC,GACD,OAAOC,aAAalB,MAAe,EAAE;QACnC,OAAOE,IAAAA,gCAAwB,EAACF;IAClC;IAEA;;;;;GAKC,GACD,OAAOmB,wBAAwBnB,MAAe,EAK5C;QACA,MAAMC,SAASC,IAAAA,gCAAwB,EAACF;QAExC,IAAI,CAACC,OAAOE,OAAO,EAAE;YACnB,MAAMiB,cAAwB,EAAE;YAEhCnB,OAAOI,KAAK,CAACC,MAAM,CAACe,OAAO,CAAC,CAACb;gBAC3B,MAAMC,OAAOD,MAAMC,IAAI,CAACE,IAAI,CAAC;gBAE7B,eAAe;gBACf,IAAIH,MAAMc,IAAI,KAAK,gBAAgB;oBACjC,MAAMC,mBAAmBf;oBACzBY,YAAYI,IAAI,CACd,CAAC,KAAK,EAAEf,KAAK,WAAW,EAAEc,iBAAiBE,QAAQ,CAAC,IAAI,EAAEF,iBAAiBG,QAAQ,EAAE;gBAEzF,OAAO,IAAIlB,MAAMc,IAAI,KAAK,aAAa;oBACrCF,YAAYI,IAAI,CACd,CAAC,KAAK,EAAEf,KAAK,OAAO,EAAED,MAAMI,OAAO,EAAE;gBAEzC,OAAO,IAAIJ,MAAMc,IAAI,KAAK,WAAW;oBACnCF,YAAYI,IAAI,CACd,CAAC,KAAK,EAAEf,KAAK,OAAO,EAAED,MAAMI,OAAO,EAAE;gBAEzC,OAAO;oBACLQ,YAAYI,IAAI,CAAC,CAAC,KAAK,EAAEf,KAAK,GAAG,EAAED,MAAMI,OAAO,EAAE;gBACpD;YACF;YAEA,OAAO;gBACLT,SAAS;gBACTY,QAAQd,OAAOI,KAAK,CAACC,MAAM;gBAC3Bc;YACF;QACF;QAEA,OAAO;YACLjB,SAAS;YACTc,MAAMhB,OAAOgB,IAAI;QACnB;IACF;AACF"}

package/dist/core/router/validation/RouterConfigValidator.d.ts

@@ -0,0 +1,58 @@
+/**
+ * 路由配置验证器
+ * 使用 Zod 进行配置验证，并提供友好的错误信息
+ */
+import { z } from 'zod';
+/**
+ * 路由配置验证器
+ */
+export declare class RouterConfigValidator {
+    /**
+     * 验证路由配置
+     *
+     * @param config - 要验证的路由配置
+     * @returns 验证后的路由配置
+     * @throws ConfigValidationError 如果配置验证失败
+     */
+    static validate(config: unknown): {
+        enabled?: boolean | "disabled" | undefined;
+        routes?: any[] | z.core.$InferOuterFunctionType<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut> | undefined;
+        mode?: "hash" | "browser" | "memory" | undefined;
+        options?: any;
+        pathResolve?: {
+            basePath?: string | undefined;
+            pathAliases?: Record<string, string> | undefined;
+        } | undefined;
+        transformOptions?: any;
+    };
+    /**
+     * 安全验证路由配置（不抛出异常）
+     *
+     * @param config - 要验证的路由配置
+     * @returns 验证结果
+     */
+    static safeValidate(config: unknown): z.ZodSafeParseResult<{
+        enabled?: boolean | "disabled" | undefined;
+        routes?: any[] | z.core.$InferOuterFunctionType<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut> | undefined;
+        mode?: "hash" | "browser" | "memory" | undefined;
+        options?: any;
+        pathResolve?: {
+            basePath?: string | undefined;
+            pathAliases?: Record<string, string> | undefined;
+        } | undefined;
+        transformOptions?: any;
+    }>;
+    /**
+     * 验证路由配置并提供修复建议
+     *
+     * @param config - 要验证的路由配置
+     * @returns 验证结果和修复建议
+     */
+    static validateWithSuggestions(config: unknown): {
+        success: boolean;
+        data?: unknown;
+        errors?: z.ZodIssue[];
+        suggestions?: string[];
+    };
+}
+//# sourceMappingURL=RouterConfigValidator.d.ts.map

package/dist/core/router/validation/RouterConfigValidator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RouterConfigValidator.d.ts","sourceRoot":"","sources":["../../../../src/core/router/validation/RouterConfigValidator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB;;GAEG;AACH,qBAAa,qBAAqB;IAChC;;;;;;OAMG;IACH,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,OAAO;;;;;;;;;;;IAuB/B;;;;;OAKG;IACH,MAAM,CAAC,YAAY,CAAC,MAAM,EAAE,OAAO;;;;;;;;;;;IAInC;;;;;OAKG;IACH,MAAM,CAAC,uBAAuB,CAAC,MAAM,EAAE,OAAO,GAAG;QAC/C,OAAO,EAAE,OAAO,CAAC;QACjB,IAAI,CAAC,EAAE,OAAO,CAAC;QACf,MAAM,CAAC,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC;QACtB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;KACxB;CAwCF"}

package/dist/core/router/validation/RouterConfigValidator.js

@@ -0,0 +1,77 @@
+/**
+ * 路由配置验证器
+ * 使用 Zod 进行配置验证，并提供友好的错误信息
+ */ import { ConfigValidationError } from "../../config/ConfigValidator";
+import { logger } from "../../../utils";
+import { safeValidateRouterConfig } from "./schema";
+/**
+ * 路由配置验证器
+ */ export class RouterConfigValidator {
+    /**
+   * 验证路由配置
+   * 
+   * @param config - 要验证的路由配置
+   * @returns 验证后的路由配置
+   * @throws ConfigValidationError 如果配置验证失败
+   */ static validate(config) {
+        const result = safeValidateRouterConfig(config);
+        if (!result.success) {
+            // 构建友好的错误信息
+            const errorMessages = result.error.issues.map((issue)=>{
+                const path = issue.path.length > 0 ? issue.path.join('.') : 'root';
+                return `路由配置项 "${path}": ${issue.message}`;
+            });
+            const friendlyMessage = `路由配置验证失败:\n${errorMessages.join('\n')}`;
+            logger.error('路由配置验证失败', {
+                errors: result.error.issues,
+                config
+            });
+            throw new ConfigValidationError(friendlyMessage, result.error);
+        }
+        return result.data;
+    }
+    /**
+   * 安全验证路由配置（不抛出异常）
+   * 
+   * @param config - 要验证的路由配置
+   * @returns 验证结果
+   */ static safeValidate(config) {
+        return safeValidateRouterConfig(config);
+    }
+    /**
+   * 验证路由配置并提供修复建议
+   * 
+   * @param config - 要验证的路由配置
+   * @returns 验证结果和修复建议
+   */ static validateWithSuggestions(config) {
+        const result = safeValidateRouterConfig(config);
+        if (!result.success) {
+            const suggestions = [];
+            result.error.issues.forEach((issue)=>{
+                const path = issue.path.join('.');
+                // 根据错误类型提供修复建议
+                if (issue.code === 'invalid_type') {
+                    const invalidTypeIssue = issue;
+                    suggestions.push(`配置项 "${path}" 类型错误: 期望 ${invalidTypeIssue.expected}，实际 ${invalidTypeIssue.received}`);
+                } else if (issue.code === 'too_small') {
+                    suggestions.push(`配置项 "${path}" 值太小: ${issue.message}`);
+                } else if (issue.code === 'too_big') {
+                    suggestions.push(`配置项 "${path}" 值太大: ${issue.message}`);
+                } else {
+                    suggestions.push(`配置项 "${path}": ${issue.message}`);
+                }
+            });
+            return {
+                success: false,
+                errors: result.error.issues,
+                suggestions
+            };
+        }
+        return {
+            success: true,
+            data: result.data
+        };
+    }
+}
+
+//# sourceMappingURL=RouterConfigValidator.js.map

package/dist/core/router/validation/RouterConfigValidator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/core/router/validation/RouterConfigValidator.ts"],"sourcesContent":["/**\n * 路由配置验证器\n * 使用 Zod 进行配置验证，并提供友好的错误信息\n */\n\nimport { z } from 'zod';\nimport { ConfigValidationError } from '../../config/ConfigValidator';\nimport { logger } from '../../../utils';\nimport { safeValidateRouterConfig } from './schema';\n\n/**\n * 路由配置验证器\n */\nexport class RouterConfigValidator {\n  /**\n   * 验证路由配置\n   * \n   * @param config - 要验证的路由配置\n   * @returns 验证后的路由配置\n   * @throws ConfigValidationError 如果配置验证失败\n   */\n  static validate(config: unknown) {\n    const result = safeValidateRouterConfig(config);\n\n    if (!result.success) {\n      // 构建友好的错误信息\n      const errorMessages = result.error.issues.map((issue: z.ZodIssue) => {\n        const path = issue.path.length > 0 ? issue.path.join('.') : 'root';\n        return `路由配置项 \"${path}\": ${issue.message}`;\n      });\n\n      const friendlyMessage = `路由配置验证失败:\\n${errorMessages.join('\\n')}`;\n\n      logger.error('路由配置验证失败', {\n        errors: result.error.issues,\n        config,\n      });\n\n      throw new ConfigValidationError(friendlyMessage, result.error);\n    }\n\n    return result.data;\n  }\n\n  /**\n   * 安全验证路由配置（不抛出异常）\n   * \n   * @param config - 要验证的路由配置\n   * @returns 验证结果\n   */\n  static safeValidate(config: unknown) {\n    return safeValidateRouterConfig(config);\n  }\n\n  /**\n   * 验证路由配置并提供修复建议\n   * \n   * @param config - 要验证的路由配置\n   * @returns 验证结果和修复建议\n   */\n  static validateWithSuggestions(config: unknown): {\n    success: boolean;\n    data?: unknown;\n    errors?: z.ZodIssue[];\n    suggestions?: string[];\n  } {\n    const result = safeValidateRouterConfig(config);\n\n    if (!result.success) {\n      const suggestions: string[] = [];\n\n      result.error.issues.forEach((issue: z.ZodIssue) => {\n        const path = issue.path.join('.');\n\n        // 根据错误类型提供修复建议\n        if (issue.code === 'invalid_type') {\n          const invalidTypeIssue = issue as z.ZodIssue & { expected: string; received: string };\n          suggestions.push(\n            `配置项 \"${path}\" 类型错误: 期望 ${invalidTypeIssue.expected}，实际 ${invalidTypeIssue.received}`\n          );\n        } else if (issue.code === 'too_small') {\n          suggestions.push(\n            `配置项 \"${path}\" 值太小: ${issue.message}`\n          );\n        } else if (issue.code === 'too_big') {\n          suggestions.push(\n            `配置项 \"${path}\" 值太大: ${issue.message}`\n          );\n        } else {\n          suggestions.push(`配置项 \"${path}\": ${issue.message}`);\n        }\n      });\n\n      return {\n        success: false,\n        errors: result.error.issues,\n        suggestions,\n      };\n    }\n\n    return {\n      success: true,\n      data: result.data,\n    };\n  }\n}\n"],"names":["ConfigValidationError","logger","safeValidateRouterConfig","RouterConfigValidator","validate","config","result","success","errorMessages","error","issues","map","issue","path","length","join","message","friendlyMessage","errors","data","safeValidate","validateWithSuggestions","suggestions","forEach","code","invalidTypeIssue","push","expected","received"],"mappings":"AAAA;;;CAGC,GAGD,SAASA,qBAAqB,QAAQ,+BAA+B;AACrE,SAASC,MAAM,QAAQ,iBAAiB;AACxC,SAASC,wBAAwB,QAAQ,WAAW;AAEpD;;CAEC,GACD,OAAO,MAAMC;IACX;;;;;;GAMC,GACD,OAAOC,SAASC,MAAe,EAAE;QAC/B,MAAMC,SAASJ,yBAAyBG;QAExC,IAAI,CAACC,OAAOC,OAAO,EAAE;YACnB,YAAY;YACZ,MAAMC,gBAAgBF,OAAOG,KAAK,CAACC,MAAM,CAACC,GAAG,CAAC,CAACC;gBAC7C,MAAMC,OAAOD,MAAMC,IAAI,CAACC,MAAM,GAAG,IAAIF,MAAMC,IAAI,CAACE,IAAI,CAAC,OAAO;gBAC5D,OAAO,CAAC,OAAO,EAAEF,KAAK,GAAG,EAAED,MAAMI,OAAO,EAAE;YAC5C;YAEA,MAAMC,kBAAkB,CAAC,WAAW,EAAET,cAAcO,IAAI,CAAC,OAAO;YAEhEd,OAAOQ,KAAK,CAAC,YAAY;gBACvBS,QAAQZ,OAAOG,KAAK,CAACC,MAAM;gBAC3BL;YACF;YAEA,MAAM,IAAIL,sBAAsBiB,iBAAiBX,OAAOG,KAAK;QAC/D;QAEA,OAAOH,OAAOa,IAAI;IACpB;IAEA;;;;;GAKC,GACD,OAAOC,aAAaf,MAAe,EAAE;QACnC,OAAOH,yBAAyBG;IAClC;IAEA;;;;;GAKC,GACD,OAAOgB,wBAAwBhB,MAAe,EAK5C;QACA,MAAMC,SAASJ,yBAAyBG;QAExC,IAAI,CAACC,OAAOC,OAAO,EAAE;YACnB,MAAMe,cAAwB,EAAE;YAEhChB,OAAOG,KAAK,CAACC,MAAM,CAACa,OAAO,CAAC,CAACX;gBAC3B,MAAMC,OAAOD,MAAMC,IAAI,CAACE,IAAI,CAAC;gBAE7B,eAAe;gBACf,IAAIH,MAAMY,IAAI,KAAK,gBAAgB;oBACjC,MAAMC,mBAAmBb;oBACzBU,YAAYI,IAAI,CACd,CAAC,KAAK,EAAEb,KAAK,WAAW,EAAEY,iBAAiBE,QAAQ,CAAC,IAAI,EAAEF,iBAAiBG,QAAQ,EAAE;gBAEzF,OAAO,IAAIhB,MAAMY,IAAI,KAAK,aAAa;oBACrCF,YAAYI,IAAI,CACd,CAAC,KAAK,EAAEb,KAAK,OAAO,EAAED,MAAMI,OAAO,EAAE;gBAEzC,OAAO,IAAIJ,MAAMY,IAAI,KAAK,WAAW;oBACnCF,YAAYI,IAAI,CACd,CAAC,KAAK,EAAEb,KAAK,OAAO,EAAED,MAAMI,OAAO,EAAE;gBAEzC,OAAO;oBACLM,YAAYI,IAAI,CAAC,CAAC,KAAK,EAAEb,KAAK,GAAG,EAAED,MAAMI,OAAO,EAAE;gBACpD;YACF;YAEA,OAAO;gBACLT,SAAS;gBACTW,QAAQZ,OAAOG,KAAK,CAACC,MAAM;gBAC3BY;YACF;QACF;QAEA,OAAO;YACLf,SAAS;YACTY,MAAMb,OAAOa,IAAI;QACnB;IACF;AACF"}

package/dist/core/router/validation/index.cjs

@@ -0,0 +1,23 @@
+/**
+ * 路由配置验证模块入口
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./schema"), exports);
+_export_star(require("./RouterConfigValidator"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+
+//# sourceMappingURL=index.js.map

package/dist/core/router/validation/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/core/router/validation/index.ts"],"sourcesContent":["/**\n * 路由配置验证模块入口\n */\n\nexport * from './schema';\nexport * from './RouterConfigValidator';\n"],"names":[],"mappings":"AAAA;;CAEC;;;;qBAEa;qBACA"}

package/dist/core/router/validation/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 路由配置验证模块入口
+ */
+export * from './schema';
+export * from './RouterConfigValidator';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/router/validation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/core/router/validation/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,UAAU,CAAC;AACzB,cAAc,yBAAyB,CAAC"}

package/dist/core/router/validation/index.js

@@ -0,0 +1,6 @@
+/**
+ * 路由配置验证模块入口
+ */ export * from "./schema";
+export * from "./RouterConfigValidator";
+
+//# sourceMappingURL=index.js.map

package/dist/core/router/validation/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/core/router/validation/index.ts"],"sourcesContent":["/**\n * 路由配置验证模块入口\n */\n\nexport * from './schema';\nexport * from './RouterConfigValidator';\n"],"names":[],"mappings":"AAAA;;CAEC,GAED,cAAc,WAAW;AACzB,cAAc,0BAA0B"}

package/dist/core/router/validation/schema.cjs

@@ -0,0 +1,91 @@
+/**
+ * 路由配置验证 Schema（使用 Zod）
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get componentImportSchema () {
+        return componentImportSchema;
+    },
+    get routeConfigSchema () {
+        return routeConfigSchema;
+    },
+    get routeItemHandleSchema () {
+        return routeItemHandleSchema;
+    },
+    get routerConfigSchema () {
+        return routerConfigSchema;
+    },
+    get safeValidateRouterConfig () {
+        return safeValidateRouterConfig;
+    },
+    get validateRouterConfig () {
+        return validateRouterConfig;
+    }
+});
+const _zod = require("zod");
+const routeItemHandleSchema = _zod.z.object({
+    title: _zod.z.string().min(1, '路由标题不能为空'),
+    i18nKey: _zod.z.string().optional(),
+    order: _zod.z.number().int('排序值必须是整数'),
+    icon: _zod.z.string().optional(),
+    hideInMenu: _zod.z.boolean().optional(),
+    hideFooter: _zod.z.boolean().optional(),
+    keepAlive: _zod.z.boolean().optional(),
+    needLogin: _zod.z.boolean().optional(),
+    roles: _zod.z.array(_zod.z.string()).optional(),
+    name: _zod.z.string().optional()
+}).passthrough(); // 允许其他自定义字段
+const componentImportSchema = _zod.z.union([
+    _zod.z.string().min(1, '组件路径不能为空'),
+    _zod.z.function(),
+    _zod.z.null()
+]);
+const routeConfigSchema = _zod.z.lazy(()=>_zod.z.object({
+        layout: componentImportSchema.optional().nullable(),
+        page: componentImportSchema.optional().nullable(),
+        loading: componentImportSchema.optional().nullable(),
+        errors: componentImportSchema.optional().nullable(),
+        name: _zod.z.string().min(1, '路由名称不能为空'),
+        path: _zod.z.string().optional(),
+        isGroup: _zod.z.boolean().optional(),
+        enableRedirection: _zod.z.boolean().optional(),
+        handle: routeItemHandleSchema,
+        children: _zod.z.array(routeConfigSchema).optional()
+    }));
+const routerConfigSchema = _zod.z.object({
+    enabled: _zod.z.union([
+        _zod.z.boolean(),
+        _zod.z.literal('disabled')
+    ]).optional(),
+    routes: _zod.z.union([
+        _zod.z.array(routeConfigSchema),
+        _zod.z.function()
+    ]).optional(),
+    mode: _zod.z.enum([
+        'browser',
+        'hash',
+        'memory'
+    ]).optional(),
+    options: _zod.z.any().optional(),
+    pathResolve: _zod.z.object({
+        basePath: _zod.z.string().optional(),
+        pathAliases: _zod.z.record(_zod.z.string(), _zod.z.string()).optional()
+    }).optional(),
+    transformOptions: _zod.z.any().optional()
+});
+function validateRouterConfig(config) {
+    return routerConfigSchema.parse(config);
+}
+function safeValidateRouterConfig(config) {
+    return routerConfigSchema.safeParse(config);
+}
+
+//# sourceMappingURL=schema.js.map

package/dist/core/router/validation/schema.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/core/router/validation/schema.ts"],"sourcesContent":["/**\n * 路由配置验证 Schema（使用 Zod）\n */\n\nimport { z } from 'zod';\n\n/**\n * RouteItemHandle Schema\n */\nexport const routeItemHandleSchema = z.object({\n  title: z.string().min(1, '路由标题不能为空'),\n  i18nKey: z.string().optional(),\n  order: z.number().int('排序值必须是整数'),\n  icon: z.string().optional(),\n  hideInMenu: z.boolean().optional(),\n  hideFooter: z.boolean().optional(),\n  keepAlive: z.boolean().optional(),\n  needLogin: z.boolean().optional(),\n  roles: z.array(z.string()).optional(),\n  name: z.string().optional(),\n}).passthrough(); // 允许其他自定义字段\n\n/**\n * ComponentImport Schema\n * 可以是字符串路径或函数\n */\nexport const componentImportSchema = z.union([\n  z.string().min(1, '组件路径不能为空'),\n  z.function(),\n  z.null(),\n]);\n\n/**\n * RouteConfig Schema\n */\nexport const routeConfigSchema: z.ZodType<any> = z.lazy(() =>\n  z.object({\n    layout: componentImportSchema.optional().nullable(),\n    page: componentImportSchema.optional().nullable(),\n    loading: componentImportSchema.optional().nullable(),\n    errors: componentImportSchema.optional().nullable(),\n    name: z.string().min(1, '路由名称不能为空'),\n    path: z.string().optional(),\n    isGroup: z.boolean().optional(),\n    enableRedirection: z.boolean().optional(),\n    handle: routeItemHandleSchema,\n    children: z.array(routeConfigSchema).optional(),\n  })\n);\n\n/**\n * RouterConfig Schema\n */\nexport const routerConfigSchema = z.object({\n  enabled: z.union([z.boolean(), z.literal('disabled')]).optional(),\n  routes: z\n    .union([\n      z.array(routeConfigSchema),\n      z.function(),\n    ])\n    .optional(),\n  mode: z.enum(['browser', 'hash', 'memory']).optional(),\n  options: z.any().optional(), // react-router-dom 的选项类型较复杂，使用 any\n  pathResolve: z\n    .object({\n      basePath: z.string().optional(),\n      pathAliases: z.record(z.string(), z.string()).optional(),\n    })\n    .optional(),\n  transformOptions: z.any().optional(), // TransformOptions 类型较复杂，使用 any\n});\n\n/**\n * 验证路由配置\n * \n * @param config - 要验证的路由配置\n * @returns 验证后的路由配置\n * @throws z.ZodError 如果配置验证失败\n */\nexport function validateRouterConfig(config: unknown) {\n  return routerConfigSchema.parse(config);\n}\n\n/**\n * 安全验证路由配置（不抛出异常）\n * \n * @param config - 要验证的路由配置\n * @returns 验证结果\n */\nexport function safeValidateRouterConfig(config: unknown) {\n  return routerConfigSchema.safeParse(config);\n}\n"],"names":["componentImportSchema","routeConfigSchema","routeItemHandleSchema","routerConfigSchema","safeValidateRouterConfig","validateRouterConfig","z","object","title","string","min","i18nKey","optional","order","number","int","icon","hideInMenu","boolean","hideFooter","keepAlive","needLogin","roles","array","name","passthrough","union","function","null","lazy","layout","nullable","page","loading","errors","path","isGroup","enableRedirection","handle","children","enabled","literal","routes","mode","enum","options","any","pathResolve","basePath","pathAliases","record","transformOptions","config","parse","safeParse"],"mappings":"AAAA;;CAEC;;;;;;;;;;;QAwBYA;eAAAA;;QASAC;eAAAA;;QA1BAC;eAAAA;;QA4CAC;eAAAA;;QAoCGC;eAAAA;;QAVAC;eAAAA;;;qBA3EE;AAKX,MAAMH,wBAAwBI,MAAC,CAACC,MAAM,CAAC;IAC5CC,OAAOF,MAAC,CAACG,MAAM,GAAGC,GAAG,CAAC,GAAG;IACzBC,SAASL,MAAC,CAACG,MAAM,GAAGG,QAAQ;IAC5BC,OAAOP,MAAC,CAACQ,MAAM,GAAGC,GAAG,CAAC;IACtBC,MAAMV,MAAC,CAACG,MAAM,GAAGG,QAAQ;IACzBK,YAAYX,MAAC,CAACY,OAAO,GAAGN,QAAQ;IAChCO,YAAYb,MAAC,CAACY,OAAO,GAAGN,QAAQ;IAChCQ,WAAWd,MAAC,CAACY,OAAO,GAAGN,QAAQ;IAC/BS,WAAWf,MAAC,CAACY,OAAO,GAAGN,QAAQ;IAC/BU,OAAOhB,MAAC,CAACiB,KAAK,CAACjB,MAAC,CAACG,MAAM,IAAIG,QAAQ;IACnCY,MAAMlB,MAAC,CAACG,MAAM,GAAGG,QAAQ;AAC3B,GAAGa,WAAW,IAAI,YAAY;AAMvB,MAAMzB,wBAAwBM,MAAC,CAACoB,KAAK,CAAC;IAC3CpB,MAAC,CAACG,MAAM,GAAGC,GAAG,CAAC,GAAG;IAClBJ,MAAC,CAACqB,QAAQ;IACVrB,MAAC,CAACsB,IAAI;CACP;AAKM,MAAM3B,oBAAoCK,MAAC,CAACuB,IAAI,CAAC,IACtDvB,MAAC,CAACC,MAAM,CAAC;QACPuB,QAAQ9B,sBAAsBY,QAAQ,GAAGmB,QAAQ;QACjDC,MAAMhC,sBAAsBY,QAAQ,GAAGmB,QAAQ;QAC/CE,SAASjC,sBAAsBY,QAAQ,GAAGmB,QAAQ;QAClDG,QAAQlC,sBAAsBY,QAAQ,GAAGmB,QAAQ;QACjDP,MAAMlB,MAAC,CAACG,MAAM,GAAGC,GAAG,CAAC,GAAG;QACxByB,MAAM7B,MAAC,CAACG,MAAM,GAAGG,QAAQ;QACzBwB,SAAS9B,MAAC,CAACY,OAAO,GAAGN,QAAQ;QAC7ByB,mBAAmB/B,MAAC,CAACY,OAAO,GAAGN,QAAQ;QACvC0B,QAAQpC;QACRqC,UAAUjC,MAAC,CAACiB,KAAK,CAACtB,mBAAmBW,QAAQ;IAC/C;AAMK,MAAMT,qBAAqBG,MAAC,CAACC,MAAM,CAAC;IACzCiC,SAASlC,MAAC,CAACoB,KAAK,CAAC;QAACpB,MAAC,CAACY,OAAO;QAAIZ,MAAC,CAACmC,OAAO,CAAC;KAAY,EAAE7B,QAAQ;IAC/D8B,QAAQpC,MAAC,CACNoB,KAAK,CAAC;QACLpB,MAAC,CAACiB,KAAK,CAACtB;QACRK,MAAC,CAACqB,QAAQ;KACX,EACAf,QAAQ;IACX+B,MAAMrC,MAAC,CAACsC,IAAI,CAAC;QAAC;QAAW;QAAQ;KAAS,EAAEhC,QAAQ;IACpDiC,SAASvC,MAAC,CAACwC,GAAG,GAAGlC,QAAQ;IACzBmC,aAAazC,MAAC,CACXC,MAAM,CAAC;QACNyC,UAAU1C,MAAC,CAACG,MAAM,GAAGG,QAAQ;QAC7BqC,aAAa3C,MAAC,CAAC4C,MAAM,CAAC5C,MAAC,CAACG,MAAM,IAAIH,MAAC,CAACG,MAAM,IAAIG,QAAQ;IACxD,GACCA,QAAQ;IACXuC,kBAAkB7C,MAAC,CAACwC,GAAG,GAAGlC,QAAQ;AACpC;AASO,SAASP,qBAAqB+C,MAAe;IAClD,OAAOjD,mBAAmBkD,KAAK,CAACD;AAClC;AAQO,SAAShD,yBAAyBgD,MAAe;IACtD,OAAOjD,mBAAmBmD,SAAS,CAACF;AACtC"}

package/dist/core/router/validation/schema.d.ts

@@ -0,0 +1,82 @@
+/**
+ * 路由配置验证 Schema（使用 Zod）
+ */
+import { z } from 'zod';
+/**
+ * RouteItemHandle Schema
+ */
+export declare const routeItemHandleSchema: z.ZodObject<{
+    title: z.ZodString;
+    i18nKey: z.ZodOptional<z.ZodString>;
+    order: z.ZodNumber;
+    icon: z.ZodOptional<z.ZodString>;
+    hideInMenu: z.ZodOptional<z.ZodBoolean>;
+    hideFooter: z.ZodOptional<z.ZodBoolean>;
+    keepAlive: z.ZodOptional<z.ZodBoolean>;
+    needLogin: z.ZodOptional<z.ZodBoolean>;
+    roles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+/**
+ * ComponentImport Schema
+ * 可以是字符串路径或函数
+ */
+export declare const componentImportSchema: z.ZodUnion<readonly [z.ZodString, z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>, z.ZodNull]>;
+/**
+ * RouteConfig Schema
+ */
+export declare const routeConfigSchema: z.ZodType<any>;
+/**
+ * RouterConfig Schema
+ */
+export declare const routerConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"disabled">]>>;
+    routes: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>>, z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>]>>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        hash: "hash";
+        browser: "browser";
+        memory: "memory";
+    }>>;
+    options: z.ZodOptional<z.ZodAny>;
+    pathResolve: z.ZodOptional<z.ZodObject<{
+        basePath: z.ZodOptional<z.ZodString>;
+        pathAliases: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>>;
+    transformOptions: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>;
+/**
+ * 验证路由配置
+ *
+ * @param config - 要验证的路由配置
+ * @returns 验证后的路由配置
+ * @throws z.ZodError 如果配置验证失败
+ */
+export declare function validateRouterConfig(config: unknown): {
+    enabled?: boolean | "disabled" | undefined;
+    routes?: any[] | z.core.$InferOuterFunctionType<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut> | undefined;
+    mode?: "hash" | "browser" | "memory" | undefined;
+    options?: any;
+    pathResolve?: {
+        basePath?: string | undefined;
+        pathAliases?: Record<string, string> | undefined;
+    } | undefined;
+    transformOptions?: any;
+};
+/**
+ * 安全验证路由配置（不抛出异常）
+ *
+ * @param config - 要验证的路由配置
+ * @returns 验证结果
+ */
+export declare function safeValidateRouterConfig(config: unknown): z.ZodSafeParseResult<{
+    enabled?: boolean | "disabled" | undefined;
+    routes?: any[] | z.core.$InferOuterFunctionType<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut> | undefined;
+    mode?: "hash" | "browser" | "memory" | undefined;
+    options?: any;
+    pathResolve?: {
+        basePath?: string | undefined;
+        pathAliases?: Record<string, string> | undefined;
+    } | undefined;
+    transformOptions?: any;
+}>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/core/router/validation/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/core/router/validation/schema.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;iBAWlB,CAAC;AAEjB;;;GAGG;AACH,eAAO,MAAM,qBAAqB,+GAIhC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAa5C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;iBAiB7B,CAAC;AAEH;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO;;;;;;;;;;EAEnD;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,OAAO;;;;;;;;;;GAEvD"}