mxcad-app 1.0.63 → 1.0.65

package/dist/index.d.ts

@@ -224,16 +224,16 @@ declare module '@howdyjs/to-drag' {
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
-        Overline: {
+        Strike: {
             /**
              * Set the font size attribute
              */
-            setOverline: () => ReturnType;
+            setStrike: () => ReturnType;
             /**
              * Unset the font size attribute
              */
-            unsetOverline: () => ReturnType;
-            toggleOverline: () => ReturnType;
+            unsetStrike: () => ReturnType;
+            toggleStrike: () => ReturnType;
         };
     }
 }
@@ -257,16 +257,25 @@ declare module '@tiptap/core' {
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
-        Strike: {
+        TextDecoration: {
             /**
              * Set the font size attribute
              */
-            setStrike: () => ReturnType;
+            setTextDecoration: (textDecoration: string) => ReturnType;
             /**
              * Unset the font size attribute
              */
-            unsetStrike: () => ReturnType;
-            toggleStrike: () => ReturnType;
+            unsetTextDecoration: () => ReturnType;
+        };
+    }
+}
+
+
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        selectedText: {
+            setSelectedText: (from: number, to: number) => ReturnType;
+            unsetSelectedText: (from: number, to: number) => ReturnType;
         };
     }
 }
@@ -285,25 +294,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;
-        };
-    }
-}
-
-
-declare module "@tiptap/core" {
-    interface Commands<ReturnType> {
-        selectedText: {
-            setSelectedText: (from: number, to: number) => ReturnType;
-            unsetSelectedText: (from: number, to: number) => ReturnType;
+            unsetOverline: () => ReturnType;
+            toggleOverline: () => ReturnType;
         };
     }
 }

package/dist/mxcad.d.ts

@@ -8962,6 +8962,131 @@ declare module "mxcad" {
   	*/
   	copyData(fromRegion: McDbMxRegion): boolean;
   }
+  /**
+   * 视口对象
+   * @example
+   * ```ts
+   * ```
+   */
+  export  class McDbViewport extends McDbEntity {
+  	/**
+  	* 构造函数。
+  	* @param imp 内部对象。
+  	*/
+  	constructor(x?: object);
+  	/**
+  	* 设置高度
+  	* @example
+  	* ```ts
+  	* ```
+  	*/
+  	set height(val: number);
+  	/**
+  	 * 获取宽度
+  	 * @example
+  	 * ```ts
+  	 * ```
+  	 */
+  	get height(): number;
+  	/**
+  	* 设置宽度
+  	* @example
+  	* ```ts
+  	* ```
+  	*/
+  	set width(val: number);
+  	/**
+  	 * 获取高度
+  	 * @example
+  	 * ```ts
+  	 * ```
+  	 */
+  	get width(): number;
+  	/**
+  	* 设置视口中心位置
+  	* @example
+  	* ```ts
+  	* ```
+  	*/
+  	set centerPoint(vec: McGePoint3d);
+  	/**
+  	 * 获取视口中心位置
+  	 * @example
+  	 * ```ts
+  	 * ```
+  	 */
+  	get centerPoint(): McGePoint3d;
+  	/**
+  	* 设置视口目标位置
+  	* @example
+  	* ```ts
+  	* ```
+  	*/
+  	set viewTarget(vec: McGePoint3d);
+  	/**
+  	 * 获取视口目标位置
+  	 * @example
+  	 * ```ts
+  	 * ```
+  	 */
+  	get viewTarget(): McGePoint3d;
+  	/**
+  	* 设置视口方向
+  	* @example
+  	* ```ts
+  	* ```
+  	*/
+  	set viewDirection(vec: McGeVector3d);
+  	/**
+  	 * 获取视口方向
+  	 * @example
+  	 * ```ts
+  	 * ```
+  	 */
+  	get viewDirection(): McGeVector3d;
+  	/**
+  	* 设置可视高度
+  	* @example
+  	* ```ts
+  	* ```
+  	*/
+  	set viewHeight(val: number);
+  	/**
+  	 * 获取可视高度
+  	 * @example
+  	 * ```ts
+  	 * ```
+  	 */
+  	get viewHeight(): number;
+  	/**
+     * 设置视口可视位置
+     * @example
+     * ```ts
+     * ```
+     */
+  	set viewCenter(vec: McGePoint3d);
+  	/**
+  	 * 获取视口可视位置
+  	 * @example
+  	 * ```ts
+  	 * ```
+  	 */
+  	get viewCenter(): McGePoint3d;
+  	/**
+  	* 设置可视区域旋转角度
+  	* @example
+  	* ```ts
+  	* ```
+  	*/
+  	set twistAngle(val: number);
+  	/**
+  	 * 获取可视区域旋转角度
+  	 * @example
+  	 * ```ts
+  	 * ```
+  	 */
+  	get twistAngle(): number;
+  }
   /**
    * Dxf组码
    * @public
@@ -12428,6 +12553,18 @@ declare module "mxcad" {
   	 */
   	isBlockEditing(): boolean;
   	/**
+  	 * 开始进入视口编辑状态
+  	 */
+  	startViewPortEdit(idBlockRecord: McObjectId): boolean;
+  	/**
+  	 * 退出视口编辑状态
+  	 */
+  	endViewPortEdit(): boolean;
+  	/**
+  	 * 当前是否正视口编辑
+  	 */
+  	isViewPortEditing(): boolean;
+  	/**
     * 获取系统变量的点数值
     * @param varName 变量名称
     * @returns 变量的点数值
@@ -12708,7 +12845,7 @@ declare module "mxcad" {
   	 * | dimtfac | 146 | 与通过 DIMTXT 系统变量设置一样，指定分数和公差值的文字高度相对于标注文字高度的比例因子。|
   	 * | dimtm  |  48 | 为标注文字设置最小（即最低）公差限制。|
   	 * | dimtp  |  47 | 为标注文字设置最大（即最高）公差限制。|
-  	 * | dimtsz |  142 | 指定线性标注、半径标注以及直径标注中绘制的代替箭头的小斜线的尺寸。|
+  	 * | dimtsz |  142 | DIMTSZ = 0使用标准的实心箭头，DIMTSZ > 0 标注的箭头被替换为倾斜线（建筑标记），而 DIMTSZ 的数值就是这条倾斜线的长度|
   	 * | dimtvp |  145 | 控制标注文字在尺寸线上方或下方的垂直位置。|
   	 * | dimtxt |  140 | 指定标注文字的高度（除非当前文字样式具有固定的高度）。|
   	 * | dimaltrnd | 148 | 舍入换算标注单位。|
@@ -15254,6 +15391,7 @@ declare module "mxcad" {
   export interface ITableStyle {
   	name: string;
   	textHeight: number;
+  	outerBorderColor?: number;
   	borderColor: number;
   	textColor: number;
   	backgroundColor?: number | null;
@@ -15287,6 +15425,7 @@ declare module "mxcad" {
   	 */
   	borderLineType?: string;
   }
