id-scanner-lib 1.6.6 → 1.7.0

package/dist/id-scanner-lib.esm.js

@@ -282,18 +282,20 @@ class ConsoleLogHandler {
     handle(entry) {
         const timestamp = new Date(entry.timestamp).toISOString();
         const prefix = `[${timestamp}] [${entry.level.toUpperCase()}] [${entry.tag}]`;
+        // 优先使用 error，其次使用 data
+        const extra = entry.error || entry.data || '';
         switch (entry.level) {
             case LoggerLevel.DEBUG:
-                console.debug(prefix, entry.message, entry.error || '');
+                console.debug(prefix, entry.message, extra);
                 break;
             case LoggerLevel.INFO:
-                console.info(prefix, entry.message, entry.error || '');
+                console.info(prefix, entry.message, extra);
                 break;
             case LoggerLevel.WARN:
-                console.warn(prefix, entry.message, entry.error || '');
+                console.warn(prefix, entry.message, extra);
                 break;
             case LoggerLevel.ERROR:
-                console.error(prefix, entry.message, entry.error || '');
+                console.error(prefix, entry.message, extra);
                 break;
             // 输出什么也不做
         }
@@ -367,10 +369,13 @@ class RemoteLogHandler {
         this.queue = [];
         /** 定时发送的计时器ID */
         this.timerId = null;
+        /** 当前连续失败计数 */
+        this.consecutiveFailures = 0;
         this.endpoint = endpoint;
         this.maxQueueSize = maxQueueSize;
         this.flushInterval = flushInterval;
         this.isBrowser = typeof window !== 'undefined' && typeof window.addEventListener === 'function';
+        this.maxConsecutiveFailures = 10;
         // 设置定时发送
         this.startTimer();
         // 页面卸载前尝试发送剩余日志
@@ -400,47 +405,55 @@ class RemoteLogHandler {
     flush() {
         if (this.queue.length === 0)
             return;
-        const entriesToSend = [...this.queue];
-        this.queue = [];
-        // 防止在 fetch 失败时无限重试
-        const sendCount = this._sendCount || 0;
-        this._sendCount = sendCount + 1;
-        // 如果发送次数过多，停止发送以防止无限循环
-        if (sendCount > 10) {
-            console.warn('RemoteLogHandler: Too many failed sends, stopping. Clear queue.');
+        // 如果连续失败次数过多，停止发送以防止无限循环
+        if (this.consecutiveFailures >= this.maxConsecutiveFailures) {
+            console.warn('RemoteLogHandler: Too many consecutive failures, stopping. Clear queue.');
             this.queue = [];
-            this._sendCount = 0;
+            this.consecutiveFailures = 0;
             return;
         }
-        try {
-            fetch(this.endpoint, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json'
-                },
-                body: JSON.stringify(entriesToSend),
-                keepalive: true
-            }).catch((err) => {
-                console.error('Failed to send logs to remote server:', err);
-                // 防止无限重试 - 如果失败次数过多，丢弃日志
-                if (this._sendCount > 10) {
-                    console.warn('RemoteLogHandler: Max retry exceeded, discarding logs');
-                    this.queue = []; // 清空队列，避免内存泄漏
-                    this._sendCount = 0;
-                    return;
-                }
-                // 失败时把日志放回队列，但防止无限增长
-                if (this.queue.length < this.maxQueueSize) {
-                    const maxReturn = Math.min(entriesToSend.length, this.maxQueueSize - this.queue.length);
-                    const returnedEntries = entriesToSend.slice(0, maxReturn);
-                    this.queue = [...returnedEntries, ...this.queue];
-                }
-                this._sendCount = 0;
-            });
-        }
-        catch (error) {
-            console.error('Error sending logs:', error);
-        }
+        const entriesToSend = [...this.queue];
+        this.queue = [];
+        this.sendLogEntries(entriesToSend);
+    }
+    /**
+     * 发送日志条目到远程服务器
+     * @param entries 日志条目数组
+     */
+    sendLogEntries(entries) {
+        if (entries.length === 0)
+            return;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 10000); // 10s 超时
+        fetch(this.endpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(entries),
+            keepalive: true,
+            signal: controller.signal
+        }).then(() => {
+            clearTimeout(timeoutId);
+            this.consecutiveFailures = 0; // 发送成功，重置失败计数
+        }).catch((err) => {
+            clearTimeout(timeoutId);
+            console.error('Failed to send logs to remote server:', err);
+            this.consecutiveFailures++;
+            // 如果失败次数过多，丢弃日志防止内存泄漏
+            if (this.consecutiveFailures >= this.maxConsecutiveFailures) {
+                console.warn('RemoteLogHandler: Max consecutive failures exceeded, discarding logs');
+                this.queue = [];
+                this.consecutiveFailures = 0;
+                return;
+            }
+            // 失败时把日志放回队列，但防止无限增长
+            const maxReturn = Math.min(entries.length, this.maxQueueSize - this.queue.length);
+            if (maxReturn > 0) {
+                const returnedEntries = entries.slice(0, maxReturn);
+                this.queue = [...returnedEntries, ...this.queue];
+            }
+        });
     }
     /**
      * 开始定时发送
@@ -450,7 +463,7 @@ class RemoteLogHandler {
             return;
         if (this.timerId !== null)
             return;
-        this.timerId = window.setInterval(() => {
+        this.timerId = setInterval(() => {
             this.flush();
         }, this.flushInterval);
     }
@@ -459,7 +472,7 @@ class RemoteLogHandler {
      */
     stopTimer() {
         if (this.timerId !== null) {
-            window.clearInterval(this.timerId);
+            clearInterval(this.timerId);
             this.timerId = null;
         }
     }
@@ -536,37 +549,57 @@ class Logger {
      * 记录调试级别日志
      * @param tag 标签
      * @param message 消息
-     * @param error 错误
+     * @param errorOrData 错误对象或结构化数据
      */
-    debug(tag, message, error) {
-        this.log(LoggerLevel.DEBUG, tag, message, error);
+    debug(tag, message, errorOrData) {
+        if (errorOrData instanceof Error) {
+            this.log(LoggerLevel.DEBUG, tag, message, errorOrData);
+        }
+        else {
+            this.logWithData(LoggerLevel.DEBUG, tag, message, errorOrData);
+        }
     }
     /**
      * 记录信息级别日志
      * @param tag 标签
      * @param message 消息
-     * @param error 错误
+     * @param errorOrData 错误对象或结构化数据
      */
-    info(tag, message, error) {
-        this.log(LoggerLevel.INFO, tag, message, error);
+    info(tag, message, errorOrData) {
+        if (errorOrData instanceof Error) {
+            this.log(LoggerLevel.INFO, tag, message, errorOrData);
+        }
+        else {
+            this.logWithData(LoggerLevel.INFO, tag, message, errorOrData);
+        }
     }
     /**
      * 记录警告级别日志
      * @param tag 标签
      * @param message 消息
-     * @param error 错误
+     * @param errorOrData 错误对象或结构化数据
      */
-    warn(tag, message, error) {
-        this.log(LoggerLevel.WARN, tag, message, error);
+    warn(tag, message, errorOrData) {
+        if (errorOrData instanceof Error) {
+            this.log(LoggerLevel.WARN, tag, message, errorOrData);
+        }
+        else {
+            this.logWithData(LoggerLevel.WARN, tag, message, errorOrData);
+        }
     }
     /**
      * 记录错误级别日志
      * @param tag 标签
      * @param message 消息
-     * @param error 错误
+     * @param errorOrData 错误对象或结构化数据
      */
-    error(tag, message, error) {
-        this.log(LoggerLevel.ERROR, tag, message, error);
+    error(tag, message, errorOrData) {
+        if (errorOrData instanceof Error) {
+            this.log(LoggerLevel.ERROR, tag, message, errorOrData);
+        }
+        else {
+            this.logWithData(LoggerLevel.ERROR, tag, message, errorOrData);
+        }
     }
     /**
      * 创建标记了特定标签的日志记录器
@@ -611,6 +644,42 @@ class Logger {
             this.consoleOutput(entry);
         }
     }
+    /**
+     * 记录日志（支持结构化数据）
+     * @param level 日志级别
+     * @param tag 标签
+     * @param message 消息
+     * @param data 结构化数据
+     */
+    logWithData(level, tag, message, data) {
+        // 检查日志级别
+        const levelValue = this.getLevelValue(level);
+        const currentLevelValue = this.getLevelValue(this.logLevel);
+        if (levelValue < currentLevelValue) {
+            return;
+        }
+        // 创建日志条目
+        const entry = {
+            timestamp: Date.now(),
+            level: level,
+            tag: tag || this.defaultTag,
+            message,
+            data
+        };
+        // 分发到所有处理程序
+        for (const handler of this.handlers) {
+            try {
+                handler.handle(entry);
+            }
+            catch (handlerError) {
+                console.error(`[Logger] 处理程序错误:`, handlerError);
+            }
+        }
+        // 如果没有处理程序，使用控制台
+        if (this.handlers.length === 0) {
+            this.consoleOutput(entry);
+        }
+    }
     /**
      * 控制台输出
      * @param entry 日志条目
@@ -618,18 +687,20 @@ class Logger {
     consoleOutput(entry) {
         const timestamp = new Date(entry.timestamp).toISOString();
         const prefix = `[${timestamp}] [${entry.level.toUpperCase()}] [${entry.tag}]`;
+        // 构造日志内容：错误对象或数据对象
+        const extra = entry.error || entry.data || '';
         switch (entry.level) {
             case LoggerLevel.DEBUG:
-                console.debug(`${prefix} ${entry.message}`, entry.error || '');
+                console.debug(`${prefix} ${entry.message}`, extra);
                 break;
             case LoggerLevel.INFO:
-                console.info(`${prefix} ${entry.message}`, entry.error || '');
+                console.info(`${prefix} ${entry.message}`, extra);
                 break;
             case LoggerLevel.WARN:
-                console.warn(`${prefix} ${entry.message}`, entry.error || '');
+                console.warn(`${prefix} ${entry.message}`, extra);
                 break;
             case LoggerLevel.ERROR:
-                console.error(`${prefix} ${entry.message}`, entry.error || '');
+                console.error(`${prefix} ${entry.message}`, extra);
                 break;
         }
     }
@@ -1596,93 +1667,685 @@ class IDCardDetector extends EventEmitter {
 }
 
 /**
- * @file 图像处理工具类
- * @description 提供图像预处理功能，用于提高OCR识别率
- * @module ImageProcessor
- * @version 1.3.2
+ * 格式化日期字符串为标准格式 (YYYY-MM-DD)
  */
+function formatDateString(dateStr) {
+    const dateMatch = dateStr.match(/(\d{4})[-\.\u5e74\s]*(\d{1,2})[-\.\u6708\s]*(\d{1,2})[日]*/);
+    if (dateMatch) {
+        const year = dateMatch[1];
+        const month = dateMatch[2].padStart(2, "0");
+        const day = dateMatch[3].padStart(2, "0");
+        return `${year}-${month}-${day}`;
+    }
+    if (/^\d{8}$/.test(dateStr)) {
+        const year = dateStr.substring(0, 4);
+        const month = dateStr.substring(4, 6);
+        const day = dateStr.substring(6, 8);
+        return `${year}-${month}-${day}`;
+    }
+    return dateStr;
+}
 /**
- * 图像处理工具类
+ * IDCardTextParser - 统一解析身份证OCR文本
+ * 提取 ocr-processor.ts 和 ocr-worker.ts 中的解析逻辑
+ */
+class IDCardTextParser {
+    /**
+     * 解析身份证文本
+     * @param text OCR识别的原始文本
+     * @returns 解析后的身份证信息
+     */
+    static parse(text) {
+        const info = {};
+        const processedText = text.replace(/\s+/g, " ").trim();
+        const lines = processedText.split("\n").filter((line) => line.trim());
+        // 1. 解析身份证号码
+        const idNumberRegex = /(\d{17}[\dX])/;
+        const idNumberWithPrefixRegex = /公民身份号码[\s\:]*(\d{17}[\dX])/;
+        const basicMatch = processedText.match(idNumberRegex);
+        const prefixMatch = processedText.match(idNumberWithPrefixRegex);
+        if (prefixMatch && prefixMatch[1]) {
+            info.idNumber = prefixMatch[1];
+        }
+        else if (basicMatch && basicMatch[1]) {
+            info.idNumber = basicMatch[1];
+        }
+        // 2. 解析姓名
+        const nameWithLabelRegex = /姓名[\s\:]*([一-龥]{2,4})/;
+        const nameMatch = processedText.match(nameWithLabelRegex);
+        if (nameMatch && nameMatch[1]) {
+            info.name = nameMatch[1].trim();
+        }
+        else {
+            for (const line of lines) {
+                if (line.length >= 2 && line.length <= 5 && /^[一-龥]+$/.test(line) &&
+                    !/性别|民族|住址|公民|签发|有效/.test(line)) {
+                    info.name = line.trim();
+                    break;
+                }
+            }
+        }
+        // 3. 解析性别和民族
+        const genderAndNationalityRegex = /性别[\s\:]*([男女])[\s ]*民族[\s\:]*([一-龥]+族)/;
+        const genderOnlyRegex = /性别[\s\:]*([男女])/;
+        const nationalityOnlyRegex = /民族[\s\:]*([一-龥]+族)/;
+        const genderNationalityMatch = processedText.match(genderAndNationalityRegex);
+        const genderOnlyMatch = processedText.match(genderOnlyRegex);
+        const nationalityOnlyMatch = processedText.match(nationalityOnlyRegex);
+        if (genderNationalityMatch) {
+            info.gender = genderNationalityMatch[1];
+            info.ethnicity = genderNationalityMatch[2];
+        }
+        else {
+            if (genderOnlyMatch)
+                info.gender = genderOnlyMatch[1];
+            if (nationalityOnlyMatch)
+                info.ethnicity = nationalityOnlyMatch[1];
+        }
+        // 4. 判断身份证类型
+        if (processedText.includes('出生') || processedText.includes('公民身份号码')) {
+            info.type = IDCardType.FRONT;
+        }
+        else if (processedText.includes('签发机关') || processedText.includes('有效期')) {
+            info.type = IDCardType.BACK;
+        }
+        // 5. 解析出生日期
+        const birthDateRegex1 = /出生[\s\:]*(\d{4})年(\d{1,2})月(\d{1,2})[日号]/;
+        const birthDateRegex2 = /出生[\s\:]*(\d{4})[-\/\.](\d{1,2})[-\/\.](\d{1,2})/;
+        const birthDateRegex3 = /出生日期[\s\:]*(\d{4})[-\/\.\u5e74](\d{1,2})[-\/\.\u6708](\d{1,2})[日号]?/;
+        const birthDateMatch = processedText.match(birthDateRegex1) || processedText.match(birthDateRegex2) || processedText.match(birthDateRegex3);
+        if (!birthDateMatch && info.idNumber && info.idNumber.length === 18) {
+            const year = info.idNumber.substring(6, 10);
+            const month = info.idNumber.substring(10, 12);
+            const day = info.idNumber.substring(12, 14);
+            info.birthDate = `${year}-${month}-${day}`;
+        }
+        else if (birthDateMatch) {
+            const year = birthDateMatch[1];
+            const month = birthDateMatch[2].padStart(2, "0");
+            const day = birthDateMatch[3].padStart(2, "0");
+            info.birthDate = `${year}-${month}-${day}`;
+        }
+        // 6. 解析地址
+        const addressRegex1 = /住址[\s\:]*([\s\S]*?)(?=公民身份|出生|性别|签发)/;
+        const addressRegex2 = /住址[\s\:]*([一-龥a-zA-Z0-9\s\.\-]+)/;
+        const addressMatch = processedText.match(addressRegex1) || processedText.match(addressRegex2);
+        if (addressMatch && addressMatch[1]) {
+            info.address = addressMatch[1].replace(/\s+/g, "").replace(/\n/g, "").trim();
+            if (info.address.length > 70)
+                info.address = info.address.substring(0, 70);
+            if (!/[一-龥]/.test(info.address))
+                info.address = '';
+        }
+        // 7. 解析签发机关
+        const authorityRegex1 = /签发机关[\s\:]*([\s\S]*?)(?=有效|公民|出生|\d{8}|$)/;
+        const authorityRegex2 = /签发机关[\s\:]*([一-龥\s]+)/;
+        const authorityMatch = processedText.match(authorityRegex1) || processedText.match(authorityRegex2);
+        if (authorityMatch && authorityMatch[1]) {
+            info.issueAuthority = authorityMatch[1].replace(/\s+/g, "").replace(/\n/g, "").trim();
+        }
+        // 8. 解析有效期限
+        const validPeriodRegex1 = /有效期限[\s\:]*(\d{4}[-\.\u5e74\s]\d{1,2}[-\.\u6708\s]\d{1,2}[日\s]*)[-\s]*(至|-)[-\s]*(\d{4}[-\.\u5e74\s]\d{1,2}[-\.\u6708\s]\d{1,2}[日]*|[永久长期]*)/;
+        const validPeriodRegex2 = /有效期限[\s\:]*(\d{8})[-\s]*(至|-)[-\s]*(\d{8}|[永久长期]*)/;
+        const validPeriodMatch = processedText.match(validPeriodRegex1) || processedText.match(validPeriodRegex2);
+        if (validPeriodMatch && validPeriodMatch[1] && validPeriodMatch[3]) {
+            const startDate = formatDateString(validPeriodMatch[1]);
+            const endDate = /\d/.test(validPeriodMatch[3]) ? formatDateString(validPeriodMatch[3]) : '长期有效';
+            info.validFrom = startDate;
+            info.validTo = endDate;
+            info.validPeriod = `${startDate}-${endDate}`;
+        }
+        else if (validPeriodMatch) {
+            info.validPeriod = validPeriodMatch[0].replace("有效期限", "").trim();
+        }
+        return info;
+    }
+}
+
+/**
+ * @file Canvas 对象池
+ * @description 提供 Canvas 元素的复用机制，减少内存分配和 GC 压力
+ * @module utils/canvas-pool
+ */
+/**
+ * Canvas 对象池
  *
- * 提供各种图像处理功能，用于优化识别效果
+ * 复用 Canvas 元素，避免频繁创建和销毁导致的内存抖动
+ *
+ * @example
+ * ```typescript
+ * const pool = CanvasPool.getInstance();
+ * const { canvas, context } = pool.acquire(100, 200);
+ * // 使用 canvas 进行绘制...
+ * pool.release(canvas);
+ * ```
  */
-class ImageProcessor {
+class CanvasPool {
     /**
-     * 将ImageData转换为Canvas元素
-     *
-     * @param {ImageData} imageData - 要转换的图像数据
-     * @returns {HTMLCanvasElement} 包含图像的Canvas元素
+     * 获取单例实例
      */
-    static imageDataToCanvas(imageData) {
-        const canvas = document.createElement("canvas");
-        canvas.width = imageData.width;
-        canvas.height = imageData.height;
-        const ctx = canvas.getContext("2d");
-        if (ctx) {
-            ctx.putImageData(imageData, 0, 0);
+    static getInstance() {
+        if (!CanvasPool.instance) {
+            CanvasPool.instance = new CanvasPool();
         }
-        return canvas;
+        return CanvasPool.instance;
     }
     /**
-     * 将Canvas转换为ImageData
-     *
-     * @param {HTMLCanvasElement} canvas - 要转换的Canvas元素
-     * @returns {ImageData|null} Canvas的图像数据，如果获取失败则返回null
+     * 重置单例实例（主要用于测试）
      */
-    static canvasToImageData(canvas) {
-        const ctx = canvas.getContext("2d");
-        return ctx ? ctx.getImageData(0, 0, canvas.width, canvas.height) : null;
+    static resetInstance() {
+        if (CanvasPool.instance) {
+            CanvasPool.instance.dispose();
+            CanvasPool.instance = null;
+        }
     }
     /**
-     * 调整图像亮度和对比度
-     *
-     * @param imageData 原始图像数据
-     * @param brightness 亮度调整值 (-100到100)
-     * @param contrast 对比度调整值 (-100到100)
-     * @returns 处理后的图像数据
+     * 私有构造函数
      */
-    static adjustBrightnessContrast(imageData, brightness = 0, contrast = 0) {
-        // 将亮度和对比度范围限制在 -100 到 100 之间
-        brightness = Math.max(-100, Math.min(100, brightness));
-        contrast = Math.max(-100, Math.min(100, contrast));
-        // 将范围转换为适合计算的值
-        const factor = (259 * (contrast + 255)) / (255 * (259 - contrast));
-        const briAdjust = (brightness / 100) * 255;
-        const data = imageData.data;
-        const length = data.length;
-        for (let i = 0; i < length; i += 4) {
-            // 分别处理 RGB 三个通道
-            for (let j = 0; j < 3; j++) {
-                // 应用亮度和对比度调整公式
-                const newValue = factor * (data[i + j] + briAdjust - 128) + 128;
-                data[i + j] = Math.max(0, Math.min(255, newValue));
+    constructor() {
+        /** Canvas 池存储 */
+        this.pool = new Map();
+        /** 已借出的 Canvas */
+        this.borrowed = new Map();
+        /** 最大池大小（每个尺寸） */
+        this.maxPoolSize = 4;
+        /** Canvas 尺寸容差（允许一定范围的尺寸复用） */
+        this.sizeTolerance = 10;
+        // 页面卸载前清理
+        if (typeof window !== 'undefined') {
+            window.addEventListener('beforeunload', () => this.dispose());
+        }
+    }
+    /**
+     * 生成尺寸键
+     * @param width 宽度
+     * @param height 高度
+     */
+    getSizeKey(width, height) {
+        return `${width}x${height}`;
+    }
+    /**
+     * 查找匹配的尺寸键（考虑容差）
+     * @param width 宽度
+     * @param height 高度
+     */
+    findMatchingSizeKey(width, height) {
+        for (const [key, items] of this.pool.entries()) {
+            const [w, h] = key.split('x').map(Number);
+            if (Math.abs(w - width) <= this.sizeTolerance &&
+                Math.abs(h - height) <= this.sizeTolerance) {
+                // 找到可用的
+                const available = items.filter(item => !item.inUse);
+                if (available.length > 0) {
+                    return key;
+                }
             }
-            // Alpha 通道保持不变
         }
-        return imageData;
+        return null;
     }
     /**
-     * 将图像转换为灰度图
+     * 从池中获取 Canvas
      *
-     * @param imageData 原始图像数据
-     * @returns 灰度图像数据
+     * @param width  宽度
+     * @param height 高度
+     * @returns Canvas 和其上下文
+     */
+    acquire(width, height) {
+        // 先尝试精确匹配
+        let sizeKey = this.getSizeKey(width, height);
+        let items = this.pool.get(sizeKey);
+        // 如果没有精确匹配，尝试模糊匹配
+        if (!items || items.every(item => item.inUse)) {
+            const matchedKey = this.findMatchingSizeKey(width, height);
+            if (matchedKey) {
+                sizeKey = matchedKey;
+                items = this.pool.get(sizeKey);
+            }
+        }
+        // 如果没有可用的，创建一个新的
+        if (!items || items.every(item => item.inUse)) {
+            const canvas = document.createElement('canvas');
+            canvas.width = width;
+            canvas.height = height;
+            const context = canvas.getContext('2d');
+            const item = {
+                canvas,
+                context,
+                inUse: true,
+                lastUsed: Date.now(),
+                sizeKey: this.getSizeKey(width, height)
+            };
+            // 如果池已满，移除最老的
+            if (!items) {
+                items = [];
+                this.pool.set(sizeKey, items);
+            }
+            else if (items.length >= this.maxPoolSize) {
+                // 找到最老的未使用项并移除
+                let oldestIdx = 0;
+                let oldestTime = Infinity;
+                items.forEach((item, idx) => {
+                    if (!item.inUse && item.lastUsed < oldestTime) {
+                        oldestTime = item.lastUsed;
+                        oldestIdx = idx;
+                    }
+                });
+                const removed = items.splice(oldestIdx, 1)[0];
+                this.borrowed.delete(removed.canvas);
+            }
+            items.push(item);
+            this.borrowed.set(canvas, item);
+            return { canvas, context };
+        }
+        // 找到一个空闲的
+        const available = items.find(item => !item.inUse);
+        available.inUse = true;
+        available.lastUsed = Date.now();
+        // 如果尺寸变化，更新 canvas
+        if (available.canvas.width !== width || available.canvas.height !== height) {
+            available.canvas.width = width;
+            available.canvas.height = height;
+            available.sizeKey = sizeKey;
+        }
+        // 清除之前的上下文状态
+        available.context.setTransform(1, 0, 0, 1, 0, 0);
+        available.context.clearRect(0, 0, width, height);
+        this.borrowed.set(available.canvas, available);
+        return { canvas: available.canvas, context: available.context };
+    }
+    /**
+     * 释放 Canvas 回池中
+     *
+     * @param canvas 要释放的 Canvas
      */
-    static toGrayscale(imageData) {
-        const data = imageData.data;
-        const length = data.length;
-        for (let i = 0; i < length; i += 4) {
-            // 使用加权平均法将 RGB 转换为灰度值
-            const gray = data[i] * 0.3 + data[i + 1] * 0.59 + data[i + 2] * 0.11;
-            data[i] = data[i + 1] = data[i + 2] = gray;
+    release(canvas) {
+        const item = this.borrowed.get(canvas);
+        if (!item) {
+            // 不属于我们管理的 Canvas，忽略
+            return;
         }
-        return imageData;
+        item.inUse = false;
+        item.lastUsed = Date.now();
+        this.borrowed.delete(canvas);
     }
     /**
-     * 锐化图像
-     *
-     * @param imageData 原始图像数据
-     * @param amount 锐化程度，默认为2
-     * @returns 锐化后的图像数据
+     * 批量释放所有借出的 Canvas
+     */
+    releaseAll() {
+        for (const [, item] of this.borrowed) {
+            item.inUse = false;
+            item.lastUsed = Date.now();
+        }
+        this.borrowed.clear();
+    }
+    /**
+     * 预热池（预创建指定尺寸的 Canvas）
+     *
+     * @param sizes 尺寸数组，每项为 [width, height]
+     */
+    warmup(sizes) {
+        for (const [width, height] of sizes) {
+            this.acquire(width, height);
+            // 立即释放，让它们进入池中
+            const sizeKey = this.getSizeKey(width, height);
+            const items = this.pool.get(sizeKey);
+            if (items && items.length > 0) {
+                const item = items[items.length - 1];
+                item.inUse = false;
+                this.borrowed.delete(item.canvas);
+            }
+        }
+    }
+    /**
+     * 获取池统计信息
+     */
+    getStats() {
+        let totalItems = 0;
+        let borrowedCount = 0;
+        const poolSizes = {};
+        for (const [key, items] of this.pool.entries()) {
+            totalItems += items.length;
+            borrowedCount += items.filter(i => i.inUse).length;
+            poolSizes[key] = {
+                total: items.length,
+                available: items.filter(i => !i.inUse).length
+            };
+        }
+        return { totalItems, borrowedCount, poolSizes };
+    }
+    /**
+     * 清理并释放所有资源
+     */
+    dispose() {
+        this.pool.clear();
+        this.borrowed.clear();
+    }
+}
+/** 单例实例 */
+CanvasPool.instance = null;
+
+/**
+ * @file 边缘检测器
+ * @description 提供边缘检测算法（Sobel、Canny等）
+ * @module utils/edge-detector
+ */
+/**
+ * 边缘检测器类
+ * 提供各种边缘检测算法用于图像处理
+ */
+class EdgeDetector {
+    /**
+     * 使用Sobel算子进行边缘检测
+     * @param imageData 灰度图像数据
+     * @param threshold 边缘阈值，默认为30
+     * @returns 检测到边缘的图像数据
+     */
+    static detectEdges(imageData, threshold = 30) {
+        const grayscaleImage = this.toGrayscale(new ImageData(new Uint8ClampedArray(imageData.data), imageData.width, imageData.height));
+        const width = grayscaleImage.width;
+        const height = grayscaleImage.height;
+        const inputData = grayscaleImage.data;
+        const outputData = new Uint8ClampedArray(inputData.length);
+        const sobelX = [-1, 0, 1, -2, 0, 2, -1, 0, 1];
+        const sobelY = [-1, -2, -1, 0, 0, 0, 1, 2, 1];
+        for (let y = 1; y < height - 1; y++) {
+            for (let x = 1; x < width - 1; x++) {
+                let gx = 0, gy = 0;
+                for (let ky = -1; ky <= 1; ky++) {
+                    for (let kx = -1; kx <= 1; kx++) {
+                        const pixelPos = ((y + ky) * width + (x + kx)) * 4;
+                        const pixelVal = inputData[pixelPos];
+                        const kernelIdx = (ky + 1) * 3 + (kx + 1);
+                        gx += pixelVal * sobelX[kernelIdx];
+                        gy += pixelVal * sobelY[kernelIdx];
+                    }
+                }
+                let magnitude = Math.sqrt(gx * gx + gy * gy);
+                magnitude = magnitude > threshold ? 255 : 0;
+                const pos = (y * width + x) * 4;
+                outputData[pos] = outputData[pos + 1] = outputData[pos + 2] = magnitude;
+                outputData[pos + 3] = 255;
+            }
+        }
+        // 处理边缘
+        for (let i = 0; i < width * 4; i++) {
+            outputData[i] = 0;
+            outputData[(height - 1) * width * 4 + i] = 0;
+        }
+        for (let i = 0; i < height; i++) {
+            const leftPos = i * width * 4;
+            const rightPos = (i * width + width - 1) * 4;
+            for (let j = 0; j < 4; j++) {
+                outputData[leftPos + j] = 0;
+                outputData[rightPos + j] = 0;
+            }
+        }
+        return new ImageData(outputData, width, height);
+    }
+    /**
+     * 卡尼-德里奇边缘检测
+     */
+    static cannyEdgeDetection(imageData, lowThreshold = 20, highThreshold = 50) {
+        const grayscaleImage = this.toGrayscale(new ImageData(new Uint8ClampedArray(imageData.data), imageData.width, imageData.height));
+        const blurredImage = this.gaussianBlur(grayscaleImage, 1.5);
+        const { gradientMagnitude, gradientDirection } = this.computeGradients(blurredImage);
+        const nonMaxSuppressed = this.nonMaxSuppression(gradientMagnitude, gradientDirection, blurredImage.width, blurredImage.height);
+        const thresholdResult = this.hysteresisThresholding(nonMaxSuppressed, blurredImage.width, blurredImage.height, lowThreshold, highThreshold);
+        const outputData = new Uint8ClampedArray(imageData.data.length);
+        for (let i = 0; i < thresholdResult.length; i++) {
+            const pos = i * 4;
+            const value = thresholdResult[i] ? 255 : 0;
+            outputData[pos] = outputData[pos + 1] = outputData[pos + 2] = value;
+            outputData[pos + 3] = 255;
+        }
+        return new ImageData(outputData, blurredImage.width, blurredImage.height);
+    }
+    static toGrayscale(imageData) {
+        const srcData = imageData.data;
+        const destData = new Uint8ClampedArray(srcData);
+        for (let i = 0; i < srcData.length; i += 4) {
+            const gray = srcData[i] * 0.3 + srcData[i + 1] * 0.59 + srcData[i + 2] * 0.11;
+            destData[i] = destData[i + 1] = destData[i + 2] = gray;
+            destData[i + 3] = srcData[i + 3];
+        }
+        return new ImageData(destData, imageData.width, imageData.height);
+    }
+    static gaussianBlur(imageData, sigma = 1.5) {
+        const width = imageData.width, height = imageData.height;
+        const inputData = imageData.data, outputData = new Uint8ClampedArray(inputData.length);
+        const kernelSize = Math.max(3, Math.floor(sigma * 3) * 2 + 1);
+        const halfKernel = Math.floor(kernelSize / 2);
+        const kernel = this.generateGaussianKernel(kernelSize, sigma);
+        for (let y = 0; y < height; y++) {
+            for (let x = 0; x < width; x++) {
+                let sum = 0, weightSum = 0;
+                for (let ky = -halfKernel; ky <= halfKernel; ky++) {
+                    for (let kx = -halfKernel; kx <= halfKernel; kx++) {
+                        const pixelY = Math.min(Math.max(y + ky, 0), height - 1);
+                        const pixelX = Math.min(Math.max(x + kx, 0), width - 1);
+                        const pixelPos = (pixelY * width + pixelX) * 4;
+                        const kernelY = ky + halfKernel, kernelX = kx + halfKernel;
+                        const weight = kernel[kernelY * kernelSize + kernelX];
+                        sum += inputData[pixelPos] * weight;
+                        weightSum += weight;
+                    }
+                }
+                const pos = (y * width + x) * 4;
+                const value = Math.round(sum / weightSum);
+                outputData[pos] = outputData[pos + 1] = outputData[pos + 2] = value;
+                outputData[pos + 3] = 255;
+            }
+        }
+        return new ImageData(outputData, width, height);
+    }
+    static generateGaussianKernel(size, sigma) {
+        const kernel = new Array(size * size);
+        const center = Math.floor(size / 2);
+        let sum = 0;
+        for (let y = 0; y < size; y++) {
+            for (let x = 0; x < size; x++) {
+                const distance = Math.sqrt((x - center) ** 2 + (y - center) ** 2);
+                kernel[y * size + x] = Math.exp(-(distance ** 2) / (2 * sigma ** 2));
+                sum += kernel[y * size + x];
+            }
+        }
+        for (let i = 0; i < kernel.length; i++)
+            kernel[i] /= sum;
+        return kernel;
+    }
+    static computeGradients(imageData) {
+        const width = imageData.width, height = imageData.height;
+        const inputData = imageData.data;
+        const gradientMagnitude = new Array(width * height);
+        const gradientDirection = new Array(width * height);
+        const sobelX = [-1, 0, 1, -2, 0, 2, -1, 0, 1];
+        const sobelY = [-1, -2, -1, 0, 0, 0, 1, 2, 1];
+        for (let y = 1; y < height - 1; y++) {
+            for (let x = 1; x < width - 1; x++) {
+                let gx = 0, gy = 0;
+                for (let ky = -1; ky <= 1; ky++) {
+                    for (let kx = -1; kx <= 1; kx++) {
+                        const pixelPos = ((y + ky) * width + (x + kx)) * 4;
+                        const pixelVal = inputData[pixelPos];
+                        const kernelIdx = (ky + 1) * 3 + (kx + 1);
+                        gx += pixelVal * sobelX[kernelIdx];
+                        gy += pixelVal * sobelY[kernelIdx];
+                    }
+                }
+                const idx = y * width + x;
+                gradientMagnitude[idx] = Math.sqrt(gx * gx + gy * gy);
+                gradientDirection[idx] = Math.atan2(gy, gx);
+            }
+        }
+        return { gradientMagnitude, gradientDirection };
+    }
+    static nonMaxSuppression(gradientMagnitude, gradientDirection, width, height) {
+        const result = new Array(width * height).fill(0);
+        for (let y = 1; y < height - 1; y++) {
+            for (let x = 1; x < width - 1; x++) {
+                const idx = y * width + x;
+                const magnitude = gradientMagnitude[idx];
+                const direction = gradientDirection[idx];
+                const degrees = (direction * 180 / Math.PI + 180) % 180;
+                let neighbor1Idx, neighbor2Idx;
+                if ((degrees >= 0 && degrees < 22.5) || (degrees >= 157.5 && degrees <= 180)) {
+                    neighbor1Idx = idx - 1;
+                    neighbor2Idx = idx + 1;
+                }
+                else if (degrees >= 22.5 && degrees < 67.5) {
+                    neighbor1Idx = (y - 1) * width + (x + 1);
+                    neighbor2Idx = (y + 1) * width + (x - 1);
+                }
+                else if (degrees >= 67.5 && degrees < 112.5) {
+                    neighbor1Idx = (y - 1) * width + x;
+                    neighbor2Idx = (y + 1) * width + x;
+                }
+                else {
+                    neighbor1Idx = (y - 1) * width + (x - 1);
+                    neighbor2Idx = (y + 1) * width + (x + 1);
+                }
+                if (magnitude >= gradientMagnitude[neighbor1Idx] && magnitude >= gradientMagnitude[neighbor2Idx]) {
+                    result[idx] = magnitude;
+                }
+            }
+        }
+        return result;
+    }
+    static hysteresisThresholding(nonMaxSuppressed, width, height, lowThreshold, highThreshold) {
+        const result = new Array(width * height).fill(false);
+        const visited = new Array(width * height).fill(false);
+        const stack = [];
+        for (let i = 0; i < nonMaxSuppressed.length; i++) {
+            if (nonMaxSuppressed[i] >= highThreshold) {
+                result[i] = true;
+                stack.push(i);
+                visited[i] = true;
+            }
+        }
+        const dx = [-1, 0, 1, -1, 1, -1, 0, 1];
+        const dy = [-1, -1, -1, 0, 0, 1, 1, 1];
+        while (stack.length > 0) {
+            const currentIdx = stack.pop();
+            const currentX = currentIdx % width;
+            const currentY = Math.floor(currentIdx / width);
+            for (let i = 0; i < 8; i++) {
+                const newX = currentX + dx[i];
+                const newY = currentY + dy[i];
+                if (newX >= 0 && newX < width && newY >= 0 && newY < height) {
+                    const newIdx = newY * width + newX;
+                    if (!visited[newIdx] && nonMaxSuppressed[newIdx] >= lowThreshold) {
+                        result[newIdx] = true;
+                        stack.push(newIdx);
+                        visited[newIdx] = true;
+                    }
+                }
+            }
+        }
+        return result;
+    }
+}
+
+/**
+ * @file 图像处理工具类
+ * @description 提供图像预处理功能，用于提高OCR识别率
+ * @module ImageProcessor
+ * @version 1.4.0
+ */
+/**
+ * 图像处理工具类
+ *
+ * 提供各种图像处理功能，用于优化识别效果
+ */
+class ImageProcessor {
+    /**
+     * 将ImageData转换为Canvas元素
+     *
+     * @param {ImageData} imageData - 要转换的图像数据
+     * @returns {HTMLCanvasElement} 包含图像的Canvas元素
+     */
+    static imageDataToCanvas(imageData, usePool = true) {
+        let canvas;
+        let context;
+        if (usePool) {
+            ({ canvas, context } = CanvasPool.getInstance().acquire(imageData.width, imageData.height));
+        }
+        else {
+            canvas = document.createElement("canvas");
+            canvas.width = imageData.width;
+            canvas.height = imageData.height;
+            context = canvas.getContext("2d");
+        }
+        context.putImageData(imageData, 0, 0);
+        if (usePool) {
+            // 立即释放回池中，用户保留 canvas 引用即可
+            CanvasPool.getInstance().release(canvas);
+        }
+        return canvas;
+    }
+    /**
+     * 将Canvas转换为ImageData
+     *
+     * @param {HTMLCanvasElement} canvas - 要转换的Canvas元素
+     * @returns {ImageData|null} Canvas的图像数据，如果获取失败则返回null
+     */
+    static canvasToImageData(canvas) {
+        const ctx = canvas.getContext("2d");
+        return ctx ? ctx.getImageData(0, 0, canvas.width, canvas.height) : null;
+    }
+    /**
+     * 调整图像亮度和对比度
+     *
+     * @param imageData 原始图像数据
+     * @param brightness 亮度调整值 (-100到100)
+     * @param contrast 对比度调整值 (-100到100)
+     * @returns 处理后的图像数据
+     */
+    static adjustBrightnessContrast(imageData, brightness = 0, contrast = 0) {
+        // 将亮度和对比度范围限制在 -100 到 100 之间
+        brightness = Math.max(-100, Math.min(100, brightness));
+        contrast = Math.max(-100, Math.min(100, contrast));
+        // 将范围转换为适合计算的值
+        const factor = (259 * (contrast + 255)) / (255 * (259 - contrast));
+        const briAdjust = (brightness / 100) * 255;
+        const data = imageData.data;
+        const length = data.length;
+        for (let i = 0; i < length; i += 4) {
+            // 分别处理 RGB 三个通道
+            for (let j = 0; j < 3; j++) {
+                // 应用亮度和对比度调整公式
+                const newValue = factor * (data[i + j] + briAdjust - 128) + 128;
+                data[i + j] = Math.max(0, Math.min(255, newValue));
+            }
+            // Alpha 通道保持不变
+        }
+        return imageData;
+    }
+    /**
+     * 将图像转换为灰度图（返回新 ImageData，不修改原图）
+     *
+     * @param imageData 原始图像数据
+     * @returns 灰度图像数据（新对象）
+     */
+    static toGrayscale(imageData) {
+        const srcData = imageData.data;
+        const length = srcData.length;
+        // 创建新数组，避免修改原图
+        const destData = new Uint8ClampedArray(srcData);
+        for (let i = 0; i < length; i += 4) {
+            // 使用加权平均法将 RGB 转换为灰度值
+            const gray = srcData[i] * 0.3 + srcData[i + 1] * 0.59 + srcData[i + 2] * 0.11;
+            destData[i] = destData[i + 1] = destData[i + 2] = gray;
+            // Alpha 通道保持不变
+            destData[i + 3] = srcData[i + 3];
+        }
+        return new ImageData(destData, imageData.width, imageData.height);
+    }
+    /**
+     * 锐化图像
+     *
+     * @param imageData 原始图像数据
+     * @param amount 锐化程度，默认为2
+     * @returns 锐化后的图像数据
      */
     static sharpen(imageData, amount = 2) {
         if (!imageData || !imageData.data)
@@ -1722,52 +2385,79 @@ class ImageProcessor {
                 outputData[pos + 3] = data[pos + 3]; // 保持透明度不变
             }
         }
-        // 处理边缘像素
-        for (let y = 0; y < height; y++) {
-            for (let x = 0; x < width; x++) {
-                if (y === 0 || y === height - 1 || x === 0 || x === width - 1) {
-                    const pos = (y * width + x) * 4;
-                    outputData[pos] = data[pos];
-                    outputData[pos + 1] = data[pos + 1];
-                    outputData[pos + 2] = data[pos + 2];
-                    outputData[pos + 3] = data[pos + 3];
-                }
-            }
+        // 处理边缘像素（仅遍历四条边，而非全图 O(width×height) → O(width+height)）
+        // 上边 + 下边
+        for (let x = 0; x < width; x++) {
+            const topPos = x * 4;
+            const bottomPos = ((height - 1) * width + x) * 4;
+            outputData[topPos] = data[topPos];
+            outputData[topPos + 1] = data[topPos + 1];
+            outputData[topPos + 2] = data[topPos + 2];
+            outputData[topPos + 3] = data[topPos + 3];
+            outputData[bottomPos] = data[bottomPos];
+            outputData[bottomPos + 1] = data[bottomPos + 1];
+            outputData[bottomPos + 2] = data[bottomPos + 2];
+            outputData[bottomPos + 3] = data[bottomPos + 3];
+        }
+        // 左边 + 右边（排除四角，它们已在上下一行处理）
+        for (let y = 1; y < height - 1; y++) {
+            const leftPos = y * width * 4;
+            const rightPos = (y * width + width - 1) * 4;
+            outputData[leftPos] = data[leftPos];
+            outputData[leftPos + 1] = data[leftPos + 1];
+            outputData[leftPos + 2] = data[leftPos + 2];
+            outputData[leftPos + 3] = data[leftPos + 3];
+            outputData[rightPos] = data[rightPos];
+            outputData[rightPos + 1] = data[rightPos + 1];
+            outputData[rightPos + 2] = data[rightPos + 2];
+            outputData[rightPos + 3] = data[rightPos + 3];
         }
         // 创建新的ImageData对象
         return new ImageData(outputData, width, height);
     }
     /**
-     * 对图像应用阈值操作，增强对比度
+     * 对图像应用阈值操作，增强对比度（二值化）
      *
      * @param imageData 原始图像数据
      * @param threshold 阈值 (0-255)
-     * @returns 处理后的图像数据
+     * @returns 处理后的图像数据（新对象，不修改原图）
      */
     static threshold(imageData, threshold = 128) {
-        // 先转换为灰度图
-        const grayscaleImage = this.toGrayscale(new ImageData(new Uint8ClampedArray(imageData.data), imageData.width, imageData.height));
-        const data = grayscaleImage.data;
-        const length = data.length;
+        // 先转换为灰度图（返回新 ImageData，不修改原图）
+        const grayscaleImage = this.toGrayscale(imageData);
+        const srcData = grayscaleImage.data;
+        const length = srcData.length;
+        // 创建新数组存储二值化结果
+        const destData = new Uint8ClampedArray(length);
         for (let i = 0; i < length; i += 4) {
             // 二值化处理
-            const value = data[i] < threshold ? 0 : 255;
-            data[i] = data[i + 1] = data[i + 2] = value;
+            const value = srcData[i] < threshold ? 0 : 255;
+            destData[i] = destData[i + 1] = destData[i + 2] = value;
+            destData[i + 3] = srcData[i + 3]; // 保持透明度
         }
-        return grayscaleImage;
+        return new ImageData(destData, grayscaleImage.width, grayscaleImage.height);
     }
     /**
-     * 将图像转换为黑白图像（二值化）
+     * 将图像转换为黑白图像（二值化，使用OTSU自动阈值）
      *
      * @param imageData 原始图像数据
-     * @returns 二值化后的图像数据
+     * @returns 二值化后的图像数据（新对象，不修改原图）
      */
     static toBinaryImage(imageData) {
-        // 先转换为灰度图
-        const grayscaleImage = this.toGrayscale(new ImageData(new Uint8ClampedArray(imageData.data), imageData.width, imageData.height));
+        // 先转换为灰度图（返回新 ImageData，不修改原图）
+        const grayscaleImage = this.toGrayscale(imageData);
         // 使用OTSU算法自动确定阈值
         const threshold = this.getOtsuThreshold(grayscaleImage);
-        return this.threshold(grayscaleImage, threshold);
+        // 直接对灰度图进行二值化，避免再次调用 toGrayscale
+        const srcData = grayscaleImage.data;
+        const length = srcData.length;
+        const destData = new Uint8ClampedArray(length);
+        for (let i = 0; i < length; i += 4) {
+            const value = srcData[i] < threshold ? 0 : 255;
+            destData[i] = destData[i + 1] = destData[i + 2] = value;
+            destData[i + 3] = srcData[i + 3]; // 保持透明度
+        }
+        return new ImageData(destData, grayscaleImage.width, grayscaleImage.height);
     }
     /**
      * 使用OTSU算法计算最佳阈值
@@ -1777,8 +2467,9 @@ class ImageProcessor {
      */
     static getOtsuThreshold(imageData) {
         const data = imageData.data;
-        const histogram = new Array(256).fill(0);
-        // 统计灰度直方图
+        // 使用 Uint8Array 替代 Array<number>，避免 boxing 开销，提升直方图统计性能
+        const histogram = new Uint32Array(256);
+        // 统计灰度直方图（每4字节取R通道，即灰度值）
         for (let i = 0; i < data.length; i += 4) {
             histogram[data[i]]++;
         }
@@ -1884,24 +2575,20 @@ class ImageProcessor {
                 const url = URL.createObjectURL(file);
                 img.onload = () => {
                     try {
-                        // 创建canvas元素
-                        const canvas = document.createElement("canvas");
-                        const ctx = canvas.getContext("2d");
-                        if (!ctx) {
-                            reject(new Error("无法创建2D上下文"));
-                            return;
-                        }
-                        canvas.width = img.width;
-                        canvas.height = img.height;
+                        // 使用 Canvas 池获取 canvas
+                        const { canvas, context } = CanvasPool.getInstance().acquire(img.width, img.height);
                         // 绘制图片到canvas
-                        ctx.drawImage(img, 0, 0);
+                        context.drawImage(img, 0, 0);
                         // 获取图像数据
-                        const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+                        const imageData = context.getImageData(0, 0, canvas.width, canvas.height);
+                        // 释放回池
+                        CanvasPool.getInstance().release(canvas);
                         // 释放资源
                         URL.revokeObjectURL(url);
                         resolve(imageData);
                     }
                     catch (e) {
+                        URL.revokeObjectURL(url);
                         reject(e);
                     }
                 };
@@ -1928,16 +2615,12 @@ class ImageProcessor {
     static async imageDataToFile(imageData, fileName = "image.jpg", fileType = "image/jpeg", quality = 0.8) {
         return new Promise((resolve, reject) => {
             try {
-                const canvas = document.createElement("canvas");
-                canvas.width = imageData.width;
-                canvas.height = imageData.height;
-                const ctx = canvas.getContext("2d");
-                if (!ctx) {
-                    reject(new Error("无法创建2D上下文"));
-                    return;
-                }
-                ctx.putImageData(imageData, 0, 0);
+                // 使用 Canvas 池
+                const { canvas, context } = CanvasPool.getInstance().acquire(imageData.width, imageData.height);
+                context.putImageData(imageData, 0, 0);
                 canvas.toBlob((blob) => {
+                    // 释放回池
+                    CanvasPool.getInstance().release(canvas);
                     if (!blob) {
                         reject(new Error("无法创建图片Blob"));
                         return;
@@ -1971,327 +2654,67 @@ class ImageProcessor {
         let height;
         if (image instanceof ImageData) {
             width = image.width;
-            height = image.height;
-        }
-        else {
-            width = image.width;
-            height = image.height;
-        }
-        // 计算调整后的尺寸
-        let newWidth = width;
-        let newHeight = height;
-        if (keepAspectRatio) {
-            if (width > height) {
-                if (width > maxWidth) {
-                    newHeight = Math.round(height * (maxWidth / width));
-                    newWidth = maxWidth;
-                }
-            }
-            else {
-                if (height > maxHeight) {
-                    newWidth = Math.round(width * (maxHeight / height));
-                    newHeight = maxHeight;
-                }
-            }
-        }
-        else {
-            newWidth = Math.min(width, maxWidth);
-            newHeight = Math.min(height, maxHeight);
-        }
-        // 设置canvas尺寸
-        canvas.width = newWidth;
-        canvas.height = newHeight;
-        // 绘制调整后的图像
-        if (image instanceof ImageData) {
-            // 创建临时canvas存储ImageData
-            const tempCanvas = document.createElement('canvas');
-            const tempCtx = tempCanvas.getContext('2d');
-            if (!tempCtx) {
-                throw new Error('无法创建临时Canvas上下文');
-            }
-            tempCanvas.width = image.width;
-            tempCanvas.height = image.height;
-            tempCtx.putImageData(image, 0, 0);
-            // 绘制调整后的图像
-            ctx.drawImage(tempCanvas, 0, 0, width, height, 0, 0, newWidth, newHeight);
-        }
-        else {
-            ctx.drawImage(image, 0, 0, width, height, 0, 0, newWidth, newHeight);
-        }
-        // 返回调整后的ImageData
-        return ctx.getImageData(0, 0, newWidth, newHeight);
-    }
-    /**
-     * 边缘检测算法，用于识别图像中的边缘
-     * 基于Sobel算子实现
-     *
-     * @param imageData 原始图像数据，应已转为灰度图
-     * @param threshold 边缘阈值，默认为30
-     * @returns 检测到边缘的图像数据
-     */
-    static detectEdges(imageData, threshold = 30) {
-        // 确保输入图像是灰度图
-        const grayscaleImage = this.toGrayscale(new ImageData(new Uint8ClampedArray(imageData.data), imageData.width, imageData.height));
-        const width = grayscaleImage.width;
-        const height = grayscaleImage.height;
-        const inputData = grayscaleImage.data;
-        const outputData = new Uint8ClampedArray(inputData.length);
-        // Sobel算子 - 水平和垂直方向
-        const sobelX = [-1, 0, 1, -2, 0, 2, -1, 0, 1];
-        const sobelY = [-1, -2, -1, 0, 0, 0, 1, 2, 1];
-        // 对每个像素应用Sobel算子
-        for (let y = 1; y < height - 1; y++) {
-            for (let x = 1; x < width - 1; x++) {
-                let gx = 0;
-                let gy = 0;
-                // 应用卷积
-                for (let ky = -1; ky <= 1; ky++) {
-                    for (let kx = -1; kx <= 1; kx++) {
-                        const pixelPos = ((y + ky) * width + (x + kx)) * 4;
-                        const pixelVal = inputData[pixelPos]; // 灰度值
-                        const kernelIdx = (ky + 1) * 3 + (kx + 1);
-                        gx += pixelVal * sobelX[kernelIdx];
-                        gy += pixelVal * sobelY[kernelIdx];
-                    }
-                }
-                // 计算梯度强度
-                let magnitude = Math.sqrt(gx * gx + gy * gy);
-                // 应用阈值
-                magnitude = magnitude > threshold ? 255 : 0;
-                // 设置输出像素
-                const pos = (y * width + x) * 4;
-                outputData[pos] = outputData[pos + 1] = outputData[pos + 2] = magnitude;
-                outputData[pos + 3] = 255; // 透明度保持完全不透明
-            }
-        }
-        // 处理边缘像素
-        for (let i = 0; i < width * 4; i++) {
-            // 顶部和底部行
-            outputData[i] = 0;
-            outputData[(height - 1) * width * 4 + i] = 0;
-        }
-        for (let i = 0; i < height; i++) {
-            // 左右两侧列
-            const leftPos = i * width * 4;
-            const rightPos = (i * width + width - 1) * 4;
-            for (let j = 0; j < 4; j++) {
-                outputData[leftPos + j] = 0;
-                outputData[rightPos + j] = 0;
-            }
-        }
-        return new ImageData(outputData, width, height);
-    }
-    /**
-     * 卡尼-德里奇边缘检测
-     * 相比Sobel更精确的边缘检测算法
-     *
-     * @param imageData 灰度图像数据
-     * @param lowThreshold 低阈值
-     * @param highThreshold 高阈值
-     * @returns 边缘检测结果
-     */
-    static cannyEdgeDetection(imageData, lowThreshold = 20, highThreshold = 50) {
-        const grayscaleImage = this.toGrayscale(new ImageData(new Uint8ClampedArray(imageData.data), imageData.width, imageData.height));
-        // 1. 高斯模糊
-        const blurredImage = this.gaussianBlur(grayscaleImage, 1.5);
-        // 2. 使用Sobel算子计算梯度
-        const { gradientMagnitude, gradientDirection } = this.computeGradients(blurredImage);
-        // 3. 非极大值抛弃
-        const nonMaxSuppressed = this.nonMaxSuppression(gradientMagnitude, gradientDirection, blurredImage.width, blurredImage.height);
-        // 4. 双阈值处理
-        const thresholdResult = this.hysteresisThresholding(nonMaxSuppressed, blurredImage.width, blurredImage.height, lowThreshold, highThreshold);
-        // 创建输出图像
-        const outputData = new Uint8ClampedArray(imageData.data.length);
-        // 将结果转换为ImageData
-        for (let i = 0; i < thresholdResult.length; i++) {
-            const pos = i * 4;
-            const value = thresholdResult[i] ? 255 : 0;
-            outputData[pos] = outputData[pos + 1] = outputData[pos + 2] = value;
-            outputData[pos + 3] = 255;
-        }
-        return new ImageData(outputData, blurredImage.width, blurredImage.height);
-    }
-    /**
-     * 高斯模糊
-     */
-    static gaussianBlur(imageData, sigma = 1.5) {
-        const width = imageData.width;
-        const height = imageData.height;
-        const inputData = imageData.data;
-        const outputData = new Uint8ClampedArray(inputData.length);
-        // 生成高斯核
-        const kernelSize = Math.max(3, Math.floor(sigma * 3) * 2 + 1);
-        const halfKernel = Math.floor(kernelSize / 2);
-        const kernel = this.generateGaussianKernel(kernelSize, sigma);
-        // 应用高斯核
-        for (let y = 0; y < height; y++) {
-            for (let x = 0; x < width; x++) {
-                let sum = 0;
-                let weightSum = 0;
-                for (let ky = -halfKernel; ky <= halfKernel; ky++) {
-                    for (let kx = -halfKernel; kx <= halfKernel; kx++) {
-                        const pixelY = Math.min(Math.max(y + ky, 0), height - 1);
-                        const pixelX = Math.min(Math.max(x + kx, 0), width - 1);
-                        const pixelPos = (pixelY * width + pixelX) * 4;
-                        const kernelY = ky + halfKernel;
-                        const kernelX = kx + halfKernel;
-                        const weight = kernel[kernelY * kernelSize + kernelX];
-                        sum += inputData[pixelPos] * weight;
-                        weightSum += weight;
-                    }
-                }
-                const pos = (y * width + x) * 4;
-                const value = Math.round(sum / weightSum);
-                outputData[pos] = outputData[pos + 1] = outputData[pos + 2] = value;
-                outputData[pos + 3] = 255;
-            }
-        }
-        return new ImageData(outputData, width, height);
-    }
-    /**
-     * 生成高斯核
-     */
-    static generateGaussianKernel(size, sigma) {
-        const kernel = new Array(size * size);
-        const center = Math.floor(size / 2);
-        let sum = 0;
-        for (let y = 0; y < size; y++) {
-            for (let x = 0; x < size; x++) {
-                const distance = Math.sqrt((x - center) ** 2 + (y - center) ** 2);
-                const value = Math.exp(-(distance ** 2) / (2 * sigma ** 2));
-                kernel[y * size + x] = value;
-                sum += value;
-            }
+            height = image.height;
         }
-        // 归一化
-        for (let i = 0; i < kernel.length; i++) {
-            kernel[i] /= sum;
+        else {
+            width = image.width;
+            height = image.height;
         }
-        return kernel;
-    }
-    /**
-     * 计算梯度强度和方向
-     */
-    static computeGradients(imageData) {
-        const width = imageData.width;
-        const height = imageData.height;
-        const inputData = imageData.data;
-        const gradientMagnitude = new Array(width * height);
-        const gradientDirection = new Array(width * height);
-        // Sobel算子
-        const sobelX = [-1, 0, 1, -2, 0, 2, -1, 0, 1];
-        const sobelY = [-1, -2, -1, 0, 0, 0, 1, 2, 1];
-        for (let y = 1; y < height - 1; y++) {
-            for (let x = 1; x < width - 1; x++) {
-                let gx = 0;
-                let gy = 0;
-                for (let ky = -1; ky <= 1; ky++) {
-                    for (let kx = -1; kx <= 1; kx++) {
-                        const pixelPos = ((y + ky) * width + (x + kx)) * 4;
-                        const pixelVal = inputData[pixelPos];
-                        const kernelIdx = (ky + 1) * 3 + (kx + 1);
-                        gx += pixelVal * sobelX[kernelIdx];
-                        gy += pixelVal * sobelY[kernelIdx];
-                    }
+        // 计算调整后的尺寸
+        let newWidth = width;
+        let newHeight = height;
+        if (keepAspectRatio) {
+            if (width > height) {
+                if (width > maxWidth) {
+                    newHeight = Math.round(height * (maxWidth / width));
+                    newWidth = maxWidth;
                 }
-                const idx = y * width + x;
-                gradientMagnitude[idx] = Math.sqrt(gx * gx + gy * gy);
-                gradientDirection[idx] = Math.atan2(gy, gx);
             }
-        }
-        // 处理边界
-        for (let y = 0; y < height; y++) {
-            for (let x = 0; x < width; x++) {
-                if (y === 0 || y === height - 1 || x === 0 || x === width - 1) {
-                    const idx = y * width + x;
-                    gradientMagnitude[idx] = 0;
-                    gradientDirection[idx] = 0;
+            else {
+                if (height > maxHeight) {
+                    newWidth = Math.round(width * (maxHeight / height));
+                    newHeight = maxHeight;
                 }
             }
         }
-        return { gradientMagnitude, gradientDirection };
+        else {
+            newWidth = Math.min(width, maxWidth);
+            newHeight = Math.min(height, maxHeight);
+        }
+        // 设置canvas尺寸
+        canvas.width = newWidth;
+        canvas.height = newHeight;
+        // 绘制调整后的图像
+        if (image instanceof ImageData) {
+            // 创建临时canvas存储ImageData
+            const tempCanvas = document.createElement('canvas');
+            const tempCtx = tempCanvas.getContext('2d');
+            if (!tempCtx) {
+                throw new Error('无法创建临时Canvas上下文');
+            }
+            tempCanvas.width = image.width;
+            tempCanvas.height = image.height;
+            tempCtx.putImageData(image, 0, 0);
+            // 绘制调整后的图像
+            ctx.drawImage(tempCanvas, 0, 0, width, height, 0, 0, newWidth, newHeight);
+        }
+        else {
+            ctx.drawImage(image, 0, 0, width, height, 0, 0, newWidth, newHeight);
+        }
+        // 返回调整后的ImageData
+        return ctx.getImageData(0, 0, newWidth, newHeight);
     }
     /**
-     * 非极大值抛弃
+     * @deprecated 请使用 EdgeDetector.detectEdges()
      */
-    static nonMaxSuppression(gradientMagnitude, gradientDirection, width, height) {
-        const result = new Array(width * height).fill(0);
-        for (let y = 1; y < height - 1; y++) {
-            for (let x = 1; x < width - 1; x++) {
-                const idx = y * width + x;
-                const magnitude = gradientMagnitude[idx];
-                const direction = gradientDirection[idx];
-                // 将方向转化为角度
-                const degrees = (direction * 180 / Math.PI + 180) % 180;
-                // 获取相邻像素索引
-                let neighbor1Idx, neighbor2Idx;
-                // 将方向量化为四个方向: 0°, 45°, 90°, 135°
-                if ((degrees >= 0 && degrees < 22.5) || (degrees >= 157.5 && degrees <= 180)) {
-                    // 水平方向
-                    neighbor1Idx = idx - 1;
-                    neighbor2Idx = idx + 1;
-                }
-                else if (degrees >= 22.5 && degrees < 67.5) {
-                    // 45度方向
-                    neighbor1Idx = (y - 1) * width + (x + 1);
-                    neighbor2Idx = (y + 1) * width + (x - 1);
-                }
-                else if (degrees >= 67.5 && degrees < 112.5) {
-                    // 垂直方向
-                    neighbor1Idx = (y - 1) * width + x;
-                    neighbor2Idx = (y + 1) * width + x;
-                }
-                else {
-                    // 135度方向
-                    neighbor1Idx = (y - 1) * width + (x - 1);
-                    neighbor2Idx = (y + 1) * width + (x + 1);
-                }
-                // 检查当前像素是否是最大值
-                if (magnitude >= gradientMagnitude[neighbor1Idx] &&
-                    magnitude >= gradientMagnitude[neighbor2Idx]) {
-                    result[idx] = magnitude;
-                }
-            }
-        }
-        return result;
+    static detectEdges(imageData, threshold = 30) {
+        return EdgeDetector.detectEdges(imageData, threshold);
     }
     /**
-     * 双阈值处理
+     * @deprecated 请使用 EdgeDetector.cannyEdgeDetection()
      */
-    static hysteresisThresholding(nonMaxSuppressed, width, height, lowThreshold, highThreshold) {
-        const result = new Array(width * height).fill(false);
-        const visited = new Array(width * height).fill(false);
-        const stack = [];
-        // 标记强边缘点
-        for (let i = 0; i < nonMaxSuppressed.length; i++) {
-            if (nonMaxSuppressed[i] >= highThreshold) {
-                result[i] = true;
-                stack.push(i);
-                visited[i] = true;
-            }
-        }
-        // 使用深度优先搜索连接弱边缘
-        const dx = [-1, 0, 1, -1, 1, -1, 0, 1];
-        const dy = [-1, -1, -1, 0, 0, 1, 1, 1];
-        while (stack.length > 0) {
-            const currentIdx = stack.pop();
-            const currentX = currentIdx % width;
-            const currentY = Math.floor(currentIdx / width);
-            // 检查88个相邻方向
-            for (let i = 0; i < 8; i++) {
-                const newX = currentX + dx[i];
-                const newY = currentY + dy[i];
-                if (newX >= 0 && newX < width && newY >= 0 && newY < height) {
-                    const newIdx = newY * width + newX;
-                    if (!visited[newIdx] && nonMaxSuppressed[newIdx] >= lowThreshold) {
-                        result[newIdx] = true;
-                        stack.push(newIdx);
-                        visited[newIdx] = true;
-                    }
-                }
-            }
-        }
-        return result;
+    static cannyEdgeDetection(imageData, lowThreshold = 20, highThreshold = 50) {
+        return EdgeDetector.cannyEdgeDetection(imageData, lowThreshold, highThreshold);
     }
 }
 
@@ -2581,7 +3004,7 @@ async function processOCRInWorker(input) {
         // 识别图像
         const { data } = await worker.recognize(input.imageBase64);
         // 解析身份证信息
-        const idCardInfo = parseIDCardText(data.text);
+        const idCardInfo = IDCardTextParser.parse(data.text);
         // 释放Worker资源
         await worker.terminate();
         const processingTime = performance.now() - startTime;
@@ -2595,160 +3018,6 @@ async function processOCRInWorker(input) {
         };
     }
 }
-/**
- * 解析身份证文本
- * @param text OCR识别的文本
- * @returns 解析后的身份证信息
- */
-function parseIDCardText(text) {
-    const info = {};
-    // 预处理文本，清除多余空白
-    const processedText = text.replace(/\s+/g, ' ').trim();
-    // 解析身份证号码
-    const idNumberRegex = /(\d{17}[\dX])/;
-    const idNumberWithPrefixRegex = /公民身份号码[\s\:]*(\d{17}[\dX])/;
-    const basicMatch = processedText.match(idNumberRegex);
-    const prefixMatch = processedText.match(idNumberWithPrefixRegex);
-    if (prefixMatch && prefixMatch[1]) {
-        info.idNumber = prefixMatch[1];
-    }
-    else if (basicMatch && basicMatch[1]) {
-        info.idNumber = basicMatch[1];
-    }
-    // 解析姓名
-    const nameWithLabelRegex = /姓名[\s\:]*([一-龥]{2,4})/;
-    const nameMatch = processedText.match(nameWithLabelRegex);
-    if (nameMatch && nameMatch[1]) {
-        info.name = nameMatch[1].trim();
-    }
-    else {
-        // 备用方案：查找短行且内容全是汉字
-        const lines = processedText.split('\n').filter(line => line.trim());
-        for (const line of lines) {
-            if (line.length >= 2 &&
-                line.length <= 5 &&
-                /^[一-龥]+$/.test(line) &&
-                !/性别|民族|住址|公民|签发|有效/.test(line)) {
-                info.name = line.trim();
-                break;
-            }
-        }
-    }
-    // 解析性别和民族
-    const genderAndNationalityRegex = /性别[\s\:]*([男女])[\s ]*民族[\s\:]*([一-龥]+族)/;
-    const genderOnlyRegex = /性别[\s\:]*([男女])/;
-    const nationalityOnlyRegex = /民族[\s\:]*([一-龥]+族)/;
-    const genderNationalityMatch = processedText.match(genderAndNationalityRegex);
-    const genderOnlyMatch = processedText.match(genderOnlyRegex);
-    const nationalityOnlyMatch = processedText.match(nationalityOnlyRegex);
-    if (genderNationalityMatch) {
-        info.gender = genderNationalityMatch[1];
-        info.ethnicity = genderNationalityMatch[2];
-    }
-    else {
-        if (genderOnlyMatch)
-            info.gender = genderOnlyMatch[1];
-        if (nationalityOnlyMatch)
-            info.ethnicity = nationalityOnlyMatch[1];
-    }
-    // 根据内容判断身份证类型
-    if (processedText.includes('出生') || processedText.includes('公民身份号码')) {
-        info.type = IDCardType.FRONT; // 确保类型为枚举值而不是字符串
-    }
-    else if (processedText.includes('签发机关') || processedText.includes('有效期')) {
-        info.type = IDCardType.BACK; // 确保类型为枚举值而不是字符串
-    }
-    // 解析出生日期
-    const birthDateRegex1 = /出生[\s\:]*(\d{4})年(\d{1,2})月(\d{1,2})[日号]/;
-    const birthDateRegex2 = /出生[\s\:]*(\d{4})[-\/\.](\d{1,2})[-\/\.](\d{1,2})/;
-    const birthDateRegex3 = /出生日期[\s\:]*(\d{4})[-\/\.\u5e74](\d{1,2})[-\/\.\u6708](\d{1,2})[日号]?/;
-    const birthDateMatch = processedText.match(birthDateRegex1) ||
-        processedText.match(birthDateRegex2) ||
-        processedText.match(birthDateRegex3);
-    if (!birthDateMatch && info.idNumber && info.idNumber.length === 18) {
-        const year = info.idNumber.substring(6, 10);
-        const month = info.idNumber.substring(10, 12);
-        const day = info.idNumber.substring(12, 14);
-        info.birthDate = `${year}-${month}-${day}`;
-    }
-    else if (birthDateMatch) {
-        const year = birthDateMatch[1];
-        const month = birthDateMatch[2].padStart(2, '0');
-        const day = birthDateMatch[3].padStart(2, '0');
-        info.birthDate = `${year}-${month}-${day}`;
-    }
-    // 解析地址
-    const addressRegex1 = /住址[\s\:]*([\s\S]*?)(?=公民身份|出生|性别|签发)/;
-    const addressRegex2 = /住址[\s\:]*([一-龥a-zA-Z0-9\s\.\-]+)/;
-    const addressMatch = processedText.match(addressRegex1) || processedText.match(addressRegex2);
-    if (addressMatch && addressMatch[1]) {
-        info.address = addressMatch[1]
-            .replace(/\s+/g, '')
-            .replace(/\n/g, '')
-            .trim();
-        if (info.address.length > 70) {
-            info.address = info.address.substring(0, 70);
-        }
-        if (!/[一-龥]/.test(info.address)) {
-            info.address = '';
-        }
-    }
-    // 解析签发机关
-    const authorityRegex1 = /签发机关[\s\:]*([\s\S]*?)(?=有效|公民|出生|\d{8}|$)/;
-    const authorityRegex2 = /签发机关[\s\:]*([一-龥\s]+)/;
-    const authorityMatch = processedText.match(authorityRegex1) ||
-        processedText.match(authorityRegex2);
-    if (authorityMatch && authorityMatch[1]) {
-        info.issueAuthority = authorityMatch[1]
-            .replace(/\s+/g, '')
-            .replace(/\n/g, '')
-            .trim();
-    }
-    // 解析有效期限
-    const validPeriodRegex1 = /有效期限[\s\:]*(\d{4}[-\.\u5e74\s]\d{1,2}[-\.\u6708\s]\d{1,2}[日\s]*)[-\s]*(至|-)[-\s]*(\d{4}[-\.\u5e74\s]\d{1,2}[-\.\u6708\s]\d{1,2}[日]*|[永久长期]*)/;
-    const validPeriodRegex2 = /有效期限[\s\:]*(\d{8})[-\s]*(至|-)[-\s]*(\d{8}|[永久长期]*)/;
-    const validPeriodMatch = processedText.match(validPeriodRegex1) ||
-        processedText.match(validPeriodRegex2);
-    if (validPeriodMatch) {
-        if (validPeriodMatch[1] && validPeriodMatch[3]) {
-            const startDate = formatDateString(validPeriodMatch[1]);
-            const endDate = /\d/.test(validPeriodMatch[3])
-                ? formatDateString(validPeriodMatch[3])
-                : '长期有效';
-            info.validFrom = startDate;
-            info.validTo = endDate;
-            info.validPeriod = `${startDate}-${endDate}`;
-        }
-        else {
-            info.validPeriod = validPeriodMatch[0].replace('有效期限', '').trim();
-        }
-    }
-    return info;
-}
-/**
- * 格式化日期字符串
- * @param dateStr 原始日期字符串
- * @returns 格式化后的日期字符串
- */
-function formatDateString(dateStr) {
-    // 提取年月日
-    const dateMatch = dateStr.match(/(\d{4})[-\.\u5e74\s]*(\d{1,2})[-\.\u6708\s]*(\d{1,2})[日]*/);
-    if (dateMatch) {
-        const year = dateMatch[1];
-        const month = dateMatch[2].padStart(2, '0');
-        const day = dateMatch[3].padStart(2, '0');
-        return `${year}-${month}-${day}`;
-    }
-    // 纯数字格式如 20220101
-    if (/^\d{8}$/.test(dateStr)) {
-        const year = dateStr.substring(0, 4);
-        const month = dateStr.substring(4, 6);
-        const day = dateStr.substring(6, 8);
-        return `${year}-${month}-${day}`;
-    }
-    // 无法格式化，返回原始字符串
-    return dateStr;
-}
 
 /**
  * @file OCR处理器
@@ -2800,7 +3069,7 @@ class OCRProcessor {
     /**
      * 初始化OCR引擎
      *
-     * 加载Tesseract OCR引擎和中文简体语言包，并设置适合身份证识别的参数
+     * 加载Tesseract OCR引擎和中文简体语言包,并设置适合身份证识别的参数
      *
      * @returns {Promise<void>} 初始化完成的Promise
      */
@@ -2822,11 +3091,11 @@ class OCRProcessor {
             await this.worker.loadLanguage("chi_sim");
             await this.worker.initialize("chi_sim");
             await this.worker.setParameters({
-                tessedit_char_whitelist: "0123456789X年月日壹贰叁肆伍陆柒捌玖拾民族汉满回维吾尔藏苗彝壮朝鲜侗瑶白土家哈尼哈萨克傣黎傈僳佤高山拉祜水东乡纳西景颇柯尔克孜达斡尔仫佬羌布朗撒拉毛南仡佬锡伯阿昌普米塔吉克怒乌孜别克俄罗斯鄂温克德昂保安裕固京塔塔尔独龙鄂伦春赫哲门巴珞巴基诺男女住址出生公民身份号码签发机关有效期省市区县乡镇街道号楼单元室ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", // 优化字符白名单，增加常见地址字符，移除部分不常用汉字
+                tessedit_char_whitelist: "0123456789X年月日壹贰叁肆伍陆柒捌玖拾民族汉满回维吾尔藏苗彝壮朝鲜侗瑶白土家哈尼哈萨克傣黎傈僳佤高山拉祜水东乡纳西景颇柯尔克孜达斡尔仫佬羌布朗撒拉毛南仡佬锡伯阿昌普米塔吉克怒乌孜别克俄罗斯鄂温克德昂保安裕固京塔塔尔独龙鄂伦春赫哲门巴珞巴基诺男女住址出生公民身份号码签发机关有效期省市区县乡镇街道号楼单元室ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", // 优化字符白名单,增加常见地址字符,移除部分不常用汉字
             });
-            // 增加一些针对性的参数，提高识别率
+            // 增加一些针对性的参数,提高识别率
             await this.worker.setParameters({
-                tessedit_pageseg_mode: 7, // PSM_SINGLE_LINE，使用数字而不是字符串
+                tessedit_pageseg_mode: 7, // PSM_SINGLE_LINE,使用数字而不是字符串
                 preserve_interword_spaces: "1", // 保留单词间的空格
             });
             this.initialized = true;
@@ -2842,7 +3111,7 @@ class OCRProcessor {
         if (!this.initialized) {
             await this.initialize();
         }
-        // 计算图像指纹，用于缓存查找
+        // 计算图像指纹,用于缓存查找
         if (this.options.enableCache) {
             const fingerprint = calculateImageFingerprint(imageData);
             // 检查缓存中是否有结果
@@ -2859,7 +3128,7 @@ class OCRProcessor {
         const enhancedImage = ImageProcessor.batchProcess(downsampledImage, {
             brightness: this.options.brightness !== undefined ? this.options.brightness : 10, // 调整默认亮度
             contrast: this.options.contrast !== undefined ? this.options.contrast : 20, // 调整默认对比度
-            sharpen: true, // 默认启用锐化，通常对OCR有益
+            sharpen: true, // 默认启用锐化,通常对OCR有益
         });
         // 转换为base64供Tesseract处理
         // 创建一个canvas元素
@@ -2881,11 +3150,11 @@ class OCRProcessor {
                 // 使用Worker线程处理
                 const result = await this.ocrWorker.postMessage({
                     imageBase64: base64Image,
-                    // 不传递函数对象，避免DataCloneError
+                    // 不传递函数对象,避免DataCloneError
                     tessWorkerOptions: {},
                 });
                 idCardInfo = result.idCardInfo;
-                this.options.logger?.(`OCR处理完成，用时: ${result.processingTime.toFixed(2)}ms`);
+                this.options.logger?.(`OCR处理完成,用时: ${result.processingTime.toFixed(2)}ms`);
             }
             else {
                 // 使用主线程处理
@@ -2898,9 +3167,9 @@ class OCRProcessor {
                 }
                 const { data } = (await this.worker.recognize(canvas));
                 // 解析身份证信息
-                idCardInfo = this.parseIDCardText(data.text);
+                idCardInfo = IDCardTextParser.parse(data.text);
                 const processingTime = performance.now() - startTime;
-                this.options.logger?.(`OCR处理完成，用时: ${processingTime.toFixed(2)}ms`);
+                this.options.logger?.(`OCR处理完成,用时: ${processingTime.toFixed(2)}ms`);
             }
             // 缓存结果
             if (this.options.enableCache) {
@@ -2917,7 +3186,7 @@ class OCRProcessor {
                     ? JSON.stringify(error)
                     : String(error);
             this.options.logger?.(`OCR识别错误: ${errorMessage}`);
-            // 返回 null，让调用方知道识别失败
+            // 返回 null,让调用方知道识别失败
             return null;
         }
     }
@@ -2930,198 +3199,6 @@ class OCRProcessor {
      * @param {string} text - OCR识别到的文本
      * @returns {IDCardInfo} 提取到的身份证信息对象
      */
-    /**
-     * 格式化日期字符串为标准格式 (YYYY-MM-DD)
-     * @param dateStr 原始日期字符串
-     * @returns 格式化后的日期字符串
-     */
-    formatDateString(dateStr) {
-        // 先尝试提取年月日
-        const dateMatch = dateStr.match(/(\d{4})[-\.\u5e74\s]*(\d{1,2})[-\.\u6708\s]*(\d{1,2})[日]*/);
-        if (dateMatch) {
-            const year = dateMatch[1];
-            const month = dateMatch[2].padStart(2, "0");
-            const day = dateMatch[3].padStart(2, "0");
-            return `${year}-${month}-${day}`;
-        }
-        // 如果是纯数字格式如 20220101
-        if (/^\d{8}$/.test(dateStr)) {
-            const year = dateStr.substring(0, 4);
-            const month = dateStr.substring(4, 6);
-            const day = dateStr.substring(6, 8);
-            return `${year}-${month}-${day}`;
-        }
-        // 如果无法格式化，返回原始字符串
-        return dateStr;
-    }
-    /**
-     * 验证身份证号是否符合规则
-     * @param idNumber 身份证号
-     * @returns 是否有效
-     */
-    validateIDNumber(idNumber) {
-        // 基本验证，校验位有效性和长度
-        if (!idNumber || idNumber.length !== 18) {
-            return false;
-        }
-        // 检查格式，前17位必须为数字，最后一位可以是数字或'X'
-        const pattern = /^\d{17}[\dX]$/;
-        if (!pattern.test(idNumber)) {
-            return false;
-        }
-        // 检查日期部分
-        parseInt(idNumber.substr(6, 4));
-        const month = parseInt(idNumber.substr(10, 2));
-        const day = parseInt(idNumber.substr(12, 2));
-        if (month < 1 || month > 12 || day < 1 || day > 31) {
-            return false;
-        }
-        // 更详细的检查可以添加校验位的验证等逻辑...
-        return true;
-    }
-    parseIDCardText(text) {
-        const info = {};
-        // 预处理文本，清除多余空白
-        const processedText = text.replace(/\s+/g, " ").trim();
-        // 拆分为行，并过滤空行
-        const lines = processedText.split("\n").filter((line) => line.trim());
-        // 解析身份证号码 - 多种模式匹配
-        // 1. 普通18位身份证号模式
-        const idNumberRegex = /(\d{17}[\dX])/;
-        // 2. 带前缀的模式
-        const idNumberWithPrefixRegex = /公民身份号码[\s\:]*(\d{17}[\dX])/;
-        // 尝试所有模式
-        let idNumber = null;
-        const basicMatch = processedText.match(idNumberRegex);
-        const prefixMatch = processedText.match(idNumberWithPrefixRegex);
-        if (prefixMatch && prefixMatch[1]) {
-            idNumber = prefixMatch[1]; // 首选带前缀的匹配，因为最可靠
-        }
-        else if (basicMatch && basicMatch[1]) {
-            idNumber = basicMatch[1]; // 其次是常规匹配
-        }
-        if (idNumber) {
-            info.idNumber = idNumber;
-        }
-        // 解析姓名 - 使用多种策略
-        // 1. 直接匹配姓名标签近的内容
-        const nameWithLabelRegex = /姓名[\s\:]*([一-龥]{2,4})/;
-        const nameMatch = processedText.match(nameWithLabelRegex);
-        // 2. 分析行文本寻找姓名
-        if (nameMatch && nameMatch[1]) {
-            info.name = nameMatch[1].trim();
-        }
-        else {
-            // 备用方案：查找短行且内容全是汉字
-            for (const line of lines) {
-                if (line.length >= 2 &&
-                    line.length <= 5 &&
-                    /^[一-龥]+$/.test(line) &&
-                    !/性别|民族|住址|公民|签发|有效/.test(line)) {
-                    info.name = line.trim();
-                    break;
-                }
-            }
-        }
-        // 解析性别和民族 - 多种模式匹配
-        // 1. 标准格式匹配
-        const genderAndNationalityRegex = /性别[\s\:]*([男女])[\s ]*民族[\s\:]*([一-龥]+族)/;
-        const genderNationalityMatch = processedText.match(genderAndNationalityRegex);
-        // 2. 只匹配性别
-        const genderOnlyRegex = /性别[\s\:]*([男女])/;
-        const genderOnlyMatch = processedText.match(genderOnlyRegex);
-        // 3. 只匹配民族
-        const nationalityOnlyRegex = /民族[\s\:]*([一-龥]+族)/;
-        const nationalityOnlyMatch = processedText.match(nationalityOnlyRegex);
-        if (genderNationalityMatch) {
-            info.gender = genderNationalityMatch[1];
-            info.nationality = genderNationalityMatch[2];
-        }
-        else {
-            // 分开获取
-            if (genderOnlyMatch)
-                info.gender = genderOnlyMatch[1];
-            if (nationalityOnlyMatch)
-                info.nationality = nationalityOnlyMatch[1];
-        }
-        // 解析出生日期 - 支持多种格式
-        // 1. 标准格式：YYYY年MM月DD日
-        const birthDateRegex1 = /出生[\s\:]*(\d{4})年(\d{1,2})月(\d{1,2})[日号]/;
-        // 2. 美式日期格式：YYYY-MM-DD或YYYY/MM/DD
-        const birthDateRegex2 = /出生[\s\:]*(\d{4})[-\/\.](\d{1,2})[-\/\.](\d{1,2})/;
-        // 3. 带前缀的格式
-        const birthDateRegex3 = /出生日期[\s\:]*(\d{4})[-\/\.\u5e74](\d{1,2})[-\/\.\u6708](\d{1,2})[日号]?/;
-        let birthDateMatch = processedText.match(birthDateRegex1) ||
-            processedText.match(birthDateRegex2) ||
-            processedText.match(birthDateRegex3);
-        // 4. 从身份证号码中提取出生日期（如果上述方法失败）
-        if (!birthDateMatch && info.idNumber && info.idNumber.length === 18) {
-            const year = info.idNumber.substring(6, 10);
-            const month = info.idNumber.substring(10, 12);
-            const day = info.idNumber.substring(12, 14);
-            info.birthDate = `${year}-${month}-${day}`;
-        }
-        else if (birthDateMatch) {
-            // 确保月份和日期是两位数
-            const year = birthDateMatch[1];
-            const month = birthDateMatch[2].padStart(2, "0");
-            const day = birthDateMatch[3].padStart(2, "0");
-            info.birthDate = `${year}-${month}-${day}`;
-        }
-        // 解析地址 - 改进的正则匹配
-        // 1. 常规模式
-        const addressRegex1 = /住址[\s\:]*([\s\S]*?)(?=公民身份|出生|性别|签发)/;
-        // 2. 更宽松的模式
-        const addressRegex2 = /住址[\s\:]*([一-龥a-zA-Z0-9\s\.\-]+)/;
-        const addressMatch = processedText.match(addressRegex1) || processedText.match(addressRegex2);
-        if (addressMatch && addressMatch[1]) {
-            // 清理地址中的常见错误和多余空格
-            info.address = addressMatch[1]
-                .replace(/\s+/g, "")
-                .replace(/\n/g, "")
-                .trim();
-            // 限制地址长度并判断地址合理性
-            if (info.address.length > 70) {
-                info.address = info.address.substring(0, 70);
-            }
-            // 确保地址是合理的（不仅仅包含符号或数字）
-            if (!/[一-龥]/.test(info.address)) {
-                info.address = ""; // 如果没有中文字符，可能不是有效地址
-            }
-        }
-        // 解析签发机关
-        const authorityRegex1 = /签发机关[\s\:]*([\s\S]*?)(?=有效|公民|出生|\d{8}|$)/;
-        const authorityRegex2 = /签发机关[\s\:]*([一-龥\s]+)/;
-        const authorityMatch = processedText.match(authorityRegex1) ||
-            processedText.match(authorityRegex2);
-        if (authorityMatch && authorityMatch[1]) {
-            info.issuingAuthority = authorityMatch[1]
-                .replace(/\s+/g, "")
-                .replace(/\n/g, "")
-                .trim();
-        }
-        // 解析有效期限 - 支持多种格式
-        // 1. 常规格式：YYYY.MM.DD-YYYY.MM.DD
-        const validPeriodRegex1 = /有效期限[\s\:]*(\d{4}[-\.\u5e74\s]\d{1,2}[-\.\u6708\s]\d{1,2}[日\s]*)[-\s]*(至|-)[-\s]*(\d{4}[-\.\u5e74\s]\d{1,2}[-\.\u6708\s]\d{1,2}[日]*|[永久长期]*)/;
-        // 2. 简化格式：YYYYMMDD-YYYYMMDD
-        const validPeriodRegex2 = /有效期限[\s\:]*(\d{8})[-\s]*(至|-)[-\s]*(\d{8}|[永久长期]*)/;
-        const validPeriodMatch = processedText.match(validPeriodRegex1) ||
-            processedText.match(validPeriodRegex2);
-        if (validPeriodMatch) {
-            // 格式化为统一的有效期限形式
-            if (validPeriodMatch[1] && validPeriodMatch[3]) {
-                const startDate = this.formatDateString(validPeriodMatch[1]);
-                const endDate = /\d/.test(validPeriodMatch[3])
-                    ? this.formatDateString(validPeriodMatch[3])
-                    : "长期有效";
-                info.validPeriod = `${startDate}-${endDate}`;
-            }
-            else {
-                info.validPeriod = validPeriodMatch[0].replace("有效期限", "").trim();
-            }
-        }
-        return info;
-    }
     /**
      * 清除结果缓存
      */