mxcad-app 1.0.33 → 1.0.35

package/dist/index.d.ts

@@ -220,28 +220,22 @@ declare module '@howdyjs/to-drag' {
 }
 
 
-declare module '@tiptap/core' {
+declare module "@tiptap/core" {
     interface Commands<ReturnType> {
-        Strike: {
-            /**
-             * Set the font size attribute
-             */
-            setStrike: () => ReturnType;
-            /**
-             * Unset the font size attribute
-             */
-            unsetStrike: () => ReturnType;
-            toggleStrike: () => ReturnType;
+        selectedText: {
+            setSelectedText: (from: number, to: number) => ReturnType;
+            unsetSelectedText: (from: number, to: number) => ReturnType;
         };
     }
 }
 
 
-declare module "@tiptap/core" {
+declare module '@tiptap/core' {
     interface Commands<ReturnType> {
-        selectedText: {
-            setSelectedText: (from: number, to: number) => ReturnType;
-            unsetSelectedText: (from: number, to: number) => ReturnType;
+        Underline: {
+            setUnderline: () => ReturnType;
+            unsetUnderline: () => ReturnType;
+            toggleUnderline: () => ReturnType;
         };
     }
 }
@@ -249,15 +243,16 @@ declare module "@tiptap/core" {
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
-        fontSize: {
+        Strike: {
             /**
              * Set the font size attribute
              */
-            setFontSize: (size: string) => ReturnType;
+            setStrike: () => ReturnType;
             /**
              * Unset the font size attribute
              */
-            unsetFontSize: () => ReturnType;
+            unsetStrike: () => ReturnType;
+            toggleStrike: () => ReturnType;
         };
     }
 }
@@ -265,15 +260,16 @@ declare module '@tiptap/core' {
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
-        TextDecoration: {
+        Overline: {
             /**
              * Set the font size attribute
              */
-            setTextDecoration: (textDecoration: string) => ReturnType;
+            setOverline: () => ReturnType;
             /**
              * Unset the font size attribute
              */
-            unsetTextDecoration: () => ReturnType;
+            unsetOverline: () => ReturnType;
+            toggleOverline: () => ReturnType;
         };
     }
 }
@@ -281,10 +277,15 @@ declare module '@tiptap/core' {
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
-        Underline: {
-            setUnderline: () => ReturnType;
-            unsetUnderline: () => ReturnType;
-            toggleUnderline: () => ReturnType;
+        fontSize: {
+            /**
+             * Set the font size attribute
+             */
+            setFontSize: (size: string) => ReturnType;
+            /**
+             * Unset the font size attribute
+             */
+            unsetFontSize: () => ReturnType;
         };
     }
 }
@@ -292,16 +293,15 @@ declare module '@tiptap/core' {
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
-        Overline: {
+        TextDecoration: {
             /**
              * Set the font size attribute
              */
-            setOverline: () => ReturnType;
+            setTextDecoration: (textDecoration: string) => ReturnType;
             /**
              * Unset the font size attribute
              */
-            unsetOverline: () => ReturnType;
-            toggleOverline: () => ReturnType;
+            unsetTextDecoration: () => ReturnType;
         };
     }
 }

package/dist/index.js

@@ -1,4 +1,4 @@
-import { c4 as e, c3 as p, c5 as s } from "./chunks/lib.js";
+import { c5 as e, c4 as p, c6 as s } from "./chunks/lib.js";
 export {
   e as MxCADView,
   p as default,

package/dist/mxcad.d.ts

@@ -1506,6 +1506,20 @@ declare module "mxcad" {
   	 * ```
   	 */
   	setData(row: number, col: number, val: number): void;
+  	/**
+  	 * 返回矩阵的所有定义数据。
+  	 * @example
+  	 * ```ts
+  	 * ```
+  	 */
+  	getDatas(): string;
+  	/**
+     * 返回THREE.Matrix4
+     * @example
+     * ```ts
+     * ```
+     */
+  	toMatrix4(): THREE.Matrix4;
   }
   /**
    * 整数数组
@@ -2748,11 +2762,16 @@ declare module "mxcad" {
   	 * const ret = await MxCADUtility.getCorner("测试");
   	 * if (!ret) return;
   	 * console.log(ret.pt1, ret.pt2)
+  	 * pt4----pt2
+  	 * |       |
+  	 * pt1----pt3
   	 * ```
   	 *  */
   	getCorner(strPrompt?: string, pt1?: McGePoint3d, detailedResult?: (retcode: DetailedResult) => any, drawSelectCroner?: boolean, isDisableAllTrace?: boolean, init?: (getPoint: MxCADUiPrPoint) => any): Promise<{
   		pt1: McGePoint3d;
   		pt2: McGePoint3d;
+  		pt3: McGePoint3d;
+  		pt4: McGePoint3d;
   	} | null>;
   	/** 获取多个实体形成的包围盒
   	 * @param aryId 实体对象ID数组
@@ -3700,6 +3719,61 @@ declare module "mxcad" {
   	 */
   	setUseBasePt(useIt: boolean): void;
   }
+  /**
+   * 带坐标变换的取点类
+   * @example
+   * ```ts
+   * ```
+   */
+  export  class MxCADUiPrPointTransform extends MxCADUiPrPoint {
+  	mat: McGeMatrix3d;
+  	rmat: McGeMatrix3d;
+  	mat_three: THREE.Matrix4;
+  	rmat_three: THREE.Matrix4;
+  	constructor(mat: McGeMatrix3d);
+  	/**
+  	* 运行go方法, 将返回用户交互的Promise任务
+  	* @returns 返回一个promise对象，包含了用户点击页面得到的坐标点
+  	* @description
+  	* @example
+  	* ```ts
+  	* ```
+  	*/
+  	go(): Promise<McGePoint3d | null>;
+  	/**
+  	 * 得以获取的点
+  	 * @returns 点坐标
+  	 * @example
+  	 * ```ts
+  	 * ```
+  	 */
+  	value(retcad_val?: boolean): McGePoint3d;
+  	/**
+  	 * 得到动态拖动的基点
+  	 * @returns 基点 McGePoint3d
+  	 * @example
+  	 * ```ts
+  	 * import { MxCADUiPrPoint } from "mxcad"
+  	 * ```
+  	 */
+  	basePt(retcad_val?: boolean): McGePoint3d;
+  	/**
+  	 * 设置动态拖动的基点
+  	 * @param basePt 基点 McGePoint3d
+  	 * @example
+  	 * ```ts
+  	 * ```
+  	 */
+  	setBasePt(basePt: McGePoint3d, cad_val?: boolean): void;
+  	/**
+  	* 设置动态绘制
+  	* @param basePt 基点 McGePoint3d
+  	* @example
+  	* ```ts
+  	* ```
+  	*/
+  	setUserDraw(pDraw: ((currentPoint: McGePoint3d, pWorldDraw: McEdGetPointWorldDrawObject) => void)): void;
+  }
   /** UI交互获取距离
    * @description 根据两个点确定一段距离
    * @example
@@ -4041,7 +4115,7 @@ declare module "mxcad" {
   	 * const getEnt = new MxCADUiPrEntity();
   	 * ```
   	 */
-  	constructor();
+  	constructor(isDisableAllTrace?: boolean);
   	/**
   	 * 设置或获取过滤器
   	 * @param filter 过滤器
@@ -11604,6 +11678,14 @@ declare module "mxcad" {
   	 * ```
   	 */
   	getMxDrawObject(): MxDrawObject;
+  	/**
+  	 * 返回与MxCAD当前视区旋转矩阵
+  	 * @returns McGeMatrix3d对象
+  	 * @example
+  	 * ```ts
+  	 * ```
+  	 */
+  	getMxCADViewSpinMatrix(): McGeMatrix3d;
   	/**
   	 * 返回与MxCAD对象绑定的MxDraw对象。
   	 * @returns MxDraw对象
@@ -11616,6 +11698,10 @@ declare module "mxcad" {
   	 * ```
   	 */
   	get mxdraw(): MxDrawObject;
+  	/**
+  	 * 把mxcad设置当前的cad对象
+  	 */
+  	makeCurrent(): void;
   	/**
   	 * 获取内部实现对象
   	 * @returns 内部实现对象
@@ -13492,6 +13578,24 @@ declare module "mxcad" {
   	 * ```
   	 */
   	getCurrentMxCAD(): McObject;
+  	/**
+  	 * 返回当前活动的CAD对象
+  	 * @example
+  	 * ```ts
+  	 * import { MxCpp } from "mxcad";
+  	 * const mxcad = MxCpp.getCurrentMxCAD();
+  	 * ```
+  	 */
+  	get mxcad(): McObject;
+  	/**
+  	* 返回当前活动的CAD对象的数据库对象.
+  	* @example
+  	* ```ts
+  	* import { MxCpp } from "mxcad";
+  	* const dataBase = MxCpp.getCurrentDatabase();
+  	* ```
+  	*/
+  	get currentDatabase(): McDbDatabase;
   	/**
   	 * 返回当前活动的CAD对象的数据库对象.
   	 * @example

package/dist/mxdraw.d.ts

@@ -497,7 +497,7 @@ declare module "mxdraw" {
        * ```
        *
        */
-      drawSolid(points: THREE.Vector3[]): void;
+      drawSolid(points: THREE.Vector3[], depthTest?: boolean): void;
       /**
        *把一个对象的绘图属性设置到当前绘图上下文
        * @returns
@@ -3434,6 +3434,14 @@ declare module "mxdraw" {
       [x: string]: any;
       private _McEdGetPointWorldDraw;
       constructor();
+      /**
+       * 设置一个变换矩阵
+       * @example
+       * ``` typescript
+       * ```
+       *
+       */
+      initMat(_matCAD: any, _matThree: THREE.Matrix4): void;
       /**
        * 绘制圆
        * @param cen 圆心位置
@@ -5088,6 +5096,7 @@ declare module "mxdraw" {
    */
    class MxDbHatch extends MxDbEntity {
       points: THREE.Vector3[];
+      depthTest: boolean;
       worldDraw(pWorldDraw: McGiWorldDraw): void;
       getTypeName(): string;
       moveGripPointsAt(index: number, offset: THREE.Vector3): boolean;

package/packToolPlugin/api-map.json.d.ts

@@ -119,6 +119,7 @@ declare const _default: {
     "MxCADUiPrInt",
     "MxCADUiPrKeyWord",
     "MxCADUiPrPoint",
+    "MxCADUiPrPointTransform",
     "MxCADUiPrString",
     "MxCADUtility",
     "MxCADUtilityClass",

package/packToolPlugin/{index-Da3ocqZH.mjs → index-C-cFEcIk.mjs}

@@ -122,6 +122,7 @@ const mxcad = [
   "MxCADUiPrInt",
   "MxCADUiPrKeyWord",
   "MxCADUiPrPoint",
+  "MxCADUiPrPointTransform",
   "MxCADUiPrString",
   "MxCADUtility",
   "MxCADUtilityClass",
@@ -1510,4 +1511,4 @@ export {
   getContentType as h,
   resolveOptions as r
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index-Da3ocqZH.mjs","sources":["../../packToolPluginSrc/shared/index.ts"],"sourcesContent":["\r\n// plugins/shared/index.ts\r\nimport { basename, join, relative, resolve } from 'path';\r\nimport fs, { NoParamCallback } from 'fs';\r\nimport { fileURLToPath } from 'url';\r\nimport { name } from \"../../lib/package.json\"\r\n\r\nimport { MxQuickCommand } from \"./types/mxQuickCommand.d\"\r\nimport { MxServerConfig } from \"./types/mxServerConfig.d\"\r\nimport { MxSketchesAndNotesUiConfig } from \"./types/mxSketchesAndNotesUiConfig.d\"\r\nimport { MxUiConfig } from \"./types/mxUiConfig.d\"\r\nimport { MxcadUiConfig } from \"./types/mxcadUiConfig.d\"\r\nimport { VuetifyThemeConfig } from \"./types/vuetifyThemeConfig.d\"\r\nimport apiMap from '../api-map.json'\r\nexport const getApiMap = () => apiMap\r\nexport interface MxPluginConfig {\r\n  plugins: (string | {\r\n    name?: string,\r\n    isAfterLoad?: boolean,\r\n    dir?: boolean,\r\n    version?: string\r\n  })[]\r\n}\r\n// === 新增：配置文件名常量 ===\r\nexport const CONFIG_FILENAMES = [\r\n  // 'mxcadUiConfig.json',\r\n  'mxQuickCommand.json',\r\n  'mxServerConfig.json',\r\n  'mxSketchesAndNotesUiConfig.json',\r\n  'mxUiConfig.json',\r\n  'vuetifyThemeConfig.json',\r\n  // 'plugins/config.json'\r\n] as const;\r\n/**\r\n * 配置文件处理器\r\n * 可选：对特定配置文件进行运行时修改\r\n * 函数接收原始 JSON 数据，返回修改后的 JSON 数据（可异步）\r\n */\r\nexport interface TransformFunctions {\r\n  // transformMxcadUiConfig(data: MxcadUiConfig): Promise<MxcadUiConfig> | MxcadUiConfig;\r\n  transformMxQuickCommand(data: MxQuickCommand): Promise<MxQuickCommand> | MxQuickCommand;\r\n  transformMxServerConfig(data: MxServerConfig): Promise<MxServerConfig> | MxServerConfig;\r\n  transformMxSketchesAndNotesUiConfig(data: MxSketchesAndNotesUiConfig): Promise<MxSketchesAndNotesUiConfig> | MxSketchesAndNotesUiConfig;\r\n  transformMxUiConfig(data: MxUiConfig): Promise<MxUiConfig> | MxUiConfig;\r\n  transformVuetifyThemeConfig(data: VuetifyThemeConfig): Promise<VuetifyThemeConfig> | VuetifyThemeConfig;\r\n  // transformMxPluginsConfig(data: MxPluginConfig[]): Promise<MxPluginConfig[]> | MxPluginConfig[];\r\n}\r\n// 扩展插件选项接口 ===\r\nexport interface MxCadAssetsPluginOptions extends Partial<TransformFunctions> {\r\n  /**\r\n   * 构建后，mxcadAppAssets 资源存放的子目录名。\r\n   * @default 'mxcadAppAssets'\r\n   */\r\n  outputDir?: string;\r\n  /** 第三方依赖*/\r\n  libraryNames?: (keyof typeof externals)[];\r\n  /** 是否单线程加载wasm (默认使用多线程及加载) */\r\n  isWasmSt?: boolean;\r\n   /**\r\n   * 是否启用预压缩资源（如 .gz 文件）的拷贝 默认是true\r\n   * 设置为 false 时，.gz 压缩文件将不会被复制到输出目录\r\n   * @default true\r\n   */\r\n  enableCompressedAssets?: boolean;\r\n}\r\n\r\n\r\n// === 增强：resolveOptions 默认值 ===\r\nexport function resolveOptions(options: MxCadAssetsPluginOptions = {}): Required<MxCadAssetsPluginOptions> {\r\n  const resolved: Required<MxCadAssetsPluginOptions> = {\r\n    outputDir: options.outputDir || 'mxcadAppAssets',\r\n    libraryNames: options.libraryNames || [],\r\n    isWasmSt: options.isWasmSt || false,\r\n    enableCompressedAssets: options.enableCompressedAssets || true,\r\n    // transformMxcadUiConfig: options.transformMxcadUiConfig || ((d) => d),\r\n    transformMxQuickCommand: options.transformMxQuickCommand || ((d) => d),\r\n    transformMxServerConfig: options.transformMxServerConfig || ((d) => d),\r\n    transformMxSketchesAndNotesUiConfig: options.transformMxSketchesAndNotesUiConfig || ((d) => d),\r\n    transformMxUiConfig: options.transformMxUiConfig || ((d) => d),\r\n    transformVuetifyThemeConfig: options.transformVuetifyThemeConfig || ((d) => d),\r\n    // transformMxPluginsConfig: options.transformMxPluginsConfig || ((d) => d),\r\n  };\r\n  return resolved;\r\n}\r\n\r\n\r\nexport interface ParsedPathResult {\r\n  success: boolean;\r\n  filePath?: string;         // 已 resolve 的安全文件路径\r\n  urlPath?: string;          // 解码后的 URL 路径（不含 query）\r\n  fileName?: string;         // 文件名（basename）\r\n  statusCode?: number;\r\n  message?: string;\r\n}\r\n\r\n\r\n/**\r\n * 安全解析并验证请求路径\r\n * @param reqUrl 请求的 URL（如 '/assets/mxServerConfig.json?v=1'）\r\n * @param root 本地根目录（如 'D:/project/dist/mxcad'）\r\n * @param basePath 可选的基础路径前缀（如 '/mxcad/'，用于 Vite）\r\n * @returns 解析结果或错误\r\n */\r\nexport function resolveSafePath(\r\n  reqUrl: string,\r\n  root: string,\r\n  basePath?: string\r\n): ParsedPathResult {\r\n  // 1. 基本校验\r\n  if (!reqUrl || typeof reqUrl !== 'string') {\r\n    return { success: false, statusCode: 400, message: 'Bad Request' };\r\n  }\r\n\r\n  // 2. 提取路径（去 query 和 hash）\r\n  let urlPath = reqUrl.split('?')[0].split('#')[0];\r\n\r\n  // 3. 解码 URL\r\n  let decodedPath: string;\r\n  try {\r\n    decodedPath = decodeURIComponent(urlPath);\r\n    // 防止 null 字节攻击\r\n    if (decodedPath.includes('\\0')) {\r\n      return { success: false, statusCode: 400, message: 'Invalid URL' };\r\n    }\r\n  } catch (err) {\r\n    return { success: false, statusCode: 400, message: 'Invalid URL encoding' };\r\n  }\r\n\r\n  // 4. 处理 basePath（如 Vite 的 base）\r\n  if (basePath && decodedPath.startsWith(basePath)) {\r\n    decodedPath = decodedPath.slice(basePath.length);\r\n  }\r\n\r\n  // 5. 清理路径：去除开头多余的 /\r\n  // 例如：//assets/file.json -> assets/file.json\r\n  const cleanedPath = decodedPath.replace(/^\\/+/, '');\r\n\r\n  // 6. 拼接文件路径\r\n  const filePath = join(root, cleanedPath || '.');\r\n\r\n  // 7. 安全检查：防止路径穿越\r\n  let normalizedFile: string;\r\n  let normalizedRoot: string;\r\n  try {\r\n    normalizedFile = resolve(filePath);\r\n    normalizedRoot = resolve(root);\r\n  } catch (err) {\r\n    return { success: false, statusCode: 500, message: 'Path resolution failed' };\r\n  }\r\n\r\n  // ✅ 关键：确保 normalizedFile 在 normalizedRoot 目录下\r\n  const normalizedFileStr = normalizedFile.replace(/\\\\/g, '/') + '/';\r\n  const normalizedRootStr = normalizedRoot.replace(/\\\\/g, '/') + '/';\r\n\r\n  if (!normalizedFileStr.startsWith(normalizedRootStr)) {\r\n    return { success: false, statusCode: 403, message: 'Forbidden: Path traversal detected' };\r\n  }\r\n\r\n  // 8. 提取 fileName\r\n  const pathSegments = cleanedPath.split('/').filter(Boolean);\r\n  const fileName = pathSegments.length > 0 ? basename(pathSegments[pathSegments.length - 1]) : '';\r\n\r\n  // ✅ 成功\r\n  return {\r\n    success: true,\r\n    filePath: normalizedFile,\r\n    urlPath: decodedPath,\r\n    fileName,\r\n  };\r\n}\r\n\r\n\r\ntype ConfigFilename = (typeof CONFIG_FILENAMES)[number];\r\nfunction handleConfigFile(\r\n  srcPath: string,\r\n  destPath: string,\r\n  filename: ConfigFilename,\r\n  options: Required<MxCadAssetsPluginOptions>,\r\n  callback: NoParamCallback\r\n) {\r\n  fs.readFile(srcPath, 'utf-8', async (err, content) => {\r\n    if (err) return callback(err);\r\n\r\n    try {\r\n      let data = content.trim() ? JSON.parse(content) : {};\r\n\r\n      // ✅ 正确生成 transform 函数名\r\n      const baseName = filename.replace(/\\.json$/i, '');\r\n      const transformKey = `transform${pascalCase(baseName)}`; // 例如: transformPluginsConfig 或 transformMxPluginsConfig\r\n\r\n      const transformFn = (options as any)[transformKey];\r\n\r\n      if (typeof transformFn === 'function') {\r\n        data = await transformFn(data);\r\n      }\r\n\r\n      const json = JSON.stringify(data, null, 2);\r\n      fs.writeFile(destPath, json, 'utf-8', callback);\r\n    } catch (err: any) {\r\n      return callback(err);\r\n    }\r\n  });\r\n}\r\n/**\r\n * 处理配置文件请求：读取 → 转换 → 返回响应\r\n * 用于 Vite/Webpack dev server 中间件\r\n */\r\nexport async function handleConfigRequest(\r\n  filePath: string,           // 已经验证过的安全路径\r\n  fileName: string,           // 文件名，如 'mxServerConfig.json'\r\n  options: Required<MxCadAssetsPluginOptions>,\r\n  res: any,\r\n  logger?: { info?: (msg: string) => void; error?: (msg: string) => void }\r\n): Promise<boolean> {\r\n  // 仅处理白名单内的文件\r\n  if (!(CONFIG_FILENAMES as unknown as string).includes(fileName)) {\r\n    return false;\r\n  }\r\n\r\n  try {\r\n    const content = await fs.promises.readFile(filePath, 'utf-8');\r\n    let data = content.trim() ? JSON.parse(content) : {};\r\n\r\n    const transformKey = `transform${pascalCase(fileName.replace(/\\.json$/i, ''))}`;\r\n    const transformFn = (options as any)[transformKey];\r\n\r\n    if (typeof transformFn === 'function') {\r\n      data = await transformFn(data);\r\n    }\r\n\r\n    res.setHeader('Content-Type', 'application/json');\r\n    res.setHeader('Cache-Control', 'no-cache');\r\n    res.end(JSON.stringify(data, null, 2));\r\n    return true;\r\n  } catch (err: any) {\r\n    logger?.error?.(`[mxcad-assets] ❌ Failed to serve ${fileName}: ${err.message}`);\r\n    if (!res.headersSent) {\r\n      res.setHeader('Content-Type', 'text/plain');\r\n      res.statusCode = 500;\r\n      res.end('Internal Server Error');\r\n    }\r\n    return true; // 已处理错误\r\n  }\r\n}\r\n\r\n/** 创建通用全局中间件 */\r\nexport function createGlobalUniversalMiddleware(options: Required<MxCadAssetsPluginOptions>) {\r\n  return async (req: any, res: any, next: any) => {\r\n    if (!options.isWasmSt) {\r\n      res.setHeader('Cross-Origin-Opener-Policy', 'same-origin');\r\n      res.setHeader('Cross-Origin-Embedder-Policy', 'require-corp');\r\n    }\r\n    next();\r\n  }\r\n}\r\n// === 辅助函数：字符串转 PascalCase ===\r\nexport function pascalCase(str: string): string {\r\n  return str\r\n    .replace(/[^a-zA-Z0-9]+(.)/g, (m, chr) => chr.toUpperCase())\r\n    .replace(/^./, c => c.toUpperCase());\r\n}\r\n\r\n// === 其他原有导出保持不变 ===\r\nexport const externals = {\r\n  'vue': 'MXCADAPP_EXTERNALLIBRARIES.Vue',\r\n  'axios': 'MXCADAPP_EXTERNALLIBRARIES.axios',\r\n  'vuetify': 'MXCADAPP_EXTERNALLIBRARIES.vuetify',\r\n  'vuetify/components': 'MXCADAPP_EXTERNALLIBRARIES.vuetifyComponents',\r\n  'mapbox-gl': 'MXCADAPP_EXTERNALLIBRARIES.mapboxgl',\r\n  'pinia': 'MXCADAPP_EXTERNALLIBRARIES.pinia'\r\n};\r\n// 始终保留的模块\r\nconst ALWAYS_KEEP = new Set(['mxcad', 'mxdraw']);\r\n\r\n/**\r\n * 清理并写入正确的类型引用\r\n */\r\nfunction syncTypeReferences(libraryNames: string[]): void {\r\n  const rootDir = process.cwd();\r\n  const distDir = resolve(rootDir, 'node_modules', 'mxcad-app', 'dist');\r\n  const indexPath = resolve(distDir, 'index.d.ts');\r\n\r\n  try {\r\n    // ✅ 1. 检查 dist 目录\r\n    if (!fs.existsSync(distDir)) {\r\n      console.warn(`⚠️ mxcad-app/dist 目录不存在，跳过类型同步: ${distDir}`);\r\n      return;\r\n    }\r\n\r\n    // ✅ 2. 确保 index.d.ts 存在\r\n    if (!fs.existsSync(indexPath)) {\r\n      fs.writeFileSync(indexPath, '', 'utf-8');\r\n      console.log(`✅ 已创建空类型文件: ${indexPath}`);\r\n    }\r\n\r\n    let content = fs.readFileSync(indexPath, 'utf-8');\r\n    const lines = content.split(/\\r?\\n/);\r\n\r\n    // ✅ 3. 提取所有现有的 /// <reference path=\"./xxx.d.ts\" /> 行\r\n    const referenceRegex = /\\/\\/\\/\\s*<reference\\s+path=\"\\.\\/([^\"]+\\.d\\.ts)\"\\s*\\/>/;\r\n    const existingRefs: string[] = [];\r\n    const nonRefLines: string[] = [];\r\n\r\n    lines.forEach(line => {\r\n      const match = line.trim().match(referenceRegex);\r\n      if (match) {\r\n        const fileName = match[1]; // 如 \"vue.d.ts\"\r\n        const moduleName = fileName.replace(/\\.d\\.ts$/, ''); // 提取模块名\r\n        existingRefs.push(moduleName);\r\n      } else {\r\n        nonRefLines.push(line); // 保留非 reference 行\r\n      }\r\n    });\r\n\r\n    // ✅ 4. 计算最终应该保留的模块\r\n    const validModules = new Set<string>(ALWAYS_KEEP);\r\n\r\n    libraryNames.forEach(name => {\r\n      // 必须在 externals 中定义，且类型文件存在\r\n      if (name in externals) {\r\n        const dtsPath = resolve(distDir, `${name}.d.ts`);\r\n        if (fs.existsSync(dtsPath)) {\r\n          validModules.add(name);\r\n        }\r\n      }\r\n    });\r\n\r\n    // ✅ 5. 生成最终的 reference 行（保持 mxcad 和 mxdraw 在最前）\r\n    const finalRefs = ['mxcad', 'mxdraw']\r\n      .filter(name => validModules.has(name))\r\n      .map(name => `/// <reference path=\"./${name}.d.ts\" />`);\r\n\r\n    // 添加其他 validModules 中的（去重）\r\n    Array.from(validModules)\r\n      .filter(name => !ALWAYS_KEEP.has(name))\r\n      .forEach(name => {\r\n        finalRefs.push(`/// <reference path=\"./${name}.d.ts\" />`);\r\n      });\r\n\r\n    // ✅ 6. 合并：最终引用 + 原始非引用行\r\n    const resultLines = [...finalRefs, '', ...nonRefLines.filter(l => l.trim().length > 0)];\r\n\r\n    // 移除连续空行，保留一个分隔\r\n    const cleanedLines = resultLines.filter((line, i, arr) =>\r\n      !(line.trim() === '' && i > 0 && arr[i - 1].trim() === '')\r\n    );\r\n\r\n    const newContent = cleanedLines.join('\\n').trim() + '\\n';\r\n\r\n    // ✅ 7. 写回文件（仅当内容变化时）\r\n    if (content.trim() !== newContent.trim()) {\r\n      fs.writeFileSync(indexPath, newContent, 'utf-8');\r\n      console.log(`✅ 已同步 mxcad-app/dist/index.d.ts 类型引用`);\r\n      console.log(`   保留: ${Array.from(validModules).join(', ')}`);\r\n    }\r\n  } catch (err) {\r\n    console.error(`❌ 同步类型引用失败:`, err);\r\n  }\r\n}\r\n\r\n/**\r\n * 预定义库名到全局变量的映射\r\n */\r\nexport const DEFAULT_LIBRARY_MAP: Record<string, string> = {\r\n  mxcad: 'MxCAD',\r\n  mxdraw: 'Mx'\r\n}\r\nexport function getExternals(\r\n  libraryNames: Required<MxCadAssetsPluginOptions>['libraryNames']\r\n): { [key: string]: string } {\r\n  syncTypeReferences(libraryNames);\r\n  const result: { [key: string]: string } = { ...DEFAULT_LIBRARY_MAP }\r\n  if (!Array.isArray(libraryNames)) return result;\r\n  libraryNames.forEach(name => {\r\n    if (name in externals) {\r\n      result[name] = externals[name as keyof typeof externals];\r\n    }\r\n  });\r\n  return result;\r\n}\r\n\r\nexport function getSourceAssetsPath(): string {\r\n  let currentFile: string;\r\n  if (typeof __filename !== 'undefined') {\r\n    currentFile = __filename;\r\n  } else {\r\n    // @ts-ignore\r\n    currentFile = fileURLToPath(import.meta.url);\r\n  }\r\n  const packageRoot = resolve(currentFile, '..', '..', '..');\r\n  const assetsPath = resolve(packageRoot, name, 'dist', 'mxcadAppAssets');\r\n  if (!fs.existsSync(assetsPath)) {\r\n    throw new Error(`mx-cad-app assets not found at: ${assetsPath}`);\r\n  }\r\n  return assetsPath;\r\n}\r\n\r\nexport function checkSourceAssetsExist(): boolean {\r\n  const path = getSourceAssetsPath();\r\n  return fs.existsSync(path) && fs.lstatSync(path).isDirectory();\r\n}\r\n\r\nexport function generateRuntimeConfigScript(publicPath: string): string {\r\n  return `\r\n    <script>\r\n      window.__MX_CAD_APP_ASSET_PATH__ = '${publicPath}';\r\n    </script>\r\n  `.trim();\r\n}\r\n\r\nexport function copyDir(\r\n  src: string,\r\n  dest: string,\r\n  publicDir: string,\r\n  options: Required<MxCadAssetsPluginOptions>,\r\n  callback: (err?: Error) => void\r\n): void {\r\n  // 第一步：扫描 publicDir 下所有文件（相对于 publicDir 的路径）\r\n  scanPublicDir(publicDir, (err, publicFiles) => {\r\n    if (err) return callback(err);\r\n\r\n    // 第二步：开始复制，传入 publicFiles 缓存\r\n    doCopy(src, dest, publicDir, publicFiles!, options, callback);\r\n  });\r\n}\r\n\r\n// 实际执行复制的函数\r\nfunction doCopy(\r\n  src: string,\r\n  dest: string,\r\n  publicDir: string,\r\n  publicFiles: Set<string>,\r\n  options: Required<MxCadAssetsPluginOptions>, // 注意：这里需要确保 enableCompressedAssets 是必选的\r\n  callback: (err?: Error) => void\r\n) {\r\n  fs.mkdir(dest, { recursive: true }, (err) => {\r\n    if (err) return callback(err);\r\n\r\n    fs.readdir(src, { withFileTypes: true }, (err, dirents) => {\r\n      if (err) return callback(err);\r\n\r\n      let pending = dirents.length;\r\n      if (pending === 0) return callback();\r\n\r\n      // 提前定义压缩文件扩展名\r\n      const compressedExts = ['.gz']; // 可按需扩展\r\n\r\n      dirents.forEach((dirent) => {\r\n        const srcPath = resolve(src, dirent.name);\r\n        const destPath = resolve(dest, dirent.name);\r\n        const relativePath = relative(src, srcPath).replace(/\\\\/g, '/') as ConfigFilename;\r\n\r\n        // 新增：如果禁用压缩资源且是压缩文件，则跳过\r\n        if (\r\n          !options.enableCompressedAssets &&\r\n          compressedExts.some(ext => relativePath.endsWith(ext))\r\n        ) {\r\n          if (--pending === 0) callback();\r\n          return;\r\n        }\r\n\r\n        if (dirent.isDirectory()) {\r\n          doCopy(srcPath, destPath, publicDir, publicFiles, options, () => {\r\n            if (--pending === 0) callback();\r\n          });\r\n        } else if (dirent.isFile()) {\r\n          if (publicFiles.has(relativePath)) {\r\n            const publicFilePath = resolve(publicDir, relativePath);\r\n            fs.copyFile(publicFilePath, destPath, (err) => {\r\n              if (err) return callback(err);\r\n              if (--pending === 0) callback();\r\n            });\r\n          } else if (CONFIG_FILENAMES.includes(relativePath)) {\r\n            handleConfigFile(srcPath, destPath, relativePath, options, (err) => {\r\n              if (err) return callback(err);\r\n              if (--pending === 0) callback();\r\n            });\r\n          } else {\r\n            fs.copyFile(srcPath, destPath, (err) => {\r\n              if (err) return callback(err);\r\n              if (--pending === 0) callback();\r\n            });\r\n          }\r\n        } else {\r\n          if (--pending === 0) callback();\r\n        }\r\n      });\r\n    });\r\n  });\r\n}\r\n// 扫描 publicDir 下所有文件，返回相对于 publicDir 的路径集合\r\nfunction scanPublicDir(\r\n  publicDir: string,\r\n  callback: (err: NodeJS.ErrnoException | null, files?: Set<string>) => void\r\n) {\r\n  const result = new Set<string>();\r\n\r\n  function walk(dir: string) {\r\n    fs.readdir(dir, { withFileTypes: true }, (err, dirents) => {\r\n      if (err) return callback(err);\r\n\r\n      let pending = dirents.length;\r\n      if (pending === 0) {\r\n        return callback(null, result);\r\n      }\r\n\r\n      dirents.forEach((dirent) => {\r\n        const fullPath = resolve(dir, dirent.name);\r\n        const relPath = relative(publicDir, fullPath).replace(/\\\\/g, '/');\r\n\r\n        if (dirent.isDirectory()) {\r\n          walk(fullPath);\r\n        } else if (dirent.isFile()) {\r\n          result.add(relPath);\r\n          if (--pending === 0) {\r\n            callback(null, result);\r\n          }\r\n        } else {\r\n          if (--pending === 0) {\r\n            callback(null, result);\r\n          }\r\n        }\r\n      });\r\n    });\r\n  }\r\n\r\n  walk(publicDir);\r\n}\r\n\r\nexport function getContentType(filePath: string): string {\r\n  const ext = filePath.split('.').pop()?.toLowerCase() || '';\r\n  const types: Record<string, string> = {\r\n    'css': 'text/css',\r\n    'js': 'application/javascript',\r\n    'json': 'application/json',\r\n    'png': 'image/png',\r\n    'jpg': 'image/jpeg',\r\n    'jpeg': 'image/jpeg',\r\n    'gif': 'image/gif',\r\n    'svg': 'image/svg+xml',\r\n    'woff': 'font/woff',\r\n    'woff2': 'font/woff2',\r\n    'ttf': 'font/ttf',\r\n    'eot': 'application/vnd.ms-fontobject',\r\n    'ico': 'image/x-icon',\r\n    'wasm': 'application/wasm',\r\n    'zip': 'application/zip',\r\n    'rar': 'application/x-rar-compressed',\r\n    '7z': 'application/x-7z-compressed',\r\n    'tar': 'application/x-tar',\r\n    'gz': 'application/gzip',\r\n    'bz2': 'application/x-bzip2',\r\n    'xz': 'application/x-xz'\r\n  };\r\n  return types[ext] || 'application/octet-stream';\r\n}\r\n\r\n\r\n/**\r\n * 标准化路径，确保以 '/' 结尾\r\n */\r\nfunction normalizePath(p: string): string {\r\n  return resolve(p).replace(/\\\\/g, '/') + '/';\r\n}\r\n\r\n/**\r\n * 创建通用中间件：优先使用 public 资源，回退到 sourceAssetsPath\r\n * 对标 createStaticMiddleware 风格\r\n */\r\nexport function createMxCadAssetsMiddleware(\r\n  root: string,\r\n  options: Required<MxCadAssetsPluginOptions>,\r\n  publicDir: string,\r\n  logger?: any\r\n) {\r\n  const { outputDir, isWasmSt = false } = options;\r\n  // ✅ 1. 规范化路径\r\n  const basePath = `/${outputDir.replace(/^\\/+/, '')}`; // '/mxcadAppAssets'\r\n  const sourceAssetsRoot = normalizePath(root);\r\n\r\n  return async (req: any, res: any, next: () => void) => {\r\n    // ✅ 2. 基本校验\r\n    if (!req.url || typeof req.url !== 'string') {\r\n      return next();\r\n    }\r\n\r\n    // ✅ 3. 设置安全头（非 isWasmSt 模式）\r\n    if (!isWasmSt) {\r\n      res.setHeader('Cross-Origin-Opener-Policy', 'same-origin');\r\n      res.setHeader('Cross-Origin-Embedder-Policy', 'require-corp');\r\n    }\r\n\r\n    // ✅ 4. 解析 URL 路径（去 query，解码）\r\n    const urlPath = req.url.split('?')[0];\r\n    let filePath!: string;\r\n    let fileName!: string;\r\n\r\n    try {\r\n      const decodedPath = decodeURIComponent(urlPath);\r\n      // 规范化路径，防止 ../../ 越权\r\n      const normalizedPath = decodedPath.replace(/^[/\\\\]+/, '');\r\n\r\n      // ✅ 5. 优先：检查 public/${outputDir} 目录\r\n      const publicFilePath = join(publicDir, normalizedPath).replace(/\\\\/g, '/');\r\n\r\n      try {\r\n        const stat = await fs.promises.stat(publicFilePath);\r\n        if (stat.isFile()) {\r\n          filePath = publicFilePath;\r\n          fileName = basename(normalizedPath);\r\n          return serveFile(filePath, fileName, res, logger);\r\n        }\r\n      } catch (err) {\r\n        // public 中没有，继续查找 sourceAssetsPath\r\n      }\r\n\r\n      // ✅ 6. fallback：查找 sourceAssetsPath\r\n      const result = resolveSafePath(decodedPath, sourceAssetsRoot, basePath);\r\n      if (!result.success) {\r\n        res.statusCode = result.statusCode || 400;\r\n        return res.end(result.message);\r\n      }\r\n\r\n      if (result.filePath) filePath = result.filePath;\r\n      if (result.fileName) fileName = result.fileName;\r\n\r\n      // ✅ 7. 尝试由 handleConfigRequest 处理（如注入配置）\r\n      const handled = await handleConfigRequest(\r\n        filePath,\r\n        fileName,\r\n        options,\r\n        res,\r\n        logger\r\n      );\r\n      if (handled) return;\r\n\r\n      // ✅ 8. 确保是文件\r\n      const stat = await fs.promises.stat(filePath);\r\n      if (!stat.isFile()) {\r\n        res.statusCode = 404;\r\n        return res.end('File not found');\r\n      }\r\n\r\n      return serveFile(filePath, fileName, res, logger);\r\n    } catch (err) {\r\n      logger?.warn?.(`[MxCadAssets] Serve failed for ${req.url}: ${(err as Error).message}`);\r\n      if (res.headersSent) return;\r\n      res.statusCode = 404;\r\n      res.end('File not found');\r\n    }\r\n  };\r\n}\r\n\r\n/**\r\n * 封装文件响应逻辑（流式传输）\r\n */\r\nfunction serveFile(filePath: string, fileName: string, res: any, logger?: any) {\r\n  const stream = fs.createReadStream(filePath);\r\n\r\n  stream.on('error', (err: NodeJS.ErrnoException) => {\r\n    if (res.headersSent) return;\r\n    if (err.code === 'ENOENT' || err.code === 'EACCES') {\r\n      return res.statusCode === 200 ? res.end() : undefined;\r\n    }\r\n    logger?.error?.(`[MxCadAssets] Read error: ${err.message}`, err);\r\n    res.statusCode = 500;\r\n    res.end('Internal Server Error');\r\n  });\r\n\r\n  res.setHeader('Content-Type', getContentType(fileName));\r\n  res.setHeader('X-Content-Type-Options', 'nosniff');\r\n\r\n  stream.pipe(res);\r\n}"],"names":["fs","err","name","stat"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAcO,MAAM,YAAY,MAAM;AAUxB,MAAM,mBAAmB;AAAA;AAAA,EAE9B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAEF;AAoC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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index-C-cFEcIk.mjs","sources":["../../packToolPluginSrc/shared/index.ts"],"sourcesContent":["\r\n// plugins/shared/index.ts\r\nimport { basename, join, relative, resolve } from 'path';\r\nimport fs, { NoParamCallback } from 'fs';\r\nimport { fileURLToPath } from 'url';\r\nimport { name } from \"../../lib/package.json\"\r\n\r\nimport { MxQuickCommand } from \"./types/mxQuickCommand.d\"\r\nimport { MxServerConfig } from \"./types/mxServerConfig.d\"\r\nimport { MxSketchesAndNotesUiConfig } from \"./types/mxSketchesAndNotesUiConfig.d\"\r\nimport { MxUiConfig } from \"./types/mxUiConfig.d\"\r\nimport { MxcadUiConfig } from \"./types/mxcadUiConfig.d\"\r\nimport { VuetifyThemeConfig } from \"./types/vuetifyThemeConfig.d\"\r\nimport apiMap from '../api-map.json'\r\nexport const getApiMap = () => apiMap\r\nexport interface MxPluginConfig {\r\n  plugins: (string | {\r\n    name?: string,\r\n    isAfterLoad?: boolean,\r\n    dir?: boolean,\r\n    version?: string\r\n  })[]\r\n}\r\n// === 新增：配置文件名常量 ===\r\nexport const CONFIG_FILENAMES = [\r\n  // 'mxcadUiConfig.json',\r\n  'mxQuickCommand.json',\r\n  'mxServerConfig.json',\r\n  'mxSketchesAndNotesUiConfig.json',\r\n  'mxUiConfig.json',\r\n  'vuetifyThemeConfig.json',\r\n  // 'plugins/config.json'\r\n] as const;\r\n/**\r\n * 配置文件处理器\r\n * 可选：对特定配置文件进行运行时修改\r\n * 函数接收原始 JSON 数据，返回修改后的 JSON 数据（可异步）\r\n */\r\nexport interface TransformFunctions {\r\n  // transformMxcadUiConfig(data: MxcadUiConfig): Promise<MxcadUiConfig> | MxcadUiConfig;\r\n  transformMxQuickCommand(data: MxQuickCommand): Promise<MxQuickCommand> | MxQuickCommand;\r\n  transformMxServerConfig(data: MxServerConfig): Promise<MxServerConfig> | MxServerConfig;\r\n  transformMxSketchesAndNotesUiConfig(data: MxSketchesAndNotesUiConfig): Promise<MxSketchesAndNotesUiConfig> | MxSketchesAndNotesUiConfig;\r\n  transformMxUiConfig(data: MxUiConfig): Promise<MxUiConfig> | MxUiConfig;\r\n  transformVuetifyThemeConfig(data: VuetifyThemeConfig): Promise<VuetifyThemeConfig> | VuetifyThemeConfig;\r\n  // transformMxPluginsConfig(data: MxPluginConfig[]): Promise<MxPluginConfig[]> | MxPluginConfig[];\r\n}\r\n// 扩展插件选项接口 ===\r\nexport interface MxCadAssetsPluginOptions extends Partial<TransformFunctions> {\r\n  /**\r\n   * 构建后，mxcadAppAssets 资源存放的子目录名。\r\n   * @default 'mxcadAppAssets'\r\n   */\r\n  outputDir?: string;\r\n  /** 第三方依赖*/\r\n  libraryNames?: (keyof typeof externals)[];\r\n  /** 是否单线程加载wasm (默认使用多线程及加载) */\r\n  isWasmSt?: boolean;\r\n   /**\r\n   * 是否启用预压缩资源（如 .gz 文件）的拷贝 默认是true\r\n   * 设置为 false 时，.gz 压缩文件将不会被复制到输出目录\r\n   * @default true\r\n   */\r\n  enableCompressedAssets?: boolean;\r\n}\r\n\r\n\r\n// === 增强：resolveOptions 默认值 ===\r\nexport function resolveOptions(options: MxCadAssetsPluginOptions = {}): Required<MxCadAssetsPluginOptions> {\r\n  const resolved: Required<MxCadAssetsPluginOptions> = {\r\n    outputDir: options.outputDir || 'mxcadAppAssets',\r\n    libraryNames: options.libraryNames || [],\r\n    isWasmSt: options.isWasmSt || false,\r\n    enableCompressedAssets: options.enableCompressedAssets || true,\r\n    // transformMxcadUiConfig: options.transformMxcadUiConfig || ((d) => d),\r\n    transformMxQuickCommand: options.transformMxQuickCommand || ((d) => d),\r\n    transformMxServerConfig: options.transformMxServerConfig || ((d) => d),\r\n    transformMxSketchesAndNotesUiConfig: options.transformMxSketchesAndNotesUiConfig || ((d) => d),\r\n    transformMxUiConfig: options.transformMxUiConfig || ((d) => d),\r\n    transformVuetifyThemeConfig: options.transformVuetifyThemeConfig || ((d) => d),\r\n    // transformMxPluginsConfig: options.transformMxPluginsConfig || ((d) => d),\r\n  };\r\n  return resolved;\r\n}\r\n\r\n\r\nexport interface ParsedPathResult {\r\n  success: boolean;\r\n  filePath?: string;         // 已 resolve 的安全文件路径\r\n  urlPath?: string;          // 解码后的 URL 路径（不含 query）\r\n  fileName?: string;         // 文件名（basename）\r\n  statusCode?: number;\r\n  message?: string;\r\n}\r\n\r\n\r\n/**\r\n * 安全解析并验证请求路径\r\n * @param reqUrl 请求的 URL（如 '/assets/mxServerConfig.json?v=1'）\r\n * @param root 本地根目录（如 'D:/project/dist/mxcad'）\r\n * @param basePath 可选的基础路径前缀（如 '/mxcad/'，用于 Vite）\r\n * @returns 解析结果或错误\r\n */\r\nexport function resolveSafePath(\r\n  reqUrl: string,\r\n  root: string,\r\n  basePath?: string\r\n): ParsedPathResult {\r\n  // 1. 基本校验\r\n  if (!reqUrl || typeof reqUrl !== 'string') {\r\n    return { success: false, statusCode: 400, message: 'Bad Request' };\r\n  }\r\n\r\n  // 2. 提取路径（去 query 和 hash）\r\n  let urlPath = reqUrl.split('?')[0].split('#')[0];\r\n\r\n  // 3. 解码 URL\r\n  let decodedPath: string;\r\n  try {\r\n    decodedPath = decodeURIComponent(urlPath);\r\n    // 防止 null 字节攻击\r\n    if (decodedPath.includes('\\0')) {\r\n      return { success: false, statusCode: 400, message: 'Invalid URL' };\r\n    }\r\n  } catch (err) {\r\n    return { success: false, statusCode: 400, message: 'Invalid URL encoding' };\r\n  }\r\n\r\n  // 4. 处理 basePath（如 Vite 的 base）\r\n  if (basePath && decodedPath.startsWith(basePath)) {\r\n    decodedPath = decodedPath.slice(basePath.length);\r\n  }\r\n\r\n  // 5. 清理路径：去除开头多余的 /\r\n  // 例如：//assets/file.json -> assets/file.json\r\n  const cleanedPath = decodedPath.replace(/^\\/+/, '');\r\n\r\n  // 6. 拼接文件路径\r\n  const filePath = join(root, cleanedPath || '.');\r\n\r\n  // 7. 安全检查：防止路径穿越\r\n  let normalizedFile: string;\r\n  let normalizedRoot: string;\r\n  try {\r\n    normalizedFile = resolve(filePath);\r\n    normalizedRoot = resolve(root);\r\n  } catch (err) {\r\n    return { success: false, statusCode: 500, message: 'Path resolution failed' };\r\n  }\r\n\r\n  // ✅ 关键：确保 normalizedFile 在 normalizedRoot 目录下\r\n  const normalizedFileStr = normalizedFile.replace(/\\\\/g, '/') + '/';\r\n  const normalizedRootStr = normalizedRoot.replace(/\\\\/g, '/') + '/';\r\n\r\n  if (!normalizedFileStr.startsWith(normalizedRootStr)) {\r\n    return { success: false, statusCode: 403, message: 'Forbidden: Path traversal detected' };\r\n  }\r\n\r\n  // 8. 提取 fileName\r\n  const pathSegments = cleanedPath.split('/').filter(Boolean);\r\n  const fileName = pathSegments.length > 0 ? basename(pathSegments[pathSegments.length - 1]) : '';\r\n\r\n  // ✅ 成功\r\n  return {\r\n    success: true,\r\n    filePath: normalizedFile,\r\n    urlPath: decodedPath,\r\n    fileName,\r\n  };\r\n}\r\n\r\n\r\ntype ConfigFilename = (typeof CONFIG_FILENAMES)[number];\r\nfunction handleConfigFile(\r\n  srcPath: string,\r\n  destPath: string,\r\n  filename: ConfigFilename,\r\n  options: Required<MxCadAssetsPluginOptions>,\r\n  callback: NoParamCallback\r\n) {\r\n  fs.readFile(srcPath, 'utf-8', async (err, content) => {\r\n    if (err) return callback(err);\r\n\r\n    try {\r\n      let data = content.trim() ? JSON.parse(content) : {};\r\n\r\n      // ✅ 正确生成 transform 函数名\r\n      const baseName = filename.replace(/\\.json$/i, '');\r\n      const transformKey = `transform${pascalCase(baseName)}`; // 例如: transformPluginsConfig 或 transformMxPluginsConfig\r\n\r\n      const transformFn = (options as any)[transformKey];\r\n\r\n      if (typeof transformFn === 'function') {\r\n        data = await transformFn(data);\r\n      }\r\n\r\n      const json = JSON.stringify(data, null, 2);\r\n      fs.writeFile(destPath, json, 'utf-8', callback);\r\n    } catch (err: any) {\r\n      return callback(err);\r\n    }\r\n  });\r\n}\r\n/**\r\n * 处理配置文件请求：读取 → 转换 → 返回响应\r\n * 用于 Vite/Webpack dev server 中间件\r\n */\r\nexport async function handleConfigRequest(\r\n  filePath: string,           // 已经验证过的安全路径\r\n  fileName: string,           // 文件名，如 'mxServerConfig.json'\r\n  options: Required<MxCadAssetsPluginOptions>,\r\n  res: any,\r\n  logger?: { info?: (msg: string) => void; error?: (msg: string) => void }\r\n): Promise<boolean> {\r\n  // 仅处理白名单内的文件\r\n  if (!(CONFIG_FILENAMES as unknown as string).includes(fileName)) {\r\n    return false;\r\n  }\r\n\r\n  try {\r\n    const content = await fs.promises.readFile(filePath, 'utf-8');\r\n    let data = content.trim() ? JSON.parse(content) : {};\r\n\r\n    const transformKey = `transform${pascalCase(fileName.replace(/\\.json$/i, ''))}`;\r\n    const transformFn = (options as any)[transformKey];\r\n\r\n    if (typeof transformFn === 'function') {\r\n      data = await transformFn(data);\r\n    }\r\n\r\n    res.setHeader('Content-Type', 'application/json');\r\n    res.setHeader('Cache-Control', 'no-cache');\r\n    res.end(JSON.stringify(data, null, 2));\r\n    return true;\r\n  } catch (err: any) {\r\n    logger?.error?.(`[mxcad-assets] ❌ Failed to serve ${fileName}: ${err.message}`);\r\n    if (!res.headersSent) {\r\n      res.setHeader('Content-Type', 'text/plain');\r\n      res.statusCode = 500;\r\n      res.end('Internal Server Error');\r\n    }\r\n    return true; // 已处理错误\r\n  }\r\n}\r\n\r\n/** 创建通用全局中间件 */\r\nexport function createGlobalUniversalMiddleware(options: Required<MxCadAssetsPluginOptions>) {\r\n  return async (req: any, res: any, next: any) => {\r\n    if (!options.isWasmSt) {\r\n      res.setHeader('Cross-Origin-Opener-Policy', 'same-origin');\r\n      res.setHeader('Cross-Origin-Embedder-Policy', 'require-corp');\r\n    }\r\n    next();\r\n  }\r\n}\r\n// === 辅助函数：字符串转 PascalCase ===\r\nexport function pascalCase(str: string): string {\r\n  return str\r\n    .replace(/[^a-zA-Z0-9]+(.)/g, (m, chr) => chr.toUpperCase())\r\n    .replace(/^./, c => c.toUpperCase());\r\n}\r\n\r\n// === 其他原有导出保持不变 ===\r\nexport const externals = {\r\n  'vue': 'MXCADAPP_EXTERNALLIBRARIES.Vue',\r\n  'axios': 'MXCADAPP_EXTERNALLIBRARIES.axios',\r\n  'vuetify': 'MXCADAPP_EXTERNALLIBRARIES.vuetify',\r\n  'vuetify/components': 'MXCADAPP_EXTERNALLIBRARIES.vuetifyComponents',\r\n  'mapbox-gl': 'MXCADAPP_EXTERNALLIBRARIES.mapboxgl',\r\n  'pinia': 'MXCADAPP_EXTERNALLIBRARIES.pinia'\r\n};\r\n// 始终保留的模块\r\nconst ALWAYS_KEEP = new Set(['mxcad', 'mxdraw']);\r\n\r\n/**\r\n * 清理并写入正确的类型引用\r\n */\r\nfunction syncTypeReferences(libraryNames: string[]): void {\r\n  const rootDir = process.cwd();\r\n  const distDir = resolve(rootDir, 'node_modules', 'mxcad-app', 'dist');\r\n  const indexPath = resolve(distDir, 'index.d.ts');\r\n\r\n  try {\r\n    // ✅ 1. 检查 dist 目录\r\n    if (!fs.existsSync(distDir)) {\r\n      console.warn(`⚠️ mxcad-app/dist 目录不存在，跳过类型同步: ${distDir}`);\r\n      return;\r\n    }\r\n\r\n    // ✅ 2. 确保 index.d.ts 存在\r\n    if (!fs.existsSync(indexPath)) {\r\n      fs.writeFileSync(indexPath, '', 'utf-8');\r\n      console.log(`✅ 已创建空类型文件: ${indexPath}`);\r\n    }\r\n\r\n    let content = fs.readFileSync(indexPath, 'utf-8');\r\n    const lines = content.split(/\\r?\\n/);\r\n\r\n    // ✅ 3. 提取所有现有的 /// <reference path=\"./xxx.d.ts\" /> 行\r\n    const referenceRegex = /\\/\\/\\/\\s*<reference\\s+path=\"\\.\\/([^\"]+\\.d\\.ts)\"\\s*\\/>/;\r\n    const existingRefs: string[] = [];\r\n    const nonRefLines: string[] = [];\r\n\r\n    lines.forEach(line => {\r\n      const match = line.trim().match(referenceRegex);\r\n      if (match) {\r\n        const fileName = match[1]; // 如 \"vue.d.ts\"\r\n        const moduleName = fileName.replace(/\\.d\\.ts$/, ''); // 提取模块名\r\n        existingRefs.push(moduleName);\r\n      } else {\r\n        nonRefLines.push(line); // 保留非 reference 行\r\n      }\r\n    });\r\n\r\n    // ✅ 4. 计算最终应该保留的模块\r\n    const validModules = new Set<string>(ALWAYS_KEEP);\r\n\r\n    libraryNames.forEach(name => {\r\n      // 必须在 externals 中定义，且类型文件存在\r\n      if (name in externals) {\r\n        const dtsPath = resolve(distDir, `${name}.d.ts`);\r\n        if (fs.existsSync(dtsPath)) {\r\n          validModules.add(name);\r\n        }\r\n      }\r\n    });\r\n\r\n    // ✅ 5. 生成最终的 reference 行（保持 mxcad 和 mxdraw 在最前）\r\n    const finalRefs = ['mxcad', 'mxdraw']\r\n      .filter(name => validModules.has(name))\r\n      .map(name => `/// <reference path=\"./${name}.d.ts\" />`);\r\n\r\n    // 添加其他 validModules 中的（去重）\r\n    Array.from(validModules)\r\n      .filter(name => !ALWAYS_KEEP.has(name))\r\n      .forEach(name => {\r\n        finalRefs.push(`/// <reference path=\"./${name}.d.ts\" />`);\r\n      });\r\n\r\n    // ✅ 6. 合并：最终引用 + 原始非引用行\r\n    const resultLines = [...finalRefs, '', ...nonRefLines.filter(l => l.trim().length > 0)];\r\n\r\n    // 移除连续空行，保留一个分隔\r\n    const cleanedLines = resultLines.filter((line, i, arr) =>\r\n      !(line.trim() === '' && i > 0 && arr[i - 1].trim() === '')\r\n    );\r\n\r\n    const newContent = cleanedLines.join('\\n').trim() + '\\n';\r\n\r\n    // ✅ 7. 写回文件（仅当内容变化时）\r\n    if (content.trim() !== newContent.trim()) {\r\n      fs.writeFileSync(indexPath, newContent, 'utf-8');\r\n      console.log(`✅ 已同步 mxcad-app/dist/index.d.ts 类型引用`);\r\n      console.log(`   保留: ${Array.from(validModules).join(', ')}`);\r\n    }\r\n  } catch (err) {\r\n    console.error(`❌ 同步类型引用失败:`, err);\r\n  }\r\n}\r\n\r\n/**\r\n * 预定义库名到全局变量的映射\r\n */\r\nexport const DEFAULT_LIBRARY_MAP: Record<string, string> = {\r\n  mxcad: 'MxCAD',\r\n  mxdraw: 'Mx'\r\n}\r\nexport function getExternals(\r\n  libraryNames: Required<MxCadAssetsPluginOptions>['libraryNames']\r\n): { [key: string]: string } {\r\n  syncTypeReferences(libraryNames);\r\n  const result: { [key: string]: string } = { ...DEFAULT_LIBRARY_MAP }\r\n  if (!Array.isArray(libraryNames)) return result;\r\n  libraryNames.forEach(name => {\r\n    if (name in externals) {\r\n      result[name] = externals[name as keyof typeof externals];\r\n    }\r\n  });\r\n  return result;\r\n}\r\n\r\nexport function getSourceAssetsPath(): string {\r\n  let currentFile: string;\r\n  if (typeof __filename !== 'undefined') {\r\n    currentFile = __filename;\r\n  } else {\r\n    // @ts-ignore\r\n    currentFile = fileURLToPath(import.meta.url);\r\n  }\r\n  const packageRoot = resolve(currentFile, '..', '..', '..');\r\n  const assetsPath = resolve(packageRoot, name, 'dist', 'mxcadAppAssets');\r\n  if (!fs.existsSync(assetsPath)) {\r\n    throw new Error(`mx-cad-app assets not found at: ${assetsPath}`);\r\n  }\r\n  return assetsPath;\r\n}\r\n\r\nexport function checkSourceAssetsExist(): boolean {\r\n  const path = getSourceAssetsPath();\r\n  return fs.existsSync(path) && fs.lstatSync(path).isDirectory();\r\n}\r\n\r\nexport function generateRuntimeConfigScript(publicPath: string): string {\r\n  return `\r\n    <script>\r\n      window.__MX_CAD_APP_ASSET_PATH__ = '${publicPath}';\r\n    </script>\r\n  `.trim();\r\n}\r\n\r\nexport function copyDir(\r\n  src: string,\r\n  dest: string,\r\n  publicDir: string,\r\n  options: Required<MxCadAssetsPluginOptions>,\r\n  callback: (err?: Error) => void\r\n): void {\r\n  // 第一步：扫描 publicDir 下所有文件（相对于 publicDir 的路径）\r\n  scanPublicDir(publicDir, (err, publicFiles) => {\r\n    if (err) return callback(err);\r\n\r\n    // 第二步：开始复制，传入 publicFiles 缓存\r\n    doCopy(src, dest, publicDir, publicFiles!, options, callback);\r\n  });\r\n}\r\n\r\n// 实际执行复制的函数\r\nfunction doCopy(\r\n  src: string,\r\n  dest: string,\r\n  publicDir: string,\r\n  publicFiles: Set<string>,\r\n  options: Required<MxCadAssetsPluginOptions>, // 注意：这里需要确保 enableCompressedAssets 是必选的\r\n  callback: (err?: Error) => void\r\n) {\r\n  fs.mkdir(dest, { recursive: true }, (err) => {\r\n    if (err) return callback(err);\r\n\r\n    fs.readdir(src, { withFileTypes: true }, (err, dirents) => {\r\n      if (err) return callback(err);\r\n\r\n      let pending = dirents.length;\r\n      if (pending === 0) return callback();\r\n\r\n      // 提前定义压缩文件扩展名\r\n      const compressedExts = ['.gz']; // 可按需扩展\r\n\r\n      dirents.forEach((dirent) => {\r\n        const srcPath = resolve(src, dirent.name);\r\n        const destPath = resolve(dest, dirent.name);\r\n        const relativePath = relative(src, srcPath).replace(/\\\\/g, '/') as ConfigFilename;\r\n\r\n        // 新增：如果禁用压缩资源且是压缩文件，则跳过\r\n        if (\r\n          !options.enableCompressedAssets &&\r\n          compressedExts.some(ext => relativePath.endsWith(ext))\r\n        ) {\r\n          if (--pending === 0) callback();\r\n          return;\r\n        }\r\n\r\n        if (dirent.isDirectory()) {\r\n          doCopy(srcPath, destPath, publicDir, publicFiles, options, () => {\r\n            if (--pending === 0) callback();\r\n          });\r\n        } else if (dirent.isFile()) {\r\n          if (publicFiles.has(relativePath)) {\r\n            const publicFilePath = resolve(publicDir, relativePath);\r\n            fs.copyFile(publicFilePath, destPath, (err) => {\r\n              if (err) return callback(err);\r\n              if (--pending === 0) callback();\r\n            });\r\n          } else if (CONFIG_FILENAMES.includes(relativePath)) {\r\n            handleConfigFile(srcPath, destPath, relativePath, options, (err) => {\r\n              if (err) return callback(err);\r\n              if (--pending === 0) callback();\r\n            });\r\n          } else {\r\n            fs.copyFile(srcPath, destPath, (err) => {\r\n              if (err) return callback(err);\r\n              if (--pending === 0) callback();\r\n            });\r\n          }\r\n        } else {\r\n          if (--pending === 0) callback();\r\n        }\r\n      });\r\n    });\r\n  });\r\n}\r\n// 扫描 publicDir 下所有文件，返回相对于 publicDir 的路径集合\r\nfunction scanPublicDir(\r\n  publicDir: string,\r\n  callback: (err: NodeJS.ErrnoException | null, files?: Set<string>) => void\r\n) {\r\n  const result = new Set<string>();\r\n\r\n  function walk(dir: string) {\r\n    fs.readdir(dir, { withFileTypes: true }, (err, dirents) => {\r\n      if (err) return callback(err);\r\n\r\n      let pending = dirents.length;\r\n      if (pending === 0) {\r\n        return callback(null, result);\r\n      }\r\n\r\n      dirents.forEach((dirent) => {\r\n        const fullPath = resolve(dir, dirent.name);\r\n        const relPath = relative(publicDir, fullPath).replace(/\\\\/g, '/');\r\n\r\n        if (dirent.isDirectory()) {\r\n          walk(fullPath);\r\n        } else if (dirent.isFile()) {\r\n          result.add(relPath);\r\n          if (--pending === 0) {\r\n            callback(null, result);\r\n          }\r\n        } else {\r\n          if (--pending === 0) {\r\n            callback(null, result);\r\n          }\r\n        }\r\n      });\r\n    });\r\n  }\r\n\r\n  walk(publicDir);\r\n}\r\n\r\nexport function getContentType(filePath: string): string {\r\n  const ext = filePath.split('.').pop()?.toLowerCase() || '';\r\n  const types: Record<string, string> = {\r\n    'css': 'text/css',\r\n    'js': 'application/javascript',\r\n    'json': 'application/json',\r\n    'png': 'image/png',\r\n    'jpg': 'image/jpeg',\r\n    'jpeg': 'image/jpeg',\r\n    'gif': 'image/gif',\r\n    'svg': 'image/svg+xml',\r\n    'woff': 'font/woff',\r\n    'woff2': 'font/woff2',\r\n    'ttf': 'font/ttf',\r\n    'eot': 'application/vnd.ms-fontobject',\r\n    'ico': 'image/x-icon',\r\n    'wasm': 'application/wasm',\r\n    'zip': 'application/zip',\r\n    'rar': 'application/x-rar-compressed',\r\n    '7z': 'application/x-7z-compressed',\r\n    'tar': 'application/x-tar',\r\n    'gz': 'application/gzip',\r\n    'bz2': 'application/x-bzip2',\r\n    'xz': 'application/x-xz'\r\n  };\r\n  return types[ext] || 'application/octet-stream';\r\n}\r\n\r\n\r\n/**\r\n * 标准化路径，确保以 '/' 结尾\r\n */\r\nfunction normalizePath(p: string): string {\r\n  return resolve(p).replace(/\\\\/g, '/') + '/';\r\n}\r\n\r\n/**\r\n * 创建通用中间件：优先使用 public 资源，回退到 sourceAssetsPath\r\n * 对标 createStaticMiddleware 风格\r\n */\r\nexport function createMxCadAssetsMiddleware(\r\n  root: string,\r\n  options: Required<MxCadAssetsPluginOptions>,\r\n  publicDir: string,\r\n  logger?: any\r\n) {\r\n  const { outputDir, isWasmSt = false } = options;\r\n  // ✅ 1. 规范化路径\r\n  const basePath = `/${outputDir.replace(/^\\/+/, '')}`; // '/mxcadAppAssets'\r\n  const sourceAssetsRoot = normalizePath(root);\r\n\r\n  return async (req: any, res: any, next: () => void) => {\r\n    // ✅ 2. 基本校验\r\n    if (!req.url || typeof req.url !== 'string') {\r\n      return next();\r\n    }\r\n\r\n    // ✅ 3. 设置安全头（非 isWasmSt 模式）\r\n    if (!isWasmSt) {\r\n      res.setHeader('Cross-Origin-Opener-Policy', 'same-origin');\r\n      res.setHeader('Cross-Origin-Embedder-Policy', 'require-corp');\r\n    }\r\n\r\n    // ✅ 4. 解析 URL 路径（去 query，解码）\r\n    const urlPath = req.url.split('?')[0];\r\n    let filePath!: string;\r\n    let fileName!: string;\r\n\r\n    try {\r\n      const decodedPath = decodeURIComponent(urlPath);\r\n      // 规范化路径，防止 ../../ 越权\r\n      const normalizedPath = decodedPath.replace(/^[/\\\\]+/, '');\r\n\r\n      // ✅ 5. 优先：检查 public/${outputDir} 目录\r\n      const publicFilePath = join(publicDir, normalizedPath).replace(/\\\\/g, '/');\r\n\r\n      try {\r\n        const stat = await fs.promises.stat(publicFilePath);\r\n        if (stat.isFile()) {\r\n          filePath = publicFilePath;\r\n          fileName = basename(normalizedPath);\r\n          return serveFile(filePath, fileName, res, logger);\r\n        }\r\n      } catch (err) {\r\n        // public 中没有，继续查找 sourceAssetsPath\r\n      }\r\n\r\n      // ✅ 6. fallback：查找 sourceAssetsPath\r\n      const result = resolveSafePath(decodedPath, sourceAssetsRoot, basePath);\r\n      if (!result.success) {\r\n        res.statusCode = result.statusCode || 400;\r\n        return res.end(result.message);\r\n      }\r\n\r\n      if (result.filePath) filePath = result.filePath;\r\n      if (result.fileName) fileName = result.fileName;\r\n\r\n      // ✅ 7. 尝试由 handleConfigRequest 处理（如注入配置）\r\n      const handled = await handleConfigRequest(\r\n        filePath,\r\n        fileName,\r\n        options,\r\n        res,\r\n        logger\r\n      );\r\n      if (handled) return;\r\n\r\n      // ✅ 8. 确保是文件\r\n      const stat = await fs.promises.stat(filePath);\r\n      if (!stat.isFile()) {\r\n        res.statusCode = 404;\r\n        return res.end('File not found');\r\n      }\r\n\r\n      return serveFile(filePath, fileName, res, logger);\r\n    } catch (err) {\r\n      logger?.warn?.(`[MxCadAssets] Serve failed for ${req.url}: ${(err as Error).message}`);\r\n      if (res.headersSent) return;\r\n      res.statusCode = 404;\r\n      res.end('File not found');\r\n    }\r\n  };\r\n}\r\n\r\n/**\r\n * 封装文件响应逻辑（流式传输）\r\n */\r\nfunction serveFile(filePath: string, fileName: string, res: any, logger?: any) {\r\n  const stream = fs.createReadStream(filePath);\r\n\r\n  stream.on('error', (err: NodeJS.ErrnoException) => {\r\n    if (res.headersSent) return;\r\n    if (err.code === 'ENOENT' || err.code === 'EACCES') {\r\n      return res.statusCode === 200 ? res.end() : undefined;\r\n    }\r\n    logger?.error?.(`[MxCadAssets] Read error: ${err.message}`, err);\r\n    res.statusCode = 500;\r\n    res.end('Internal Server Error');\r\n  });\r\n\r\n  res.setHeader('Content-Type', getContentType(fileName));\r\n  res.setHeader('X-Content-Type-Options', 'nosniff');\r\n\r\n  stream.pipe(res);\r\n}"],"names":["fs","err","name","stat"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAcO,MAAM,YAAY,MAAM;AAUxB,MAAM,mBAAmB;AAAA;AAAA,EAE9B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAEF;AAo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"}