id-scanner-lib 1.6.7 → 2.0.0

package/dist/id-scanner-lib.js

@@ -5,251 +5,95 @@
 })(this, (function (exports, tesseract_js, imageCompression, jsQR) { 'use strict';
 
   /**
-   * @file 配置管理器
-   * @description 提供全局配置管理功能
+   * @file 配置管理器 + Scanner 配置
+   * @description 提供全局配置管理功能 + Scanner v2.0 配置接口
    * @module core/config
    */
-  /**
-   * 配置管理器
-   * 负责存储和管理应用程序的配置
-   */
+  // ============================================================
+  // 原有 ConfigManager（保持向后兼容）
+  // ============================================================
   class ConfigManager {
-      /**
-       * 私有构造函数
-       */
       constructor() {
-          /** 配置存储 */
           this.config = {};
-          /** 配置变更回调 */
           this.changeCallbacks = new Map();
-          /** 初始化状态 */
           this.initialized = false;
-          // 设置默认配置
           this._resetDefaults();
       }
-      /**
-       * 获取单例实例
-       */
       static getInstance() {
           if (!ConfigManager.instance) {
               ConfigManager.instance = new ConfigManager();
           }
           return ConfigManager.instance;
       }
-      /**
-       * 重置单例实例（主要用于测试）
-       */
       static resetInstance() {
           ConfigManager.instance = undefined;
       }
-      /**
-       * 重置为默认配置
-       */
       _resetDefaults() {
           this.config = {
               debug: false,
               logLevel: 'info',
-              camera: {
-                  resolution: {
-                      width: 1280,
-                      height: 720
-                  },
-                  frameRate: 30,
-                  facingMode: 'environment'
+              modelPath: '/models',
+              maxRetries: 3,
+              retryDelay: 1000,
+              detectionInterval: 100,
+              face: {
+                  enabled: true,
+                  confidenceThreshold: 0.5,
+                  maxFaces: 10,
+              },
+              idCard: {
+                  enabled: false,
+              },
+              qr: {
+                  enabled: false,
               },
-              performance: {
-                  useCache: true
-              }
           };
           this.initialized = true;
       }
-      /**
-       * 获取配置值
-       * @param key 配置键，支持点号分隔的路径
-       * @param defaultValue 默认值
-       */
       get(key, defaultValue) {
-          const value = this.getNestedValue(this.config, key);
-          return (value !== undefined) ? value : defaultValue;
+          const keys = key.split('.');
+          let value = this.config;
+          for (const k of keys) {
+              value = value?.[k];
+          }
+          return (value !== undefined ? value : defaultValue);
       }
-      /**
-       * 设置配置值
-       * @param key 配置键，支持点号分隔的路径
-       * @param value 配置值
-       */
       set(key, value) {
-          const oldValue = this.get(key);
-          // 如果值相同，不做任何事
-          if (oldValue === value) {
-              return;
+          const keys = key.split('.');
+          let target = this.config;
+          for (let i = 0; i < keys.length - 1; i++) {
+              if (!target[keys[i]])
+                  target[keys[i]] = {};
+              target = target[keys[i]];
+          }
+          const oldValue = target[keys[keys.length - 1]];
+          target[keys[keys.length - 1]] = value;
+          const callbacks = this.changeCallbacks.get(key);
+          if (callbacks) {
+              callbacks.forEach(cb => cb(value, oldValue));
           }
-          this.setNestedValue(this.config, key, value);
-          // 触发变更回调
-          this.triggerChangeCallbacks(key, value, oldValue);
-      }
-      /**
-       * 批量更新配置
-       * @param config 配置对象
-       */
-      updateConfig(config) {
-          Object.entries(config).forEach(([key, value]) => {
-              this.set(key, value);
-          });
-      }
-      /**
-       * 重置为默认配置
-       */
-      reset() {
-          const oldConfig = { ...this.config };
-          // 使用私有 reset 方法重建默认配置
-          this.config = {
-              debug: false,
-              logLevel: 'info',
-              camera: {
-                  resolution: {
-                      width: 1280,
-                      height: 720
-                  },
-                  frameRate: 30,
-                  facingMode: 'environment'
-              },
-              performance: {
-                  useCache: true
-              }
-          };
-          // 触发所有回调
-          Object.keys(oldConfig).forEach(key => {
-              this.triggerChangeCallbacks(key, this.get(key), oldConfig[key]);
-          });
       }
-      /**
-       * 注册配置变更回调
-       * @param key 配置键
-       * @param callback 回调函数
-       */
-      onConfigChange(key, callback) {
+      onChange(key, callback) {
           if (!this.changeCallbacks.has(key)) {
               this.changeCallbacks.set(key, []);
           }
           this.changeCallbacks.get(key).push(callback);
       }
-      /**
-       * 移除配置变更回调
-       * @param key 配置键
-       * @param callback 特定回调函数，如不提供则移除所有
-       */
-      offConfigChange(key, callback) {
-          if (!this.changeCallbacks.has(key)) {
-              return;
-          }
-          if (callback) {
-              // 移除特定回调
-              const callbacks = this.changeCallbacks.get(key);
+      /** @deprecated Use onChange instead */
+      onConfigChange(key, callback) {
+          this.onChange(key, callback);
+      }
+      removeChangeCallback(key, callback) {
+          const callbacks = this.changeCallbacks.get(key);
+          if (callbacks) {
               const index = callbacks.indexOf(callback);
-              if (index !== -1) {
+              if (index > -1)
                   callbacks.splice(index, 1);
-              }
-              // 如果没有回调，删除键
-              if (callbacks.length === 0) {
-                  this.changeCallbacks.delete(key);
-              }
-          }
-          else {
-              // 移除所有回调
-              this.changeCallbacks.delete(key);
-          }
-      }
-      /**
-       * 获取嵌套值
-       * @param obj 对象
-       * @param path 路径
-       */
-      getNestedValue(obj, path) {
-          // 处理根路径
-          if (!path) {
-              return obj;
-          }
-          // 处理嵌套路径
-          const parts = path.split('.');
-          let current = obj;
-          for (const part of parts) {
-              if (current === undefined || current === null) {
-                  return undefined;
-              }
-              current = current[part];
-          }
-          return current;
-      }
-      /**
-       * 设置嵌套值
-       * @param obj 对象
-       * @param path 路径
-       * @param value 值
-       */
-      setNestedValue(obj, path, value) {
-          // 处理根路径
-          if (!path) {
-              return;
-          }
-          // 处理嵌套路径
-          const parts = path.split('.');
-          let current = obj;
-          // 遍历路径，直到倒数第二部分
-          for (let i = 0; i < parts.length - 1; i++) {
-              const part = parts[i];
-              // 如果不存在，创建新对象
-              if (current[part] === undefined || current[part] === null || typeof current[part] !== 'object') {
-                  current[part] = {};
-              }
-              current = current[part];
-          }
-          // 设置最终值
-          current[parts[parts.length - 1]] = value;
-      }
-      /**
-       * 触发变更回调
-       * @param key 配置键
-       * @param value 新值
-       * @param oldValue 旧值
-       */
-      triggerChangeCallbacks(key, value, oldValue) {
-          // 触发特定键的回调
-          if (this.changeCallbacks.has(key)) {
-              const callbacks = this.changeCallbacks.get(key);
-              callbacks.forEach(callback => {
-                  try {
-                      callback(value, oldValue);
-                  }
-                  catch (error) {
-                      console.error(`Error in config change callback for key ${key}:`, error);
-                  }
-              });
-          }
-          // 触发父路径的回调
-          const parts = key.split('.');
-          while (parts.length > 1) {
-              parts.pop();
-              const parentKey = parts.join('.');
-              if (this.changeCallbacks.has(parentKey)) {
-                  const parentValue = this.get(parentKey);
-                  this.changeCallbacks.get(parentKey).forEach(callback => {
-                      try {
-                          callback(parentValue, parentValue);
-                      }
-                      catch (error) {
-                          console.error(`Error in config change callback for parent key ${parentKey}:`, error);
-                      }
-                  });
-              }
           }
       }
-      /**
-       * 检查模块是否启用
-       * @param moduleName 模块名称
-       */
-      isModuleEnabled(moduleName) {
-          const key = `modules.${moduleName}.enabled`;
-          return this.get(key) ?? false;
+      reset() {
+          this.config = {};
+          this._resetDefaults();
       }
   }
 
@@ -284,18 +128,20 @@
       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 exports.LoggerLevel.DEBUG:
-                  console.debug(prefix, entry.message, entry.error || '');
+                  console.debug(prefix, entry.message, extra);
                   break;
               case exports.LoggerLevel.INFO:
-                  console.info(prefix, entry.message, entry.error || '');
+                  console.info(prefix, entry.message, extra);
                   break;
               case exports.LoggerLevel.WARN:
-                  console.warn(prefix, entry.message, entry.error || '');
+                  console.warn(prefix, entry.message, extra);
                   break;
               case exports.LoggerLevel.ERROR:
-                  console.error(prefix, entry.message, entry.error || '');
+                  console.error(prefix, entry.message, extra);
                   break;
               // 输出什么也不做
           }
@@ -369,10 +215,13 @@
           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();
           // 页面卸载前尝试发送剩余日志
@@ -402,47 +251,55 @@
       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];
+              }
+          });
       }
       /**
        * 开始定时发送
@@ -452,7 +309,7 @@
               return;
           if (this.timerId !== null)
               return;
-          this.timerId = window.setInterval(() => {
+          this.timerId = setInterval(() => {
               this.flush();
           }, this.flushInterval);
       }
@@ -461,7 +318,7 @@
        */
       stopTimer() {
           if (this.timerId !== null) {
-              window.clearInterval(this.timerId);
+              clearInterval(this.timerId);
               this.timerId = null;
           }
       }
@@ -538,37 +395,57 @@
        * 记录调试级别日志
        * @param tag 标签
        * @param message 消息
-       * @param error 错误
+       * @param errorOrData 错误对象或结构化数据
        */
-      debug(tag, message, error) {
-          this.log(exports.LoggerLevel.DEBUG, tag, message, error);
+      debug(tag, message, errorOrData) {
+          if (errorOrData instanceof Error) {
+              this.log(exports.LoggerLevel.DEBUG, tag, message, errorOrData);
+          }
+          else {
+              this.logWithData(exports.LoggerLevel.DEBUG, tag, message, errorOrData);
+          }
       }
       /**
        * 记录信息级别日志
        * @param tag 标签
        * @param message 消息
-       * @param error 错误
+       * @param errorOrData 错误对象或结构化数据
        */
-      info(tag, message, error) {
-          this.log(exports.LoggerLevel.INFO, tag, message, error);
+      info(tag, message, errorOrData) {
+          if (errorOrData instanceof Error) {
+              this.log(exports.LoggerLevel.INFO, tag, message, errorOrData);
+          }
+          else {
+              this.logWithData(exports.LoggerLevel.INFO, tag, message, errorOrData);
+          }
       }
       /**
        * 记录警告级别日志
        * @param tag 标签
        * @param message 消息
-       * @param error 错误
+       * @param errorOrData 错误对象或结构化数据
        */
-      warn(tag, message, error) {
-          this.log(exports.LoggerLevel.WARN, tag, message, error);
+      warn(tag, message, errorOrData) {
+          if (errorOrData instanceof Error) {
+              this.log(exports.LoggerLevel.WARN, tag, message, errorOrData);
+          }
+          else {
+              this.logWithData(exports.LoggerLevel.WARN, tag, message, errorOrData);
+          }
       }
       /**
        * 记录错误级别日志
        * @param tag 标签
        * @param message 消息
-       * @param error 错误
+       * @param errorOrData 错误对象或结构化数据
        */
-      error(tag, message, error) {
-          this.log(exports.LoggerLevel.ERROR, tag, message, error);
+      error(tag, message, errorOrData) {
+          if (errorOrData instanceof Error) {
+              this.log(exports.LoggerLevel.ERROR, tag, message, errorOrData);
+          }
+          else {
+              this.logWithData(exports.LoggerLevel.ERROR, tag, message, errorOrData);
+          }
       }
       /**
        * 创建标记了特定标签的日志记录器
@@ -613,6 +490,42 @@
               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 日志条目
@@ -620,18 +533,20 @@
       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 exports.LoggerLevel.DEBUG:
-                  console.debug(`${prefix} ${entry.message}`, entry.error || '');
+                  console.debug(`${prefix} ${entry.message}`, extra);
                   break;
               case exports.LoggerLevel.INFO:
-                  console.info(`${prefix} ${entry.message}`, entry.error || '');
+                  console.info(`${prefix} ${entry.message}`, extra);
                   break;
               case exports.LoggerLevel.WARN:
-                  console.warn(`${prefix} ${entry.message}`, entry.error || '');
+                  console.warn(`${prefix} ${entry.message}`, extra);
                   break;
               case exports.LoggerLevel.ERROR:
-                  console.error(`${prefix} ${entry.message}`, entry.error || '');
+                  console.error(`${prefix} ${entry.message}`, extra);
                   break;
           }
       }
@@ -1598,93 +1513,685 @@
   }
 
   /**
-   * @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 ImageProcessor {
+  class IDCardTextParser {
       /**
-       * 将ImageData转换为Canvas元素
-       *
-       * @param {ImageData} imageData - 要转换的图像数据
-       * @returns {HTMLCanvasElement} 包含图像的Canvas元素
+       * 解析身份证文本
+       * @param text OCR识别的原始文本
+       * @returns 解析后的身份证信息
        */
-      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 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];
           }
-          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 通道保持不变
+          else if (basicMatch && basicMatch[1]) {
+              info.idNumber = basicMatch[1];
           }
-          return imageData;
-      }
-      /**
-       * 将图像转换为灰度图
-       *
-       * @param imageData 原始图像数据
-       * @returns 灰度图像数据
-       */
-      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;
+          // 2. 解析姓名
+          const nameWithLabelRegex = /姓名[\s\:]*([一-龥]{2,4})/;
+          const nameMatch = processedText.match(nameWithLabelRegex);
+          if (nameMatch && nameMatch[1]) {
+              info.name = nameMatch[1].trim();
           }
-          return imageData;
-      }
-      /**
-       * 锐化图像
-       *
-       * @param imageData 原始图像数据
-       * @param amount 锐化程度，默认为2
-       * @returns 锐化后的图像数据
+          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 = exports.IDCardType.FRONT;
+          }
+          else if (processedText.includes('签发机关') || processedText.includes('有效期')) {
+              info.type = exports.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 CanvasPool {
+      /**
+       * 获取单例实例
+       */
+      static getInstance() {
+          if (!CanvasPool.instance) {
+              CanvasPool.instance = new CanvasPool();
+          }
+          return CanvasPool.instance;
+      }
+      /**
+       * 重置单例实例（主要用于测试）
+       */
+      static resetInstance() {
+          if (CanvasPool.instance) {
+              CanvasPool.instance.dispose();
+              CanvasPool.instance = null;
+          }
+      }
+      /**
+       * 私有构造函数
+       */
+      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;
+                  }
+              }
+          }
+          return null;
+      }
+      /**
+       * 从池中获取 Canvas
+       *
+       * @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
+       */
+      release(canvas) {
+          const item = this.borrowed.get(canvas);
+          if (!item) {
+              // 不属于我们管理的 Canvas，忽略
+              return;
+          }
+          item.inUse = false;
+          item.lastUsed = Date.now();
+          this.borrowed.delete(canvas);
+      }
+      /**
+       * 批量释放所有借出的 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)
@@ -1755,35 +2262,48 @@
           return new ImageData(outputData, width, height);
       }
       /**
-       * 对图像应用阈值操作，增强对比度
+       * 对图像应用阈值操作，增强对比度（二值化）
        *
        * @param imageData 原始图像数据
        * @param threshold 阈值 (0-255)
-       * @returns 处理后的图像数据
+       * @returns 处理后的图像数据（新对象，不修改原图）
        */
       static threshold(imageData, threshold = 128) {
-          // 先转换为灰度图（toGrayscale 内部已创建新 ImageData，无需外部拷贝）
+          // 先转换为灰度图（返回新 ImageData，不修改原图）
           const grayscaleImage = this.toGrayscale(imageData);
-          const data = grayscaleImage.data;
-          for (let i = 0; i < data.length; i += 4) {
+          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) {
-          // 先转换为灰度图（toGrayscale 内部已创建新 ImageData，无需外部拷贝）
+          // 先转换为灰度图（返回新 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算法计算最佳阈值
@@ -1901,24 +2421,20 @@
                   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);
                       }
                   };
