@meng-xi/vite-plugin 0.1.4 → 0.1.6

package/dist/common/fs/index.d.ts

@@ -45,75 +45,12 @@ interface CopyResult {
     executionTime: number;
 }
 
-/**
- * 文件/目录条目信息
- */
-interface FileEntry {
-    /** 完整路径 */
-    path: string;
-    /** 是否为文件 */
-    isFile: boolean;
-    /** 是否为目录 */
-    isDirectory: boolean;
-}
 /**
  * 检查源文件是否存在
  * @param sourcePath 源文件路径
  * @throws 当源文件不存在或无法访问时抛出异常
  */
 declare function checkSourceExists(sourcePath: string): Promise<void>;
-/**
- * 创建目标目录
- * @param targetPath 目标目录路径
- * @throws 当无法创建目标目录时抛出异常
- */
-declare function ensureTargetDir(targetPath: string): Promise<void>;
-/**
- * 读取目录内容（优化版：一次性获取文件类型信息）
- * @param dirPath 目录路径
- * @param recursive 是否递归读取
- * @returns 文件和目录条目列表
- */
-declare function readDirRecursive(dirPath: string, recursive: boolean): Promise<FileEntry[]>;
-/**
- * 检查文件是否需要更新
- * @param sourceFile 源文件路径
- * @param targetFile 目标文件路径
- * @returns 是否需要更新
- */
-declare function shouldUpdateFile(sourceFile: string, targetFile: string): Promise<boolean>;
-/**
- * 检查文件是否存在
- * @param filePath 文件路径
- * @returns 是否存在
- *
- * @example
- * ```typescript
- * if (await fileExists('/path/to/file')) {
- *   console.log('文件存在')
- * }
- * ```
- */
-declare function fileExists(filePath: string): Promise<boolean>;
-/**
- * 带并发限制的批量执行
- *
- * @param items 待处理项
- * @param handler 处理函数
- * @param concurrency 并发数
- * @returns 处理结果数组，顺序与输入项对应
- *
- * @example
- * ```typescript
- * const urls = ['url1', 'url2', 'url3', 'url4', 'url5']
- * const results = await runWithConcurrency(
- *   urls,
- *   async (url) => fetch(url),
- *   3 // 最多同时处理3个请求
- * )
- * ```
- */
-declare function runWithConcurrency<T, R>(items: T[], handler: (item: T) => Promise<R>, concurrency: number): Promise<R[]>;
 /**
  * 执行文件复制操作（优化版：并行IO）
  * @param sourcePath 源文件或目录路径
@@ -130,21 +67,6 @@ declare function copySourceToTarget(sourcePath: string, targetPath: string, opti
  * @throws 当写入过程中出现错误时抛出异常
  */
 declare function writeFileContent(filePath: string, content: string): Promise<void>;
-/**
- * 读取文件内容
- * @param filePath 文件路径
- * @returns 文件内容字符串
- * @throws 当读取过程中出现错误时抛出异常
- */
-declare function readFileContent(filePath: string): Promise<string>;
-/**
- * 同步读取文件内容
- * @param filePath 文件路径
- * @returns 文件内容字符串
- * @throws 当读取过程中出现错误时抛出异常
- * @deprecated 请使用异步版本 readFileContent
- */
-declare function readFileSync(filePath: string): string;
 /**
  * 扫描目录中的文件信息
  */