+  export type ITableStyleInfo = Partial<Omit<ITableStyle, "name">>;
   /**
    * 表格尺寸接口
    */
@@ -15359,6 +15498,10 @@ declare module "mxcad" {
   	 * */
   	get colWidth(): number;
   	set colWidth(val: number);
+  	private _style;
+  	get style(): Partial<Omit<ITableStyle, "name">> | null;
+  	/** 设置该表格样式 */
+  	setStyle(style: ITableStyleInfo): void;
   	private _position;
   	/** 表格位置和尺寸 - 渲染必需 */
   	get position(): McGePoint3d;

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

@@ -28,6 +28,7 @@ declare const _default: {
     "ITableDimensions",
     "ITablePosition",
     "ITableStyle",
+    "ITableStyleInfo",
     "IXlsxTableData",
     "IsZero",
     "LineInfo",
@@ -85,6 +86,7 @@ declare const _default: {
     "McDbText",
     "McDbTextStyleTable",
     "McDbTextStyleTableRecord",
+    "McDbViewport",
     "McDbWipeout",
     "McDbXline",
     "McDbXlsxTable",

package/packToolPlugin/{index-DbpgHLWF.mjs → index-CXnnCbjH.mjs}

@@ -31,6 +31,7 @@ const mxcad = [
   "ITableDimensions",
   "ITablePosition",
   "ITableStyle",
+  "ITableStyleInfo",
   "IXlsxTableData",
   "IsZero",
   "LineInfo",
@@ -88,6 +89,7 @@ const mxcad = [
   "McDbText",
   "McDbTextStyleTable",
   "McDbTextStyleTableRecord",
+  "McDbViewport",
   "McDbWipeout",
   "McDbXline",
   "McDbXlsxTable",
@@ -1520,4 +1522,4 @@ export {
   getContentType as h,
   resolveOptions as r
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index-DbpgHLWF.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    }\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 是否存在\r\n  if (!fs.existsSync(publicDir)) {\r\n    // 不存在则跳过扫描，直接复制\r\n    doCopy(src, dest, publicDir, new Set(), options, callback);\r\n    return;\r\n  }\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;AAoCO,SAAS,eAAe,UAAoC,IAAwC;AACzG,QAAM,WAA+C;AAAA,IACnD,WAAW,QAAQ,aAAa;AAAA,IAChC,cAAc,QAAQ,gBAAgB,CAAA;AAAA,IACtC,UAAU,QAAQ,YAAY;AAAA,IAC9B,wBAAwB,QAAQ,0BAA0B;AAAA;AAAA,IAE1D,yBAAyB,QAAQ,4BAA4B,CAAC,MAAM;AAAA,IACpE,yBAAyB,QAAQ,4BAA4B,CAAC,MAAM;AAAA,IACpE,qCAAqC,QAAQ,wCAAwC,CAAC,MAAM;AAAA,IAC5F,qBAAqB,QAAQ,wBAAwB,CAAC,MAAM;AAAA,IAC5D,6BAA6B,QAAQ,gCAAgC,CAAC,MAAM;AAAA;AAAA,EAAA;AAG9E,SAAO;AACT;AAoBO,SAAS,gBACd,QACA,MACA,UACkB;AAElB,MAAI,CAAC,UAAU,OAAO,WAAW,UAAU;AACzC,WAAO,EAAE,SAAS,OAAO,YAAY,KAAK,SAAS,cAAA;AAAA,EACrD;AAGA,MAAI,UAAU,OAAO,MAAM,GAAG,EAAE,CAAC,EAAE,MAAM,GAAG,EAAE,CAAC;AAG/C,MAAI;AACJ,MAAI;AACF,kBAAc,mBAAmB,OAAO;AAExC,QAAI,YAAY,SAAS,IAAI,GAAG;AAC9B,aAAO,EAAE,SAAS,OAAO,YAAY,KAAK,SAAS,cAAA;AAAA,IACrD;AAAA,EACF,SAAS,KAAK;AACZ,WAAO,EAAE,SAAS,OAAO,YAAY,KAAK,SAAS,uBAAA;AAAA,EACrD;AAGA,MAAI,YAAY,YAAY,WAAW,QAAQ,GAAG;AAChD,kBAAc,YAAY,MAAM,SAAS,MAAM;AAAA,EACjD;AAIA,QAAM,cAAc,YAAY,QAAQ,QAAQ,EAAE;AAGlD,QAAM,WAAW,KAAK,MAAM,eAAe,GAAG;AAG9C,MAAI;AACJ,MAAI;AACJ,MAAI;AACF,qBAAiB,QAAQ,QAAQ;AACjC,qBAAiB,QAAQ,IAAI;AAAA,EAC/B,SAAS,KAAK;AACZ,WAAO,EAAE,SAAS,OAAO,YAAY,KAAK,SAAS,yBAAA;AAAA,EACrD;AAGA,QAAM,oBAAoB,eAAe,QAAQ,OAAO,GAAG,IAAI;AAC/D,QAAM,oBAAoB,eAAe,QAAQ,OAAO,GAAG,IAAI;AAE/D,MAAI,CAAC,kBAAkB,WAAW,iBAAiB,GAAG;AACpD,WAAO,EAAE,SAAS,OAAO,YAAY,KAAK,SAAS,qCAAA;AAAA,EACrD;AAGA,QAAM,eAAe,YAAY,MAAM,GAAG,EAAE,OAAO,OAAO;AAC1D,QAAM,WAAW,aAAa,SAAS,IAAI,SAAS,aAAa,aAAa,SAAS,CAAC,CAAC,IAAI;AAG7F,SAAO;AAAA,IACL,SAAS;AAAA,IACT,UAAU;AAAA,IACV,SAAS;AAAA,IACT;AAAA,EAAA;AAEJ;AAIA,SAAS,iBACP,SACA,UACA,UACA,SACA,UACA;AACAA,cAAG,SAAS,SAAS,SAAS,OAAO,KAAK,YAAY;AACpD,QAAI,IAAK,QAAO,SAAS,GAAG;AAE5B,QAAI;AACF,UAAI,OAAO,QAAQ,KAAA,IAAS,KAAK,MAAM,OAAO,IAAI,CAAA;AAGlD,YAAM,WAAW,SAAS,QAAQ,YAAY,EAAE;AAChD,YAAM,eAAe,YAAY,WAAW,QAAQ,CAAC;AAErD,YAAM,cAAe,QAAgB,YAAY;AAEjD,UAAI,OAAO,gBAAgB,YAAY;AACrC,eAAO,MAAM,YAAY,IAAI;AAAA,MAC/B;AAEA,YAAM,OAAO,KAAK,UAAU,MAAM,MAAM,CAAC;AACzCA,kBAAG,UAAU,UAAU,MAAM,SAAS,QAAQ;AAAA,IAChD,SAASC,MAAU;AACjB,aAAO,SAASA,IAAG;AAAA,IACrB;AAAA,EACF,CAAC;AACH;AAKA,eAAsB,oBACpB,UACA,UACA,SACA,KACA,QACkB;;AAElB,MAAI,CAAE,iBAAuC,SAAS,QAAQ,GAAG;AAC/D,WAAO;AAAA,EACT;AAEA,MAAI;AACF,UAAM,UAAU,MAAMD,YAAG,SAAS,SAAS,UAAU,OAAO;AAC5D,QAAI,OAAO,QAAQ,KAAA,IAAS,KAAK,MAAM,OAAO,IAAI,CAAA;AAElD,UAAM,eAAe,YAAY,WAAW,SAAS,QAAQ,YAAY,EAAE,CAAC,CAAC;AAC7E,UAAM,cAAe,QAAgB,YAAY;AAEjD,QAAI,OAAO,gBAAgB,YAAY;AACrC,aAAO,MAAM,YAAY,IAAI;AAAA,IAC/B;AAEA,QAAI,UAAU,gBAAgB,kBAAkB;AAChD,QAAI,UAAU,iBAAiB,UAAU;AACzC,QAAI,IAAI,KAAK,UAAU,MAAM,MAAM,CAAC,CAAC;AACrC,WAAO;AAAA,EACT,SAAS,KAAU;AACjB,2CAAQ,UAAR,gCAAgB,oCAAoC,QAAQ,KAAK,IAAI,OAAO;AAC5E,QAAI,CAAC,IAAI,aAAa;AACpB,UAAI,UAAU,gBAAgB,YAAY;AAC1C,UAAI,aAAa;AACjB,UAAI,IAAI,uBAAuB;AAAA,IACjC;AACA,WAAO;AAAA,EACT;AACF;AAGO,SAAS,gCAAgC,SAA6C;AAC3F,SAAO,OAAO,KAAU,KAAU,SAAc;AAC9C,QAAI,CAAC,QAAQ,UAAU;AACrB,UAAI,UAAU,8BAA8B,aAAa;AACzD,UAAI,UAAU,gCAAgC,cAAc;AAAA,IAC9D;AACA,SAAA;AAAA,EACF;AACF;AAEO,SAAS,WAAW,KAAqB;AAC9C,SAAO,IACJ,QAAQ,qBAAqB,CAAC,GAAG,QAAQ,IAAI,YAAA,CAAa,EAC1D,QAAQ,MAAM,CAAA,MAAK,EAAE,aAAa;AACvC;AAGO,MAAM,YAAY;AAAA,EACvB,OAAO;AAAA,EACP,SAAS;AAAA,EACT,WAAW;AAAA,EACX,sBAAsB;AAAA,EACtB,aAAa;AAAA,EACb,SAAS;AACX;AAEA,MAAM,cAAc,oBAAI,IAAI,CAAC,SAAS,QAAQ,CAAC;AAK/C,SAAS,mBAAmB,cAA8B;AACxD,QAAM,UAAU,QAAQ,IAAA;AACxB,QAAM,UAAU,QAAQ,SAAS,gBAAgB,aAAa,MAAM;AACpE,QAAM,YAAY,QAAQ,SAAS,YAAY;AAE/C,MAAI;AAEF,QAAI,CAACA,YAAG,WAAW,OAAO,GAAG;AAC3B,cAAQ,KAAK,mCAAmC,OAAO,EAAE;AACzD;AAAA,IACF;AAGA,QAAI,CAACA,YAAG,WAAW,SAAS,GAAG;AAC7BA,kBAAG,cAAc,WAAW,IAAI,OAAO;AACvC,cAAQ,IAAI,eAAe,SAAS,EAAE;AAAA,IACxC;AAEA,QAAI,UAAUA,YAAG,aAAa,WAAW,OAAO;AAChD,UAAM,QAAQ,QAAQ,MAAM,OAAO;AAGnC,UAAM,iBAAiB;AACvB,UAAM,eAAyB,CAAA;AAC/B,UAAM,cAAwB,CAAA;AAE9B,UAAM,QAAQ,CAAA,SAAQ;AACpB,YAAM,QAAQ,KAAK,KAAA,EAAO,MAAM,cAAc;AAC9C,UAAI,OAAO;AACT,cAAM,WAAW,MAAM,CAAC;AACxB,cAAM,aAAa,SAAS,QAAQ,YAAY,EAAE;AAClD,qBAAa,KAAK,UAAU;AAAA,MAC9B,OAAO;AACL,oBAAY,KAAK,IAAI;AAAA,MACvB;AAAA,IACF,CAAC;AAGD,UAAM,eAAe,IAAI,IAAY,WAAW;AAEhD,iBAAa,QAAQ,CAAAE,UAAQ;AAE3B,UAAIA,SAAQ,WAAW;AACrB,cAAM,UAAU,QAAQ,SAAS,GAAGA,KAAI,OAAO;AAC/C,YAAIF,YAAG,WAAW,OAAO,GAAG;AAC1B,uBAAa,IAAIE,KAAI;AAAA,QACvB;AAAA,MACF;AAAA,IACF,CAAC;AAGD,UAAM,YAAY,CAAC,SAAS,QAAQ,EACjC,OAAO,CAAAA,UAAQ,aAAa,IAAIA,KAAI,CAAC,EACrC,IAAI,CAAAA,UAAQ,0BAA0BA,KAAI,WAAW;AAGxD,UAAM,KAAK,YAAY,EACpB,OAAO,CAAAA,UAAQ,CAAC,YAAY,IAAIA,KAAI,CAAC,EACrC,QAAQ,CAAAA,UAAQ;AACf,gBAAU,KAAK,0BAA0BA,KAAI,WAAW;AAAA,IAC1D,CAAC;AAGH,UAAM,cAAc,CAAC,GAAG,WAAW,IAAI,GAAG,YAAY,OAAO,CAAA,MAAK,EAAE,KAAA,EAAO,SAAS,CAAC,CAAC;AAGtF,UAAM,eAAe,YAAY;AAAA,MAAO,CAAC,MAAM,GAAG,QAChD,EAAE,KAAK,KAAA,MAAW,MAAM,IAAI,KAAK,IAAI,IAAI,CAAC,EAAE,WAAW;AAAA,IAAA;AAGzD,UAAM,aAAa,aAAa,KAAK,IAAI,EAAE,SAAS;AAGpD,QAAI,QAAQ,KAAA,MAAW,WAAW,QAAQ;AACxCF,kBAAG,cAAc,WAAW,YAAY,OAAO;AAC/C,cAAQ,IAAI,sCAAsC;AAAA,IACpD;AAAA,EACF,SAAS,KAAK;AACZ,YAAQ,MAAM,eAAe,GAAG;AAAA,EAClC;AACF;AAKO,MAAM,sBAA8C;AAAA,EACzD,OAAO;AAAA,EACP,QAAQ;AACV;AACO,SAAS,aACd,cAC2B;AAC3B,qBAAmB,YAAY;AAC/B,QAAM,SAAoC,EAAE,GAAG,oBAAA;AAC/C,MAAI,CAAC,MAAM,QAAQ,YAAY,EAAG,QAAO;AACzC,eAAa,QAAQ,CAAAE,UAAQ;AAC3B,QAAIA,SAAQ,WAAW;AACrB,aAAOA,KAAI,IAAI,UAAUA,KAA8B;AAAA,IACzD;AAAA,EACF,CAAC;AACD,SAAO;AACT;AAEO,SAAS,sBAA8B;AAC5C,MAAI;AACJ,MAAI,OAAO,eAAe,aAAa;AACrC,kBAAc;AAAA,EAChB,OAAO;AAEL,kBAAc,cAAc,YAAY,GAAG;AAAA,EAC7C;AACA,QAAM,cAAc,QAAQ,aAAa,MAAM,MAAM,IAAI;AACzD,QAAM,aAAa,QAAQ,aAAa,MAAM,QAAQ,gBAAgB;AACtE,MAAI,CAACF,YAAG,WAAW,UAAU,GAAG;AAC9B,UAAM,IAAI,MAAM,mCAAmC,UAAU,EAAE;AAAA,EACjE;AACA,SAAO;AACT;AAOO,SAAS,4BAA4B,YAA4B;AACtE,SAAO;AAAA;AAAA,4CAEmC,UAAU;AAAA;AAAA,IAElD,KAAA;AACJ;AAEO,SAAS,QACd,KACA,MACA,WACA,SACA,UACM;AAEN,MAAI,CAACA,YAAG,WAAW,SAAS,GAAG;AAE7B,WAAO,KAAK,MAAM,+BAAe,IAAA,GAAO,SAAS,QAAQ;AACzD;AAAA,EACF;AAEA,gBAAc,WAAW,CAAC,KAAK,gBAAgB;AAC7C,QAAI,IAAK,QAAO,SAAS,GAAG;AAG5B,WAAO,KAAK,MAAM,WAAW,aAAc,SAAS,QAAQ;AAAA,EAC9D,CAAC;AACH;AAGA,SAAS,OACP,KACA,MACA,WACA,aACA,SACA,UACA;AACAA,cAAG,MAAM,MAAM,EAAE,WAAW,KAAA,GAAQ,CAAC,QAAQ;AAC3C,QAAI,IAAK,QAAO,SAAS,GAAG;AAE5BA,gBAAG,QAAQ,KAAK,EAAE,eAAe,QAAQ,CAACC,MAAK,YAAY;AACzD,UAAIA,KAAK,QAAO,SAASA,IAAG;AAE5B,UAAI,UAAU,QAAQ;AACtB,UAAI,YAAY,EAAG,QAAO,SAAA;AAG1B,YAAM,iBAAiB,CAAC,KAAK;AAE7B,cAAQ,QAAQ,CAAC,WAAW;AAC1B,cAAM,UAAU,QAAQ,KAAK,OAAO,IAAI;AACxC,cAAM,WAAW,QAAQ,MAAM,OAAO,IAAI;AAC1C,cAAM,eAAe,SAAS,KAAK,OAAO,EAAE,QAAQ,OAAO,GAAG;AAG9D,YACE,CAAC,QAAQ,0BACT,eAAe,KAAK,SAAO,aAAa,SAAS,GAAG,CAAC,GACrD;AACA,cAAI,EAAE,YAAY,EAAG,UAAA;AACrB;AAAA,QACF;AAEA,YAAI,OAAO,eAAe;AACxB,iBAAO,SAAS,UAAU,WAAW,aAAa,SAAS,MAAM;AAC/D,gBAAI,EAAE,YAAY,EAAG,UAAA;AAAA,UACvB,CAAC;AAAA,QACH,WAAW,OAAO,UAAU;AAC1B,cAAI,YAAY,IAAI,YAAY,GAAG;AACjC,kBAAM,iBAAiB,QAAQ,WAAW,YAAY;AACtDD,wBAAG,SAAS,gBAAgB,UAAU,CAACC,SAAQ;AAC7C,kBAAIA,KAAK,QAAO,SAASA,IAAG;AAC5B,kBAAI,EAAE,YAAY,EAAG,UAAA;AAAA,YACvB,CAAC;AAAA,UACH,WAAW,iBAAiB,SAAS,YAAY,GAAG;AAClD,6BAAiB,SAAS,UAAU,cAAc,SAAS,CAACA,SAAQ;AAClE,kBAAIA,KAAK,QAAO,SAASA,IAAG;AAC5B,kBAAI,EAAE,YAAY,EAAG,UAAA;AAAA,YACvB,CAAC;AAAA,UACH,OAAO;AACLD,wBAAG,SAAS,SAAS,UAAU,CAACC,SAAQ;AACtC,kBAAIA,KAAK,QAAO,SAASA,IAAG;AAC5B,kBAAI,EAAE,YAAY,EAAG,UAAA;AAAA,YACvB,CAAC;AAAA,UACH;AAAA,QACF,OAAO;AACL,cAAI,EAAE,YAAY,EAAG,UAAA;AAAA,QACvB;AAAA,MACF,CAAC;AAAA,IACH,CAAC;AAAA,EACH,CAAC;AACH;AAEA,SAAS,cACP,WACA,UACA;AACA,QAAM,6BAAa,IAAA;AAEnB,WAAS,KAAK,KAAa;AACzBD,gBAAG,QAAQ,KAAK,EAAE,eAAe,QAAQ,CAAC,KAAK,YAAY;AACzD,UAAI,IAAK,QAAO,SAAS,GAAG;AAE5B,UAAI,UAAU,QAAQ;AACtB,UAAI,YAAY,GAAG;AACjB,eAAO,SAAS,MAAM,MAAM;AAAA,MAC9B;AAEA,cAAQ,QAAQ,CAAC,WAAW;AAC1B,cAAM,WAAW,QAAQ,KAAK,OAAO,IAAI;AACzC,cAAM,UAAU,SAAS,WAAW,QAAQ,EAAE,QAAQ,OAAO,GAAG;AAEhE,YAAI,OAAO,eAAe;AACxB,eAAK,QAAQ;AAAA,QACf,WAAW,OAAO,UAAU;AAC1B,iBAAO,IAAI,OAAO;AAClB,cAAI,EAAE,YAAY,GAAG;AACnB,qBAAS,MAAM,MAAM;AAAA,UACvB;AAAA,QACF,OAAO;AACL,cAAI,EAAE,YAAY,GAAG;AACnB,qBAAS,MAAM,MAAM;AAAA,UACvB;AAAA,QACF;AAAA,MACF,CAAC;AAAA,IACH,CAAC;AAAA,EACH;AAEA,OAAK,SAAS;AAChB;AAEO,SAAS,eAAe,UAA0B;;AACvD,QAAM,QAAM,cAAS,MAAM,GAAG,EAAE,IAAA,MAApB,mBAA2B,kBAAiB;AACxD,QAAM,QAAgC;AAAA,IACpC,OAAO;AAAA,IACP,MAAM;AAAA,IACN,QAAQ;AAAA,IACR,OAAO;AAAA,IACP,OAAO;AAAA,IACP,QAAQ;AAAA,IACR,OAAO;AAAA,IACP,OAAO;AAAA,IACP,QAAQ;AAAA,IACR,SAAS;AAAA,IACT,OAAO;AAAA,IACP,OAAO;AAAA,IACP,OAAO;AAAA,IACP,QAAQ;AAAA,IACR,OAAO;AAAA,IACP,OAAO;AAAA,IACP,MAAM;AAAA,IACN,OAAO;AAAA,IACP,MAAM;AAAA,IACN,OAAO;AAAA,IACP,MAAM;AAAA,EAAA;AAER,SAAO,MAAM,GAAG,KAAK;AACvB;AAMA,SAAS,cAAc,GAAmB;AACxC,SAAO,QAAQ,CAAC,EAAE,QAAQ,OAAO,GAAG,IAAI;AAC1C;AAMO,SAAS,4BACd,MACA,SACA,WACA,QACA;AACA,QAAM,EAAE,WAAW,WAAW,MAAA,IAAU;AAExC,QAAM,WAAW,IAAI,UAAU,QAAQ,QAAQ,EAAE,CAAC;AAClD,QAAM,mBAAmB,cAAc,IAAI;AAE3C,SAAO,OAAO,KAAU,KAAU,SAAqB;;AAErD,QAAI,CAAC,IAAI,OAAO,OAAO,IAAI,QAAQ,UAAU;AAC3C,aAAO,KAAA;AAAA,IACT;AAGA,QAAI,CAAC,UAAU;AACb,UAAI,UAAU,8BAA8B,aAAa;AACzD,UAAI,UAAU,gCAAgC,cAAc;AAAA,IAC9D;AAGA,UAAM,UAAU,IAAI,IAAI,MAAM,GAAG,EAAE,CAAC;AACpC,QAAI;AACJ,QAAI;AAEJ,QAAI;AACF,YAAM,cAAc,mBAAmB,OAAO;AAE9C,YAAM,iBAAiB,YAAY,QAAQ,WAAW,EAAE;AAGxD,YAAM,iBAAiB,KAAK,WAAW,cAAc,EAAE,QAAQ,OAAO,GAAG;AAEzE,UAAI;AACF,cAAMG,QAAO,MAAMH,YAAG,SAAS,KAAK,cAAc;AAClD,YAAIG,MAAK,UAAU;AACjB,qBAAW;AACX,qBAAW,SAAS,cAAc;AAClC,iBAAO,UAAU,UAAU,UAAU,KAAK,MAAM;AAAA,QAClD;AAAA,MACF,SAAS,KAAK;AAAA,MAEd;AAGA,YAAM,SAAS,gBAAgB,aAAa,kBAAkB,QAAQ;AACtE,UAAI,CAAC,OAAO,SAAS;AACnB,YAAI,aAAa,OAAO,cAAc;AACtC,eAAO,IAAI,IAAI,OAAO,OAAO;AAAA,MAC/B;AAEA,UAAI,OAAO,SAAU,YAAW,OAAO;AACvC,UAAI,OAAO,SAAU,YAAW,OAAO;AAGvC,YAAM,UAAU,MAAM;AAAA,QACpB;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MAAA;AAEF,UAAI,QAAS;AAGb,YAAM,OAAO,MAAMH,YAAG,SAAS,KAAK,QAAQ;AAC5C,UAAI,CAAC,KAAK,UAAU;AAClB,YAAI,aAAa;AACjB,eAAO,IAAI,IAAI,gBAAgB;AAAA,MACjC;AAEA,aAAO,UAAU,UAAU,UAAU,KAAK,MAAM;AAAA,IAClD,SAAS,KAAK;AACZ,6CAAQ,SAAR,gCAAe,kCAAkC,IAAI,GAAG,KAAM,IAAc,OAAO;AACnF,UAAI,IAAI,YAAa;AACrB,UAAI,aAAa;AACjB,UAAI,IAAI,gBAAgB;AAAA,IAC1B;AAAA,EACF;AACF;AAKA,SAAS,UAAU,UAAkB,UAAkB,KAAU,QAAc;AAC7E,QAAM,SAASA,YAAG,iBAAiB,QAAQ;AAE3C,SAAO,GAAG,SAAS,CAAC,QAA+B;;AACjD,QAAI,IAAI,YAAa;AACrB,QAAI,IAAI,SAAS,YAAY,IAAI,SAAS,UAAU;AAClD,aAAO,IAAI,eAAe,MAAM,IAAI,QAAQ;AAAA,IAC9C;AACA,2CAAQ,UAAR,gCAAgB,6BAA6B,IAAI,OAAO,IAAI;AAC5D,QAAI,aAAa;AACjB,QAAI,IAAI,uBAAuB;AAAA,EACjC,CAAC;AAED,MAAI,UAAU,gBAAgB,eAAe,QAAQ,CAAC;AACtD,MAAI,UAAU,0BAA0B,SAAS;AAEjD,SAAO,KAAK,GAAG;AACjB;"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index-CXnnCbjH.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    }\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 是否存在\r\n  if (!fs.existsSync(publicDir)) {\r\n    // 不存在则跳过扫描，直接复制\r\n    doCopy(src, dest, publicDir, new Set(), options, callback);\r\n    return;\r\n  }\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;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"}

package/packToolPlugin/{index-DEvHdVxU.js → index-DubbRmDj.js}

@@ -33,6 +33,7 @@ const mxcad = [
   "ITableDimensions",
   "ITablePosition",
   "ITableStyle",
+  "ITableStyleInfo",
   "IXlsxTableData",
   "IsZero",
   "LineInfo",
@@ -90,6 +91,7 @@ const mxcad = [
   "McDbText",
   "McDbTextStyleTable",
   "McDbTextStyleTableRecord",
+  "McDbViewport",
   "McDbWipeout",
   "McDbXline",
   "McDbXlsxTable",
@@ -1306,7 +1308,7 @@ function getSourceAssetsPath() {
   if (typeof __filename !== "undefined") {
     currentFile = __filename;
   } else {
-    currentFile = url.fileURLToPath(typeof document === "undefined" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("index-DEvHdVxU.js", document.baseURI).href);
+    currentFile = url.fileURLToPath(typeof document === "undefined" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("index-DubbRmDj.js", document.baseURI).href);
   }
   const packageRoot = path.resolve(currentFile, "..", "..", "..");
   const assetsPath = path.resolve(packageRoot, name, "dist", "mxcadAppAssets");
@@ -1520,4 +1522,4 @@ exports.getContentType = getContentType;
 exports.getExternals = getExternals;
 exports.getSourceAssetsPath = getSourceAssetsPath;
 exports.resolveOptions = resolveOptions;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index-DEvHdVxU.js","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    }\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 是否存在\r\n  if (!fs.existsSync(publicDir)) {\r\n    // 不存在则跳过扫描，直接复制\r\n    doCopy(src, dest, publicDir, new Set(), options, callback);\r\n    return;\r\n  }\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":["join","resolve","basename","err","name","fileURLToPath","relative","stat"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAcO,MAAM,YAAY,MAAM;AAUxB,MAAM,mBAAmB;AAAA;AAAA,EAE9B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index-DubbRmDj.js","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    }\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 是否存在\r\n  if (!fs.existsSync(publicDir)) {\r\n    // 不存在则跳过扫描，直接复制\r\n    doCopy(src, dest, publicDir, new Set(), options, callback);\r\n    return;\r\n  }\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":["join","resolve","basename","err","name","fileURLToPath","relative","stat"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAcO,MAAM,YAAY,MAAM;AAUxB,MAAM,mBAAmB;AAAA;AAAA,EAE9B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAA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"}

package/packToolPlugin/rollup/index.cjs

@@ -2,7 +2,7 @@
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 const path = require("path");
 const fs = require("fs");
-const index = require("../index-DEvHdVxU.js");
+const index = require("../index-DubbRmDj.js");
 function _interopNamespaceDefault(e) {
   const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
   if (e) {

package/packToolPlugin/rollup/index.mjs

@@ -1,6 +1,6 @@
 import { resolve } from "path";
 import * as fs from "fs";
-import { r as resolveOptions, g as getSourceAssetsPath, a as getExternals, f as generateRuntimeConfigScript, c as copyDir, h as getContentType, b as createGlobalUniversalMiddleware, e as getApiMap } from "../index-DbpgHLWF.mjs";
+import { r as resolveOptions, g as getSourceAssetsPath, a as getExternals, f as generateRuntimeConfigScript, c as copyDir, h as getContentType, b as createGlobalUniversalMiddleware, e as getApiMap } from "../index-CXnnCbjH.mjs";
 function mxcadAssetsPlugin(options = {}) {
   const resolvedOptions = resolveOptions(options);
   const sourceAssetsPath = getSourceAssetsPath();

package/packToolPlugin/vite/index.cjs

@@ -2,7 +2,7 @@
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 const path = require("path");
 const fs = require("fs");
-const index = require("../index-DEvHdVxU.js");
+const index = require("../index-DubbRmDj.js");
 function _interopNamespaceDefault(e) {
   const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
   if (e) {

package/packToolPlugin/vite/index.mjs

@@ -1,6 +1,6 @@
 import { resolve } from "path";
 import * as fs from "fs";
-import { r as resolveOptions, g as getSourceAssetsPath, a as getExternals, c as copyDir, b as createGlobalUniversalMiddleware, d as createMxCadAssetsMiddleware, e as getApiMap, f as generateRuntimeConfigScript } from "../index-DbpgHLWF.mjs";
+import { r as resolveOptions, g as getSourceAssetsPath, a as getExternals, c as copyDir, b as createGlobalUniversalMiddleware, d as createMxCadAssetsMiddleware, e as getApiMap, f as generateRuntimeConfigScript } from "../index-CXnnCbjH.mjs";
 function mxcadAssetsPlugin(options = {}) {
   let config;
   const resolvedOptions = resolveOptions(options);

package/packToolPlugin/webpack/index.cjs

@@ -3,7 +3,7 @@ Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toString
 const webpack = require("webpack");
 const fs = require("fs");
 const path = require("path");
-const index = require("../index-DEvHdVxU.js");
+const index = require("../index-DubbRmDj.js");
 function _interopNamespaceDefault(e) {
   const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
   if (e) {

package/packToolPlugin/webpack/index.mjs

@@ -1,7 +1,7 @@
 import { Compilation } from "webpack";
 import * as fs from "fs";
 import * as path from "path";
-import { r as resolveOptions, g as getSourceAssetsPath, a as getExternals, b as createGlobalUniversalMiddleware, d as createMxCadAssetsMiddleware, c as copyDir, f as generateRuntimeConfigScript } from "../index-DbpgHLWF.mjs";
+import { r as resolveOptions, g as getSourceAssetsPath, a as getExternals, b as createGlobalUniversalMiddleware, d as createMxCadAssetsMiddleware, c as copyDir, f as generateRuntimeConfigScript } from "../index-CXnnCbjH.mjs";
 class MxCadAssetsWebpackPlugin {
   options;
   sourceAssetsPath;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mxcad-app",
-  "version": "1.0.63",
+  "version": "1.0.65",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -33,7 +33,8 @@
     "./style": {
       "import": "./dist/styles/style.css",
       "browser": "./dist/styles/style.css",
-      "require": "./dist/styles/style.css"
+      "require": "./dist/styles/style.css",
+      "types": "./style.d.ts"
     },
     "./vite": {
       "import": "./packToolPlugin/vite/index.mjs",
@@ -59,6 +60,7 @@
     "README.md",
     "packToolPlugin",
     "package.json",
-    "postinstall.js"
+    "postinstall.js",
+    "style.d.ts"
   ]
 }

package/style.d.ts

@@ -0,0 +1,5 @@
+// style.d.ts
+declare module "mxcad-app/style" {
+  const css: string;
+  export default css;
+}