@@ -1945,16 +2461,12 @@
       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;
@@ -2003,312 +2515,52 @@
                       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;
-              }
-          }
-          // 归一化
-          for (let i = 0; i < kernel.length; i++) {
-              kernel[i] /= sum;
-          }
-          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];
-                      }
+              }
+              else {
+                  if (height > maxHeight) {
+                      newWidth = Math.round(width * (maxHeight / height));
+                      newHeight = maxHeight;
                   }
-                  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 {
+              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);
           }
-          return { gradientMagnitude, gradientDirection };
+          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);
       }
   }
 
@@ -2598,7 +2850,7 @@
           // 识别图像
           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;
@@ -2612,160 +2864,6 @@
           };
       }
   }
-  /**
-   * 解析身份证文本
-   * @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 = exports.IDCardType.FRONT; // 确保类型为枚举值而不是字符串
-      }
-      else if (processedText.includes('签发机关') || processedText.includes('有效期')) {
-          info.type = exports.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处理器
@@ -2817,7 +2915,7 @@
       /**
        * 初始化OCR引擎
        *
-       * 加载Tesseract OCR引擎和中文简体语言包，并设置适合身份证识别的参数
+       * 加载Tesseract OCR引擎和中文简体语言包,并设置适合身份证识别的参数
        *
        * @returns {Promise<void>} 初始化完成的Promise
        */