@@ -177,20 +99,11 @@ interface ScanDirectoryOptions {
  *
  * @description 递归遍历指定目录下的所有文件，收集每个文件的大小和扩展名信息，
  * 支持按扩展名、路径模式和自定义过滤函数进行过滤。
- * 这是通用的目录扫描函数，可被不同插件复用。
  *
  * @example
  * ```typescript
- * // 扫描所有 .js 文件
  * const jsFiles = await scanDirectory('dist', { includeExtensions: ['.js'] })
- *
- * // 排除 node_modules
  * const files = await scanDirectory('dist', { excludePatterns: ['node_modules'] })
- *
- * // 使用自定义过滤
- * const largeFiles = await scanDirectory('dist', {
- *   filter: (filePath, ext, size) => size > 1024
- * })
  * ```
  */
 declare function scanDirectory(dirPath: string, options?: ScanDirectoryOptions): Promise<ScannedFile[]>;
@@ -209,10 +122,44 @@ declare function scanDirectory(dirPath: string, options?: ScanDirectoryOptions):
  * @example
  * ```typescript
  * await writeJsonReport('dist/report.json', { timestamp: Date.now(), stats: [] })
- * await writeJsonReport('dist/report.json', data, 4)
  * ```
  */
 declare function writeJsonReport(filePath: string, data: object, indent?: number): Promise<void>;
+/**
+ * 同步写入文件内容，自动创建不存在的目录
+ *
+ * @param filePath 文件路径
+ * @param content 文件内容
+ *
+ * @description 同步写入文件，如果目标目录不存在会自动递归创建。
+ * 适用于构建钩子中需要同步写入的场景（如 `transform` 钩子）。
+ *
+ * @throws 当文件写入失败时（如权限不足），抛出 `NodeJS.ErrnoException`
+ *
+ * @example
+ * ```typescript
+ * writeFileSyncSafely('/project/src/auto-imports.d.ts', 'declare global { ... }')
+ * ```
+ */
+declare function writeFileSyncSafely(filePath: string, content: string): void;
+/**
+ * 检查文件内容是否需要更新（同步版本）
+ *
+ * @param filePath 文件路径
+ * @param newContent 新生成的文件内容
+ * @returns 如果需要更新返回 `true`，否则返回 `false`
+ *
+ * @description 对比现有文件内容与新生成的内容，
+ * 仅在内容发生变化时才需要写入，减少不必要的文件 IO 操作。
+ *
+ * @example
+ * ```typescript
+ * if (shouldUpdateFileContent('/project/src/auto-imports.d.ts', newContent)) {
+ *   writeFileSyncSafely('/project/src/auto-imports.d.ts', newContent)
+ * }
+ * ```
+ */
+declare function shouldUpdateFileContent(filePath: string, newContent: string): boolean;
 
-export { checkSourceExists, copySourceToTarget, ensureTargetDir, fileExists, readDirRecursive, readFileContent, readFileSync, runWithConcurrency, scanDirectory, shouldUpdateFile, writeFileContent, writeJsonReport };
+export { checkSourceExists, copySourceToTarget, scanDirectory, shouldUpdateFileContent, writeFileContent, writeFileSyncSafely, writeJsonReport };
 export type { CopyOptions, CopyResult, ScanDirectoryOptions, ScannedFile };

package/dist/common/fs/index.mjs

@@ -1 +1 @@
-import r from"fs";import w from"path";const T=10;async function k(u){try{await r.promises.access(u,r.constants.F_OK)}catch(t){const e=t;throw e.code==="ENOENT"?new Error(`\u590D\u5236\u6587\u4EF6\u5931\u8D25\uFF1A\u6E90\u6587\u4EF6\u4E0D\u5B58\u5728 - ${u}`):e.code==="EACCES"?new Error(`\u590D\u5236\u6587\u4EF6\u5931\u8D25\uFF1A\u6CA1\u6709\u6743\u9650\u8BBF\u95EE\u6E90\u6587\u4EF6 - ${u}`):new Error(`\u590D\u5236\u6587\u4EF6\u5931\u8D25\uFF1A\u68C0\u67E5\u6E90\u6587\u4EF6\u65F6\u51FA\u9519 - ${u}\uFF0C\u9519\u8BEF\uFF1A${e.message}`)}}async function D(u){try{await r.promises.mkdir(u,{recursive:!0})}catch(t){const e=t;throw e.code==="EACCES"?new Error(`\u590D\u5236\u6587\u4EF6\u5931\u8D25\uFF1A\u6CA1\u6709\u6743\u9650\u521B\u5EFA\u76EE\u6807\u76EE\u5F55 - ${u}`):new Error(`\u590D\u5236\u6587\u4EF6\u5931\u8D25\uFF1A\u521B\u5EFA\u76EE\u6807\u76EE\u5F55\u65F6\u51FA\u9519 - ${u}\uFF0C\u9519\u8BEF\uFF1A${e.message}`)}}async function h(u,t){const e=await r.promises.readdir(u,{withFileTypes:!0}),i=[];for(const n of e){const a=w.join(u,n.name),F=n.isFile(),c=n.isDirectory();if(i.push({path:a,isFile:F,isDirectory:c}),c&&t){const E=await h(a,t);i.push(...E)}}return i}async function B(u,t){try{const[e,i]=await Promise.all([r.promises.stat(u),r.promises.stat(t)]);return e.mtimeMs>i.mtimeMs||e.size!==i.size}catch{return!0}}async function C(u){try{return await r.promises.access(u,r.constants.F_OK),!0}catch{return!1}}async function g(u,t,e){const i=[];let n=0;async function a(){for(;n<u.length;){const c=n++,E=await t(u[c]);i[c]=E}}const F=Array(Math.min(e,u.length)).fill(null).map(()=>a());return await Promise.all(F),i}async function v(u,t,e){const i=Date.now(),{recursive:n,overwrite:a,incremental:F=!1,parallelLimit:c=T}=e;let E=0,p=0,l=0;if((await r.promises.stat(u)).isDirectory()){await D(t);const o=await h(u,n),f=o.filter(s=>s.isFile);l=o.filter(s=>s.isDirectory).length;const $=new Set;for(const s of f){const A=w.relative(u,s.path),y=w.dirname(w.join(t,A));$.add(y)}await Promise.all([...$].map(s=>D(s)));const x=await g(f,async s=>{const A=w.relative(u,s.path),y=w.join(t,A);let d=a;return d||(d=!await C(y)),F&&d&&(d=await B(s.path,y)),d?(await r.promises.copyFile(s.path,y),{copied:!0,skipped:!1}):{copied:!1,skipped:!0}},c);for(const s of x)s.copied&&E++,s.skipped&&p++}else{await D(w.dirname(t));let o=a;o||(o=!await C(t)),F&&o&&(o=await B(u,t)),o?(await r.promises.copyFile(u,t),E++):p++}const m=Date.now()-i;return{copiedFiles:E,skippedFiles:p,copiedDirs:l,executionTime:m}}async function S(u,t){try{await r.promises.writeFile(u,t,"utf-8")}catch(e){const i=e;throw i.code==="EACCES"?new Error(`\u5199\u5165\u6587\u4EF6\u5931\u8D25\uFF1A\u6CA1\u6709\u6743\u9650\u5199\u5165\u6587\u4EF6 - ${u}`):new Error(`\u5199\u5165\u6587\u4EF6\u5931\u8D25\uFF1A\u5199\u5165\u6587\u4EF6\u65F6\u51FA\u9519 - ${u}\uFF0C\u9519\u8BEF\uFF1A${i.message}`)}}async function z(u){try{return await r.promises.readFile(u,"utf-8")}catch(t){const e=t;throw e.code==="EACCES"?new Error(`\u8BFB\u53D6\u6587\u4EF6\u5931\u8D25\uFF1A\u6CA1\u6709\u6743\u9650\u8BFB\u53D6\u6587\u4EF6 - ${u}`):new Error(`\u8BFB\u53D6\u6587\u4EF6\u5931\u8D25\uFF1A\u8BFB\u53D6\u6587\u4EF6\u65F6\u51FA\u9519 - ${u}\uFF0C\u9519\u8BEF\uFF1A${e.message}`)}}function P(u){try{return r.readFileSync(u,"utf-8")}catch(t){const e=t;throw e.code==="EACCES"?new Error(`\u8BFB\u53D6\u6587\u4EF6\u5931\u8D25\uFF1A\u6CA1\u6709\u6743\u9650\u8BFB\u53D6\u6587\u4EF6 - ${u}`):new Error(`\u8BFB\u53D6\u6587\u4EF6\u5931\u8D25\uFF1A\u8BFB\u53D6\u6587\u4EF6\u65F6\u51FA\u9519 - ${u}\uFF0C\u9519\u8BEF\uFF1A${e.message}`)}}async function j(u,t={}){const{includeExtensions:e=[],excludePatterns:i=[],filter:n}=t,a=[];async function F(c){const E=await r.promises.readdir(c,{withFileTypes:!0});for(const p of E){const l=w.join(c,p.name);if(p.isDirectory()){await F(l);continue}if(!p.isFile()||i.some(f=>f.startsWith("*")?l.endsWith(f.slice(1)):l.includes(f)))continue;const m=w.extname(p.name).toLowerCase();if(e.length>0&&!e.includes(m))continue;const o=await r.promises.stat(l);n&&!n(l,m,o.size)||a.push({filePath:l,size:o.size,extension:m})}}return await F(u),a}async function O(u,t,e=2){await S(u,JSON.stringify(t,null,e))}export{k as checkSourceExists,v as copySourceToTarget,D as ensureTargetDir,C as fileExists,h as readDirRecursive,z as readFileContent,P as readFileSync,g as runWithConcurrency,j as scanDirectory,B as shouldUpdateFile,S as writeFileContent,O as writeJsonReport};
+import e from"fs";import F from"path";const B=10;async function k(t){try{await e.promises.access(t,e.constants.F_OK)}catch(u){const i=u;throw i.code==="ENOENT"?new Error(`\u590D\u5236\u6587\u4EF6\u5931\u8D25\uFF1A\u6E90\u6587\u4EF6\u4E0D\u5B58\u5728 - ${t}`):i.code==="EACCES"?new Error(`\u590D\u5236\u6587\u4EF6\u5931\u8D25\uFF1A\u6CA1\u6709\u6743\u9650\u8BBF\u95EE\u6E90\u6587\u4EF6 - ${t}`):new Error(`\u590D\u5236\u6587\u4EF6\u5931\u8D25\uFF1A\u68C0\u67E5\u6E90\u6587\u4EF6\u65F6\u51FA\u9519 - ${t}\uFF0C\u9519\u8BEF\uFF1A${i.message}`)}}async function D(t){try{await e.promises.mkdir(t,{recursive:!0})}catch(u){const i=u;throw i.code==="EACCES"?new Error(`\u590D\u5236\u6587\u4EF6\u5931\u8D25\uFF1A\u6CA1\u6709\u6743\u9650\u521B\u5EFA\u76EE\u6807\u76EE\u5F55 - ${t}`):new Error(`\u590D\u5236\u6587\u4EF6\u5931\u8D25\uFF1A\u521B\u5EFA\u76EE\u6807\u76EE\u5F55\u65F6\u51FA\u9519 - ${t}\uFF0C\u9519\u8BEF\uFF1A${i.message}`)}}async function C(t,u){const i=await e.promises.readdir(t,{withFileTypes:!0}),r=[];for(const n of i){const a=F.join(t,n.name),l=n.isFile(),c=n.isDirectory();if(r.push({path:a,isFile:l,isDirectory:c}),c&&u){const p=await C(a,u);r.push(...p)}}return r}async function S(t,u){try{const[i,r]=await Promise.all([e.promises.stat(t),e.promises.stat(u)]);return i.mtimeMs>r.mtimeMs||i.size!==r.size}catch{return!0}}async function x(t){try{return await e.promises.access(t,e.constants.F_OK),!0}catch{return!1}}async function v(t,u,i){const r=[];let n=0;async function a(){for(;n<t.length;){const c=n++,p=await u(t[c]);r[c]=p}}const l=Array(Math.min(i,t.length)).fill(null).map(()=>a());return await Promise.all(l),r}async function T(t,u,i){const r=Date.now(),{recursive:n,overwrite:a,incremental:l=!1,parallelLimit:c=B}=i;let p=0,E=0,w=0;if((await e.promises.stat(t)).isDirectory()){await D(u);const o=await C(t,n),f=o.filter(s=>s.isFile);w=o.filter(s=>s.isDirectory).length;const A=new Set;for(const s of f){const h=F.relative(t,s.path),y=F.dirname(F.join(u,h));A.add(y)}await Promise.all([...A].map(s=>D(s)));const $=await v(f,async s=>{const h=F.relative(t,s.path),y=F.join(u,h);let d=a;return d||(d=!await x(y)),l&&d&&(d=await S(s.path,y)),d?(await e.promises.copyFile(s.path,y),{copied:!0,skipped:!1}):{copied:!1,skipped:!0}},c);for(const s of $)s.copied&&p++,s.skipped&&E++}else{await D(F.dirname(u));let o=a;o||(o=!await x(u)),l&&o&&(o=await S(t,u)),o?(await e.promises.copyFile(t,u),p++):E++}const m=Date.now()-r;return{copiedFiles:p,skippedFiles:E,copiedDirs:w,executionTime:m}}async function g(t,u){try{await e.promises.writeFile(t,u,"utf-8")}catch(i){const r=i;throw r.code==="EACCES"?new Error(`\u5199\u5165\u6587\u4EF6\u5931\u8D25\uFF1A\u6CA1\u6709\u6743\u9650\u5199\u5165\u6587\u4EF6 - ${t}`):new Error(`\u5199\u5165\u6587\u4EF6\u5931\u8D25\uFF1A\u5199\u5165\u6587\u4EF6\u65F6\u51FA\u9519 - ${t}\uFF0C\u9519\u8BEF\uFF1A${r.message}`)}}async function z(t,u={}){const{includeExtensions:i=[],excludePatterns:r=[],filter:n}=u,a=[];async function l(c){const p=await e.promises.readdir(c,{withFileTypes:!0});for(const E of p){const w=F.join(c,E.name);if(E.isDirectory()){await l(w);continue}if(!E.isFile()||r.some(f=>f.startsWith("*")?w.endsWith(f.slice(1)):w.includes(f)))continue;const m=F.extname(E.name).toLowerCase();if(i.length>0&&!i.includes(m))continue;const o=await e.promises.stat(w);n&&!n(w,m,o.size)||a.push({filePath:w,size:o.size,extension:m})}}return await l(t),a}async function P(t,u,i=2){await g(t,JSON.stringify(u,null,i))}function j(t,u){const i=F.dirname(t);e.existsSync(i)||e.mkdirSync(i,{recursive:!0}),e.writeFileSync(t,u,"utf-8")}function O(t,u){if(!e.existsSync(t))return!0;try{return e.readFileSync(t,"utf-8")!==u}catch{return!0}}export{k as checkSourceExists,T as copySourceToTarget,z as scanDirectory,O as shouldUpdateFileContent,g as writeFileContent,j as writeFileSyncSafely,P as writeJsonReport};

package/dist/common/html/index.cjs

@@ -1,2 +1,2 @@
-"use strict";const security=require("../../shared/vite-plugin.BrI73DHA.cjs");require("../script/index.cjs");function injectBeforeTag(e,t,r){const i=new RegExp(t,"i");return i.test(e)?{html:e.replace(i,`${r}
-${t}`),injected:!0}:{html:e,injected:!1}}function injectHtmlByPriority(e,t,r=["</head>","</body>","</html>"]){for(const i of r){const n=injectBeforeTag(e,i,t);if(n.injected)return n}return{html:e+t,injected:!0}}function injectBeforeTagWithFallback(e,t,r){const i=injectBeforeTag(e,"</body>",t);if(i.injected)return{...i,usedFallback:!1};const n=injectBeforeTag(e,"</html>",t);return n.injected?{...n,usedFallback:!1}:{html:e+t,injected:!0,usedFallback:!0}}function injectHeadAndBody(e,t,r){let i=e,n=!1;if(t){const c=injectBeforeTag(i,"</head>",t);c.injected&&(i=c.html,n=!0)}const o=injectBeforeTagWithFallback(i,r);return{html:o.html,headInjected:n,bodyInjected:o.injected,usedFallback:o.usedFallback}}exports.DEFAULT_BLOCKED_ATTRIBUTES=security.DEFAULT_BLOCKED_ATTRIBUTES,exports.DEFAULT_BLOCKED_TAGS=security.DEFAULT_BLOCKED_TAGS,exports.applyTemplateVars=security.applyTemplateVars,exports.evaluateCondition=security.evaluateCondition,exports.findSelectorMatch=security.findSelectorMatch,exports.injectAtPosition=security.injectAtPosition,exports.sanitizeContent=security.sanitizeContent,exports.sortRulesByPriority=security.sortRulesByPriority,exports.validateSecurityConfig=security.validateSecurityConfig,exports.injectBeforeTag=injectBeforeTag,exports.injectBeforeTagWithFallback=injectBeforeTagWithFallback,exports.injectHeadAndBody=injectHeadAndBody,exports.injectHtmlByPriority=injectHtmlByPriority;
+"use strict";const security=require("../../shared/vite-plugin.CcvHfrL8.cjs");function injectBeforeTag(e,t,l){const n=new RegExp(t,"i");return n.test(e)?{html:e.replace(n,`${l}
+${t}`),injected:!0}:{html:e,injected:!1}}function c(e,t,l){const n=injectBeforeTag(e,"</body>",t);if(n.injected)return{...n,usedFallback:!1};const s=injectBeforeTag(e,"</html>",t);return s.injected?{...s,usedFallback:!1}:{html:e+t,injected:!0,usedFallback:!0}}function injectHeadAndBody(e,t,l){let n=e,s=!1;if(t){const r=injectBeforeTag(n,"</head>",t);r.injected&&(n=r.html,s=!0)}const i=c(n,l);return{html:i.html,headInjected:s,bodyInjected:i.injected,usedFallback:i.usedFallback}}exports.escapeHtmlAttr=security.escapeHtmlAttr,exports.sanitizeContent=security.sanitizeContent,exports.injectBeforeTag=injectBeforeTag,exports.injectHeadAndBody=injectHeadAndBody;

package/dist/common/html/index.d.cts

@@ -1,235 +1,27 @@
-import { I as InjectCondition, b as SelectorMatch, a as InjectPosition, P as PositionInjectResult, S as SecurityConfig, H as HtmlInjectResult, D as DualInjectResult } from '../../shared/vite-plugin.FfJ-Wwfu.cjs';
-export { C as ConditionType } from '../../shared/vite-plugin.FfJ-Wwfu.cjs';
+import { S as SecurityConfig, H as HtmlInjectResult, D as DualInjectResult } from '../../shared/vite-plugin.BI9taN75.cjs';
+export { C as ConditionType, I as InjectCondition, a as InjectPosition, b as SelectorMatch } from '../../shared/vite-plugin.BI9taN75.cjs';
 
 /**
- * HTML 注入工具模块
+ * 转义 HTML 属性值中的特殊字符
  *
- * @module common/html/inject
- * @description 提供高级 HTML 内容注入功能，包括选择器匹配、模板变量替换、
- * 条件判断、规则排序和多位置注入等能力，为插件提供灵活的 HTML 操作支持。
- */
-
-/**
- * 在 HTML 中查找选择器匹配位置
- *
- * @param html - 要搜索的 HTML 字符串
- * @param selector - 选择器字符串（普通字符串或正则表达式字符串）
- * @param selectorMatch - 匹配模式，`'string'` 为精确字符串匹配，`'regex'` 为正则匹配
- * @returns 匹配结果对象（包含 `index` 和 `length`），未匹配时返回 `null`
- *
- * @description 根据匹配模式在 HTML 中查找选择器的位置：
- * - 字符串模式：使用 `indexOf` 进行精确匹配
- * - 正则模式：使用 `RegExp` 进行正则匹配，正则语法错误时返回 `null`
- *
- * @example
- * ```typescript
- * // 字符串匹配
- * findSelectorMatch('<div id="app">content</div>', '<div id="app">')
- * // { index: 0, length: 14 }
- *
- * // 正则匹配
- * findSelectorMatch('<div class="foo">bar</div>', 'class="\\w+"', 'regex')
- * // { index: 5, length: 12 }
- *
- * // 未匹配
- * findSelectorMatch('<div>hello</div>', '<span>')
- * // null
- * ```
- */
-declare function findSelectorMatch(html: string, selector: string, selectorMatch?: SelectorMatch): {
-    index: number;
-    length: number;
-} | null;
-/**
- * 替换模板字符串中的变量占位符
- *
- * @param content - 包含 `{{变量名}}` 占位符的模板字符串
- * @param ruleVars - 规则级变量映射（优先级高于全局变量）
- * @param globalVars - 全局变量映射
- * @returns 替换所有匹配占位符后的字符串
+ * @param str - 需要转义的字符串
+ * @returns 转义后的安全字符串
  *
- * @description 将模板字符串中形如 `{{key}}` 的占位符替换为对应的值。
- * 规则变量（`ruleVars`）优先级高于全局变量（`globalVars`），
- * 当两者存在相同键时，规则变量的值会覆盖全局变量的值。
- * 变量名中的正则特殊字符会被自动转义，替换值中的 `$` 也会被安全处理。
+ * @description 将字符串中的 `&`、`"`、`'`、`<`、`>` 转义为对应的 HTML 实体，
+ * 防止在 HTML 属性值中注入恶意代码。
  *
  * @example
  * ```typescript
- * // 基本替换
- * applyTemplateVars('<div>{{name}}</div>', { name: 'test' })
- * // '<div>test</div>'
- *
- * // 规则变量覆盖全局变量
- * applyTemplateVars('{{a}}-{{b}}', { a: '1' }, { a: '0', b: '2' })
- * // '1-2'
- *
- * // 无匹配占位符
- * applyTemplateVars('no vars', { x: 'y' })
- * // 'no vars'
- * ```
- */
-declare function applyTemplateVars(content: string, ruleVars?: Record<string, string>, globalVars?: Record<string, string>): string;
-/**
- * 评估注入条件是否满足
- *
- * @param condition - 注入条件配置
- * @param html - 当前 HTML 内容（用于 `file-contains` 类型判断）
- * @returns 条件是否满足（布尔值）
- *
- * @description 根据条件类型评估注入条件：
- * - `env`：检查环境变量是否存在且不为 `'false'` 或 `'0'`
- * - `file-contains`：检查 HTML 内容是否包含指定字符串
- * - `custom`：执行自定义函数，捕获异常时返回 `false`
- * - 支持通过 `negate` 字段对结果取反
- *
- * @example
- * ```typescript
- * // 环境变量判断
- * evaluateCondition({ type: 'env', value: 'ENABLE_ANALYTICS' }, '')
- *
- * // 内容包含判断
- * evaluateCondition({ type: 'file-contains', value: '<div id="app">' }, html)
- *
- * // 自定义函数（带取反）
- * evaluateCondition(
- *   { type: 'custom', value: () => isDev(), negate: true },
- *   html
- * )
+ * escapeHtmlAttr('hello "world" & <friends>')
+ * // 'hello &quot;world&quot; &amp; &lt;friends&gt;'
  * ```
  */
-declare function evaluateCondition(condition: InjectCondition, html: string): boolean;
-/**
- * 按优先级排序规则列表
- *
- * @typeParam T - 规则类型，必须包含可选的 `priority` 字段
- * @param rules - 待排序的规则数组
- * @returns 按 `priority` 升序排列的新数组（不修改原数组）
- *
- * @description 将规则按 `priority` 字段升序排列，`priority` 越小优先级越高。
- * 未指定 `priority` 的规则默认优先级为 100。
- * 返回新数组，不修改原数组。
- *
- * @example
- * ```typescript
- * const rules = [
- *   { priority: 30, name: 'C' },
- *   { priority: 10, name: 'A' },
- *   { name: 'D' },           // 默认 priority=100
- *   { priority: 20, name: 'B' }
- * ]
- * sortRulesByPriority(rules)
- * // [{ priority: 10, name: 'A' }, { priority: 20, name: 'B' },
- * //  { priority: 30, name: 'C' }, { name: 'D' }]
- * ```
- */
-declare function sortRulesByPriority<T extends {
-    priority?: number;
-}>(rules: T[]): T[];
-/**
- * 在 HTML 的指定位置注入内容
- *
- * @param html - 原始 HTML 字符串
- * @param content - 要注入的内容
- * @param position - 注入位置
- * @param selector - 选择器字符串（仅 `before-selector`、`after-selector`、`replace-selector` 位置需要）
- * @param selectorMatch - 选择器匹配模式（默认为字符串匹配）
- * @returns 注入结果对象，包含注入后的 HTML、是否成功标志和失败原因
- *
- * @description 根据 `position` 参数将内容注入到 HTML 的指定位置：
- * - `head-start`：在 `<head>` 标签开始后注入
- * - `head-end`：在 `</head>` 标签前注入
- * - `body-start`：在 `<body>` 标签开始后注入
- * - `body-end`：在 `</body>` 标签前注入
- * - `before-selector`：在选择器匹配位置前注入
- * - `after-selector`：在选择器匹配位置后注入
- * - `replace-selector`：替换选择器匹配的内容
- *
- * 当目标标签或选择器未找到时，返回 `injected: false` 并附带 `reason` 说明。
- *
- * @example
- * ```typescript
- * const html = '<html><head><title>Test</title></head><body><div id="app"></div></body></html>'
- *
- * // 在 head 开始后注入 meta 标签
- * injectAtPosition(html, '<meta charset="utf-8">', 'head-start')
- *
- * // 在 body 结束前注入脚本
- * injectAtPosition(html, '<script>app()</script>', 'body-end')
- *
- * // 在指定元素前注入
- * injectAtPosition(html, '<nav>menu</nav>', 'before-selector', '<div id="app">')
- *
- * // 替换指定元素
- * injectAtPosition(html, '<div id="root"></div>', 'replace-selector', '<div id="app">')
- * ```
- */
-declare function injectAtPosition(html: string, content: string, position: InjectPosition, selector?: string, selectorMatch?: SelectorMatch): PositionInjectResult;
-
-/**
- * HTML 安全过滤模块
- *
- * @module common/html/security
- * @description 提供 HTML 内容安全过滤和验证功能，防止 XSS 攻击和危险内容注入，
- * 包括危险标签检测、危险属性过滤和安全配置验证等能力。
- */
-
-/**
- * 默认阻止的 HTML 标签列表
- *
- * @description 包含可能导致安全风险的 HTML 标签：
- * - `script`：可执行 JavaScript 代码
- * - `iframe`：可嵌入外部页面
- * - `object`/`embed`/`applet`：可嵌入插件
- * - `form`/`input`/`textarea`/`select`/`button`：可创建表单
- */
-declare const DEFAULT_BLOCKED_TAGS: string[];
-/**
- * 默认阻止的 HTML 事件属性列表
- *
- * @description 包含所有可能导致 JavaScript 执行的事件处理属性，
- * 涵盖鼠标事件、键盘事件、表单事件、拖拽事件和动画事件等。
- */
-declare const DEFAULT_BLOCKED_ATTRIBUTES: string[];
-/**
- * 验证安全配置的合法性
- *
- * @param security - 安全配置对象
- * @throws 当 `blockedTags` 不是字符串数组时抛出错误
- * @throws 当 `allowedTags` 不是字符串数组时抛出错误
- * @throws 当 `blockedAttributes` 不是字符串数组时抛出错误
- *
- * @description 检查安全配置中的数组字段是否为合法的字符串数组类型，
- * 传入 `undefined` 时直接跳过验证。
- *
- * @example
- * ```typescript
- * // 合法配置
- * validateSecurityConfig({ blockedTags: ['iframe'], allowedTags: ['div'] })
- *
- * // 非法配置（抛出错误）
- * validateSecurityConfig({ blockedTags: 'iframe' })
- * // Error: security.blockedTags 必须是字符串数组
- * ```
- */
-declare function validateSecurityConfig(security?: SecurityConfig): void;
+declare function escapeHtmlAttr(str: string): string;
 /**
  * 内容消毒规则选项
- *
- * @description 定义对单条注入规则内容进行安全过滤时的选项，
- * 控制是否允许脚本注入等特殊行为。
  */
 interface SanitizeRuleOptions {
-    /** 规则标识符，用于错误消息和警告日志中标识来源规则 */
     id?: string;
-    /**
-     * 是否允许注入 `<script>` 标签和被阻止的标签/属性
-     *
-     * @description 设置为 `true` 时，将跳过对危险标签和属性的安全检查，
-     * 但仍会输出警告日志提醒开发者注意安全风险。
-     * 仅在注入内容来源可信时使用此选项。
-     *
-     * @default false
-     */
     allowScriptInjection?: boolean;
 }
 /**
@@ -238,33 +30,8 @@ interface SanitizeRuleOptions {
  * @param content - 待过滤的 HTML 内容字符串
  * @param rule - 当前注入规则的消毒选项
  * @param security - 全局安全配置
- * @param logger - 日志记录器（需提供 `warn` 方法），用于输出安全警告
+ * @param logger - 日志记录器
  * @returns 过滤后的安全 HTML 内容字符串
- * @throws 当内容包含被阻止的标签且未启用 `allowScriptInjection` 时抛出错误
- * @throws 当内容包含危险属性且未启用 `allowScriptInjection` 时抛出错误
- *
- * @description 对 HTML 内容进行安全过滤，防止 XSS 攻击：
- * 1. **标签过滤**：检测并阻止默认阻止列表中的标签（如 script、iframe），
- *    可通过 `security.allowedTags` 放行特定标签
- * 2. **属性过滤**：检测并阻止事件处理属性（如 onclick、onerror）
- * 3. **脚本检测**：特别检测 `<script>` 标签，需要显式启用 `allowScriptInjection`
- *
- * 当 `rule.allowScriptInjection` 为 `true` 时，跳过安全检查但输出警告日志。
- *
- * @example
- * ```typescript
- * // 安全内容直接通过
- * sanitizeContent('<div>safe</div>', { id: 'rule1' })
- *
- * // 包含 script 标签（抛出错误）
- * sanitizeContent('<script>alert(1)</script>', { id: 'rule2' })
- *
- * // 允许脚本注入（通过但输出警告）
- * sanitizeContent('<script>alert(1)</script>', { id: 'rule3', allowScriptInjection: true }, undefined, console)
- *
- * // 自定义安全配置
- * sanitizeContent('<iframe>test</iframe>', { id: 'rule4' }, { allowedTags: ['iframe'] })
- * ```
  */
 declare function sanitizeContent(content: string, rule: SanitizeRuleOptions, security?: SecurityConfig, logger?: {
     warn: (msg: string) => void;
@@ -277,59 +44,8 @@ declare function sanitizeContent(content: string, rule: SanitizeRuleOptions, sec
  * @param tag - 目标闭合标签（如 `</head>`、`</body>`、`</html>`）
  * @param code - 要注入的代码
  * @returns 注入结果对象
- *
- * @example
- * ```typescript
- * // 在 </head> 前注入 CSS
- * const result = injectBeforeTag(html, '</head>', '<style>...</style>')
- *
- * // 在 </body> 前注入 JS
- * const result = injectBeforeTag(html, '</body>', '<script>...</script>')
- * ```
  */
 declare function injectBeforeTag(html: string, tag: string, code: string): HtmlInjectResult;
-/**
- * 按优先级向 HTML 中注入代码
- *
- * @description 依次尝试在 `</head>`、`</body>`、`</html>` 前注入代码，
- * 优先注入到靠前的标签位置。适用于需要注入到页面中但无特定位置要求的场景
- *
- * @param html - 原始 HTML 内容
- * @param code - 要注入的代码
- * @param targets - 目标标签优先级列表，默认为 `['</head>', '</body>', '</html>']`
- * @returns 注入结果对象
- *
- * @example
- * ```typescript
- * // 优先注入到 </body> 前
- * const result = injectHtmlByPriority(html, scriptCode, ['</body>', '</html>'])
- * ```
- */
-declare function injectHtmlByPriority(html: string, code: string, targets?: string[]): HtmlInjectResult;
-/**
- * 带回退策略的 HTML 注入
- *
- * @description 依次尝试在 `</body>`、`</html>` 前注入代码，
- * 如果均未找到目标标签，则将代码追加到 HTML 末尾。
- * 适用于需要注入到页面底部但不确定 HTML 结构是否完整的场景。
- *
- * @param html - 原始 HTML 内容
- * @param code - 要注入的代码
- * @param fallbackMessage - 回退到末尾时的警告信息，为空则不输出警告
- * @returns 注入结果对象，包含注入后的 HTML、是否成功标志和是否使用了回退策略
- *
- * @example
- * ```typescript
- * // 注入 JS 脚本到页面底部
- * const result = injectBeforeTagWithFallback(html, '<script>...</script>')
- *
- * // 带自定义警告信息
- * const result = injectBeforeTagWithFallback(html, scriptCode, '未找到 </body> 标签，代码追加到文件末尾')
- * ```
- */
-declare function injectBeforeTagWithFallback(html: string, code: string, _fallbackMessage?: string): HtmlInjectResult & {
-    usedFallback: boolean;
-};
 /**
  * 双区域 HTML 注入（head + body）
  *
@@ -340,19 +56,8 @@ declare function injectBeforeTagWithFallback(html: string, code: string, _fallba
  * @param headCode - 注入到 `</head>` 前的代码（如 CSS、meta 标签），不提供则跳过 head 注入
  * @param bodyCode - 注入到 `</body>` 前的代码（如 JS 脚本），回退到 `</html>` 前或末尾
  * @returns 双区域注入结果对象
- *
- * @example
- * ```typescript
- * // CSS 注入到 head，JS 注入到 body
- * const result = injectHeadAndBody(html, '<style>...</style>', '<script>...</script>')
- * if (!result.headInjected) logger.warn('未找到 </head> 标签')
- * if (result.usedFallback) logger.warn('代码追加到文件末尾')
- *
- * // 仅注入到 body
- * const result = injectHeadAndBody(html, undefined, '<script>...</script>')
- * ```
  */
 declare function injectHeadAndBody(html: string, headCode: string | undefined, bodyCode: string): DualInjectResult;
 
-export { DEFAULT_BLOCKED_ATTRIBUTES, DEFAULT_BLOCKED_TAGS, DualInjectResult, HtmlInjectResult, InjectCondition, InjectPosition, PositionInjectResult, SecurityConfig, SelectorMatch, applyTemplateVars, evaluateCondition, findSelectorMatch, injectAtPosition, injectBeforeTag, injectBeforeTagWithFallback, injectHeadAndBody, injectHtmlByPriority, sanitizeContent, sortRulesByPriority, validateSecurityConfig };
+export { DualInjectResult, HtmlInjectResult, SecurityConfig, escapeHtmlAttr, injectBeforeTag, injectHeadAndBody, sanitizeContent };
 export type { SanitizeRuleOptions };