@@ -2839,11 +2937,11 @@
               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;
@@ -2859,7 +2957,7 @@
           if (!this.initialized) {
               await this.initialize();
           }
-          // 计算图像指纹，用于缓存查找
+          // 计算图像指纹,用于缓存查找
           if (this.options.enableCache) {
               const fingerprint = calculateImageFingerprint(imageData);
               // 检查缓存中是否有结果
@@ -2876,7 +2974,7 @@
           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元素
@@ -2898,11 +2996,11 @@
                   // 使用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 {
                   // 使用主线程处理
@@ -2915,9 +3013,9 @@
                   }
                   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) {
@@ -2934,7 +3032,7 @@
                       ? JSON.stringify(error)
                       : String(error);
               this.options.logger?.(`OCR识别错误: ${errorMessage}`);
-              // 返回 null，让调用方知道识别失败
+              // 返回 null,让调用方知道识别失败
               return null;
           }
       }
@@ -2947,198 +3045,6 @@
        * @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;
-      }
       /**
        * 清除结果缓存
        */
@@ -4714,157 +4620,106 @@
   }
 
   /**
-   * @file 错误处理模块
-   * @description 定义ID-Scanner-Lib的错误类层次结构
+   * @file Scanner Errors
+   * @description Error classes for Scanner
    * @module core/errors
    */
   /**
-   * ID-Scanner-Lib 基础错误类
-   * 所有库特定错误的基类
+   * Scanner specific error
    */
-  class IDScannerError extends Error {
+  class ScannerError extends Error {
       /**
-       * 构造函数
-       * @param message 错误消息
-       * @param options 错误选项
+       * Create a ScannerError
+       * @param message Error message
+       * @param code Error code
+       * @param module Module name
        */
-      constructor(message, options) {
+      constructor(message, code, module) {
           super(message);
-          // 设置错误名称
-          this.name = this.constructor.name;
-          // 设置错误代码
-          this.code = options?.code || 'UNKNOWN_ERROR';
-          // 设置错误原因
-          this.cause = options?.cause;
-          // 捕获堆栈 (Node.js专有，浏览器环境忽略)
-          if (typeof Error.captureStackTrace === 'function') {
-              Error.captureStackTrace(this, this.constructor);
-          }
+          this.name = 'ScannerError';
+          this.code = code;
+          this.module = module;
       }
   }
   /**
-   * 初始化错误
-   * 当库初始化失败时抛出
+   * Camera access error
    */
-  class InitializationError extends IDScannerError {
-      constructor(message, details) {
-          super(`初始化失败: ${message}${details ? ` (${details})` : ''}`, { code: 'INIT_FAILED' });
-          this.name = 'InitializationError';
+  class CameraAccessError extends Error {
+      constructor(message = 'Camera access denied') {
+          super(message);
+          this.name = 'CameraAccessError';
       }
   }
   /**
-   * 设备错误
-   * 当访问硬件设备(如摄像头)失败时抛出
+   * Device error
    */
-  class DeviceError extends IDScannerError {
-      constructor(message) {
-          super(`设备错误: ${message}`, { code: 'DEVICE_ERROR' });
+  class DeviceError extends Error {
+      constructor(message = 'Device error') {
+          super(message);
           this.name = 'DeviceError';
       }
   }
   /**
-   * 摄像头访问错误
-   * 当无法访问或启动摄像头时抛出
+   * Resource load error
    */
-  class CameraAccessError extends IDScannerError {
-      constructor(message, options) {
-          super(`摄像头访问失败: ${message}`, {
-              code: options?.code || 'CAMERA_ACCESS_FAILED',
-              cause: options?.cause
-          });
-          this.name = 'CameraAccessError';
+  class ResourceLoadError extends Error {
+      constructor(message = 'Failed to load resource', id) {
+          super(message);
+          this.name = 'ResourceLoadError';
+          this.id = id;
       }
   }
   /**
-   * 人脸检测错误
-   * 当人脸检测过程失败时抛出
+   * Face detection error
    */
-  class FaceDetectionError extends IDScannerError {
-      constructor(message) {
-          super(`人脸检测失败: ${message}`, { code: 'FACE_DETECTION_FAILED' });
+  class FaceDetectionError extends Error {
+      constructor(message = 'Face detection failed') {
+          super(message);
           this.name = 'FaceDetectionError';
       }
   }
   /**
-   * 人脸比对错误
-   * 当人脸比对过程失败时抛出
+   * Face comparison error
    */
-  class FaceComparisonError extends IDScannerError {
-      constructor(message) {
-          super(`人脸比对失败: ${message}`, { code: 'FACE_COMPARISON_FAILED' });
+  class FaceComparisonError extends Error {
+      constructor(message = 'Face comparison failed') {
+          super(message);
           this.name = 'FaceComparisonError';
       }
   }
   /**
-   * 活体检测错误
-   * 当活体检测过程失败时抛出
-   */
-  class LivenessDetectionError extends IDScannerError {
-      constructor(message) {
-          super(`活体检测失败: ${message}`, { code: 'LIVENESS_DETECTION_FAILED' });
-          this.name = 'LivenessDetectionError';
-      }
-  }
-  /**
-   * OCR识别错误
-   * 当OCR文字识别失败时抛出
-   */
-  class OCRProcessingError extends IDScannerError {
-      constructor(message) {
-          super(`OCR处理失败: ${message}`, { code: 'OCR_PROCESSING_FAILED' });
-          this.name = 'OCRProcessingError';
-      }
-  }
-  /**
-   * 二维码扫描错误
-   * 当二维码扫描失败时抛出
-   */
-  class QRScanError extends IDScannerError {
-      constructor(message) {
-          super(`二维码扫描失败: ${message}`, { code: 'QR_SCAN_FAILED' });
-          this.name = 'QRScanError';
-      }
-  }
-  /**
-   * 身份证检测错误
-   * 当身份证检测失败时抛出
-   */
-  class IDCardDetectionError extends IDScannerError {
-      constructor(message) {
-          super(`身份证检测失败: ${message}`, { code: 'ID_CARD_DETECTION_FAILED' });
-          this.name = 'IDCardDetectionError';
-      }
-  }
-  /**
-   * 资源加载错误
-   * 当无法加载必要资源(如模型)时抛出
+   * Initialization error
    */
-  class ResourceLoadError extends IDScannerError {
-      constructor(resource, reason) {
-          super(`无法加载资源 ${resource}: ${reason}`, { code: 'RESOURCE_LOAD_FAILED' });
-          this.name = 'ResourceLoadError';
+  class InitializationError extends Error {
+      constructor(message = 'Initialization failed') {
+          super(message);
+          this.name = 'InitializationError';
       }
   }
   /**
-   * 参数错误
-   * 当提供的参数无效时抛出
+   * Liveness detection error
    */
-  class InvalidArgumentError extends IDScannerError {
-      constructor(paramName, reason) {
-          super(`无效的参数 ${paramName}: ${reason}`, { code: 'INVALID_ARGUMENT' });
-          this.name = 'InvalidArgumentError';
+  class LivenessDetectionError extends Error {
+      constructor(message = 'Liveness detection failed') {
+          super(message);
+          this.name = 'LivenessDetectionError';
       }
   }
   /**
-   * 不支持错误
-   * 当尝试使用不支持的功能或当前环境无法使用的功能时抛出
+   * Error codes for Scanner
    */
-  class NotSupportedError extends IDScannerError {
-      constructor(feature) {
-          super(`不支持的功能: ${feature}`, { code: 'NOT_SUPPORTED' });
-          this.name = 'NotSupportedError';
-      }
-  }
+  const ErrorCodes = {
+      /** Scanner not initialized */
+      NOT_INITIALIZED: 'SCANNER_001',
+      /** Module not found */
+      MODULE_NOT_FOUND: 'SCANNER_002',
+      /** Detection failed */
+      DETECTION_FAILED: 'SCANNER_003',
+      /** Camera access denied */
+      CAMERA_ACCESS_DENIED: 'CAMERA_001',
+      /** Camera not available */
+      CAMERA_NOT_AVAILABLE: 'CAMERA_002',
+  };
 
   /* eslint-disable */
   /**
@@ -4969,27 +4824,23 @@
   exports.ConsoleLogHandler = ConsoleLogHandler;
   exports.DEFAULT_FORMATS = DEFAULT_FORMATS;
   exports.DeviceError = DeviceError;
+  exports.ErrorCodes = ErrorCodes;
   exports.FaceComparisonError = FaceComparisonError;
   exports.FaceDetectionError = FaceDetectionError;
   exports.FaceModule = FaceModule;
-  exports.IDCardDetectionError = IDCardDetectionError;
   exports.IDCardModule = IDCardModule;
   exports.IDScanner = IDScanner;
-  exports.IDScannerError = IDScannerError;
   exports.InitializationError = InitializationError;
-  exports.InvalidArgumentError = InvalidArgumentError;
   exports.LivenessDetectionError = LivenessDetectionError;
   exports.LoadingStateManager = LoadingStateManager;
   exports.LogLevel = LogLevel;
   exports.Logger = Logger;
   exports.MemoryLogHandler = MemoryLogHandler;
   exports.ModuleManager = ModuleManager;
-  exports.NotSupportedError = NotSupportedError;
-  exports.OCRProcessingError = OCRProcessingError;
   exports.QRCodeModule = QRCodeModule;
-  exports.QRScanError = QRScanError;
   exports.RemoteLogHandler = RemoteLogHandler;
   exports.ResourceLoadError = ResourceLoadError;
+  exports.ScannerError = ScannerError;
   exports.TaggedLogger = TaggedLogger;
   exports.createLoadingStateManager = createLoadingStateManager;
   exports.default = IDScanner;