id-scanner-lib 1.3.3 → 1.5.0

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

@@ -0,0 +1,4641 @@
+import { createWorker as createWorker$1 } from 'tesseract.js';
+import imageCompression from 'browser-image-compression';
+import jsQR from 'jsqr';
+
+/**
+ * @file 配置管理器
+ * @description 提供全局配置管理功能
+ * @module core/config
+ */
+/**
+ * 配置管理器
+ * 负责存储和管理应用程序的配置
+ */
+class ConfigManager {
+    /**
+     * 私有构造函数
+     */
+    constructor() {
+        /** 配置存储 */
+        this.config = {};
+        /** 配置变更回调 */
+        this.changeCallbacks = new Map();
+        // 设置默认配置
+        this.config = {
+            debug: false,
+            logLevel: 'info',
+            camera: {
+                resolution: {
+                    width: 1280,
+                    height: 720
+                },
+                frameRate: 30,
+                facingMode: 'environment'
+            },
+            performance: {
+                useCache: true
+            }
+        };
+    }
+    /**
+     * 获取单例实例
+     */
+    static getInstance() {
+        if (!ConfigManager.instance) {
+            ConfigManager.instance = new ConfigManager();
+        }
+        return ConfigManager.instance;
+    }
+    /**
+     * 获取配置值
+     * @param key 配置键，支持点号分隔的路径
+     * @param defaultValue 默认值
+     */
+    get(key, defaultValue) {
+        const value = this.getNestedValue(this.config, key);
+        return (value !== undefined) ? value : defaultValue;
+    }
+    /**
+     * 设置配置值
+     * @param key 配置键，支持点号分隔的路径
+     * @param value 配置值
+     */
+    set(key, value) {
+        const oldValue = this.get(key);
+        // 如果值相同，不做任何事
+        if (oldValue === value) {
+            return;
+        }
+        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 };
+        // 重新创建默认配置
+        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) {
+        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);
+            const index = callbacks.indexOf(callback);
+            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);
+                    }
+                });
+            }
+        }
+    }
+}
+
+/**
+ * @file 日志系统
+ * @description 提供统一的日志记录与管理功能
+ * @module core/logger
+ */
+/**
+ * 日志级别枚举
+ */
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["DEBUG"] = "debug";
+    LogLevel["INFO"] = "info";
+    LogLevel["WARN"] = "warn";
+    LogLevel["ERROR"] = "error";
+})(LogLevel || (LogLevel = {}));
+/**
+ * 控制台日志处理器
+ * 将日志输出到浏览器控制台
+ */
+class ConsoleLogHandler {
+    /**
+     * 处理日志条目
+     * @param entry 日志条目
+     */
+    handle(entry) {
+        const timestamp = new Date(entry.timestamp).toISOString();
+        const prefix = `[${timestamp}] [${entry.level.toUpperCase()}] [${entry.tag}]`;
+        switch (entry.level) {
+            case LogLevel.DEBUG:
+                console.debug(prefix, entry.message, entry.error || '');
+                break;
+            case LogLevel.INFO:
+                console.info(prefix, entry.message, entry.error || '');
+                break;
+            case LogLevel.WARN:
+                console.warn(prefix, entry.message, entry.error || '');
+                break;
+            case LogLevel.ERROR:
+                console.error(prefix, entry.message, entry.error || '');
+                break;
+            // 输出什么也不做
+        }
+    }
+}
+/**
+ * 内存日志处理器
+ * 将日志保存在内存中，用于后续分析或显示
+ */
+class MemoryLogHandler {
+    /**
+     * 构造函数
+     * @param maxEntries 最大日志条目数，默认为1000
+     */
+    constructor(maxEntries = 1000) {
+        /** 日志条目数组 */
+        this.entries = [];
+        this.maxEntries = maxEntries;
+    }
+    /**
+     * 处理日志条目
+     * @param entry 日志条目
+     */
+    handle(entry) {
+        this.entries.push(entry);
+        // 如果超过最大条目数，移除最老的
+        if (this.entries.length > this.maxEntries) {
+            this.entries.shift();
+        }
+    }
+    /**
+     * 获取所有日志条目
+     */
+    getEntries() {
+        return [...this.entries];
+    }
+    /**
+     * 根据级别过滤日志条目
+     * @param level 日志级别
+     */
+    getEntriesByLevel(level) {
+        return this.entries.filter(entry => entry.level === level);
+    }
+    /**
+     * 根据标签过滤日志条目
+     * @param tag 日志标签
+     */
+    getEntriesByTag(tag) {
+        return this.entries.filter(entry => entry.tag === tag);
+    }
+    /**
+     * 清空日志
+     */
+    clear() {
+        this.entries = [];
+    }
+}
+/**
+ * 远程日志处理器
+ * 将日志发送到远程服务器
+ */
+class RemoteLogHandler {
+    /**
+     * 构造函数
+     * @param endpoint 远程服务器URL
+     * @param maxQueueSize 最大队列长度，默认为100
+     * @param flushInterval 发送间隔(毫秒)，默认为5000
+     */
+    constructor(endpoint, maxQueueSize = 100, flushInterval = 5000) {
+        /** 批量发送的队列 */
+        this.queue = [];
+        /** 定时发送的计时器ID */
+        this.timerId = null;
+        this.endpoint = endpoint;
+        this.maxQueueSize = maxQueueSize;
+        this.flushInterval = flushInterval;
+        // 设置定时发送
+        this.startTimer();
+        // 页面卸载前尝试发送剩余日志
+        window.addEventListener('beforeunload', () => {
+            this.flush();
+        });
+    }
+    /**
+     * 处理日志条目
+     * @param entry 日志条目
+     */
+    handle(entry) {
+        // 只处理INFO以上级别的日志
+        if (entry.level >= LogLevel.INFO) {
+            this.queue.push(entry);
+            // 如果队列满了，立即发送
+            if (this.queue.length >= this.maxQueueSize) {
+                this.flush();
+            }
+        }
+    }
+    /**
+     * 发送队列中的日志
+     */
+    flush() {
+        if (this.queue.length === 0)
+            return;
+        const entriesToSend = [...this.queue];
+        this.queue = [];
+        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.queue.length < this.maxQueueSize) {
+                    this.queue = [...entriesToSend.slice(0, this.maxQueueSize - this.queue.length), ...this.queue];
+                }
+            });
+        }
+        catch (error) {
+            console.error('Error sending logs:', error);
+        }
+    }
+    /**
+     * 开始定时发送
+     */
+    startTimer() {
+        if (this.timerId !== null)
+            return;
+        this.timerId = window.setInterval(() => {
+            this.flush();
+        }, this.flushInterval);
+    }
+    /**
+     * 停止定时发送
+     */
+    stopTimer() {
+        if (this.timerId !== null) {
+            window.clearInterval(this.timerId);
+            this.timerId = null;
+        }
+    }
+}
+/**
+ * 日志管理类
+ * 中央日志管理器，提供统一的日志记录接口
+ */
+class Logger {
+    /**
+     * 私有构造函数，防止直接实例化
+     */
+    constructor() {
+        /** 日志处理器 */
+        this.handlers = [];
+        /** 默认标签 */
+        this.defaultTag = 'IDScanner';
+        /** 日志级别 */
+        this.logLevel = LogLevel.INFO;
+        this.config = ConfigManager.getInstance();
+        // 默认添加控制台处理器
+        this.addHandler(new ConsoleLogHandler());
+        // 监听配置变化
+        this.config.onConfigChange('logLevel', (level) => {
+            this.debug('Logger', `Log level changed to ${level}`);
+        });
+    }
+    /**
+     * 获取单例实例
+     */
+    static getInstance() {
+        if (!Logger.instance) {
+            Logger.instance = new Logger();
+        }
+        return Logger.instance;
+    }
+    /**
+     * 添加日志处理器
+     * @param handler 日志处理器
+     */
+    addHandler(handler) {
+        this.handlers.push(handler);
+    }
+    /**
+     * 移除日志处理器
+     * @param handler 要移除的处理器
+     */
+    removeHandler(handler) {
+        const index = this.handlers.indexOf(handler);
+        if (index !== -1) {
+            this.handlers.splice(index, 1);
+        }
+    }
+    /**
+     * 移除所有处理器
+     */
+    clearHandlers() {
+        this.handlers = [];
+    }
+    /**
+     * 设置默认标签
+     * @param tag 默认标签
+     */
+    setDefaultTag(tag) {
+        this.defaultTag = tag;
+    }
+    /**
+     * 记录调试级别日志
+     * @param tag 标签
+     * @param message 消息
+     * @param error 错误
+     */
+    debug(tag, message, error) {
+        this.log(LogLevel.DEBUG, tag, message, error);
+    }
+    /**
+     * 记录信息级别日志
+     * @param tag 标签
+     * @param message 消息
+     * @param error 错误
+     */
+    info(tag, message, error) {
+        this.log(LogLevel.INFO, tag, message, error);
+    }
+    /**
+     * 记录警告级别日志
+     * @param tag 标签
+     * @param message 消息
+     * @param error 错误
+     */
+    warn(tag, message, error) {
+        this.log(LogLevel.WARN, tag, message, error);
+    }
+    /**
+     * 记录错误级别日志
+     * @param tag 标签
+     * @param message 消息
+     * @param error 错误
+     */
+    error(tag, message, error) {
+        this.log(LogLevel.ERROR, tag, message, error);
+    }
+    /**
+     * 创建标记了特定标签的日志记录器
+     * @param tag 标签
+     */
+    getTaggedLogger(tag) {
+        return new TaggedLogger(this, tag);
+    }
+    /**
+     * 记录日志
+     * @param level 日志级别
+     * @param tag 标签
+     * @param message 消息
+     * @param error 错误
+     */
+    log(level, tag, message, error) {
+        // 检查日志级别
+        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,
+            error
+        };
+        // 分发到所有处理程序
+        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 日志条目
+     */
+    consoleOutput(entry) {
+        const timestamp = new Date(entry.timestamp).toISOString();
+        const prefix = `[${timestamp}] [${entry.level.toUpperCase()}] [${entry.tag}]`;
+        switch (entry.level) {
+            case LogLevel.DEBUG:
+                console.debug(`${prefix} ${entry.message}`, entry.error || '');
+                break;
+            case LogLevel.INFO:
+                console.info(`${prefix} ${entry.message}`, entry.error || '');
+                break;
+            case LogLevel.WARN:
+                console.warn(`${prefix} ${entry.message}`, entry.error || '');
+                break;
+            case LogLevel.ERROR:
+                console.error(`${prefix} ${entry.message}`, entry.error || '');
+                break;
+        }
+    }
+    /**
+     * 获取日志级别值
+     * @param level 日志级别
+     */
+    getLevelValue(level) {
+        switch (level) {
+            case LogLevel.DEBUG:
+                return 0;
+            case LogLevel.INFO:
+                return 1;
+            case LogLevel.WARN:
+                return 2;
+            case LogLevel.ERROR:
+                return 3;
+            default:
+                return 1; // 默认INFO级别
+        }
+    }
+    /**
+     * 设置日志级别
+     * @param level 日志级别
+     */
+    setLevel(level) {
+        if (typeof level === 'string') {
+            switch (level) {
+                case 'debug':
+                    this.logLevel = LogLevel.DEBUG;
+                    break;
+                case 'info':
+                    this.logLevel = LogLevel.INFO;
+                    break;
+                case 'warn':
+                    this.logLevel = LogLevel.WARN;
+                    break;
+                case 'error':
+                    this.logLevel = LogLevel.ERROR;
+                    break;
+                default:
+                    this.logLevel = LogLevel.INFO;
+            }
+        }
+        else {
+            this.logLevel = level;
+        }
+        this.debug('Logger', `日志级别已设置为 ${this.logLevel}`);
+    }
+    /**
+     * 获取当前日志级别
+     * @returns 当前日志级别
+     */
+    getLevel() {
+        return this.logLevel;
+    }
+}
+/**
+ * 带标签的日志记录器
+ * 提供特定标签的简易日志接口
+ */
+class TaggedLogger {
+    /**
+     * 构造函数
+     * @param logger 所属的主日志记录器
+     * @param tag 标签
+     */
+    constructor(logger, tag) {
+        this.logger = logger;
+        this.tag = tag;
+    }
+    /**
+     * 记录调试级别日志
+     * @param message 消息
+     * @param error 错误
+     */
+    debug(message, error) {
+        this.logger.debug(this.tag, message, error);
+    }
+    /**
+     * 记录信息级别日志
+     * @param message 消息
+     * @param error 错误
+     */
+    info(message, error) {
+        this.logger.info(this.tag, message, error);
+    }
+    /**
+     * 记录警告级别日志
+     * @param message 消息
+     * @param error 错误
+     */
+    warn(message, error) {
+        this.logger.warn(this.tag, message, error);
+    }
+    /**
+     * 记录错误级别日志
+     * @param message 消息
+     * @param error 错误
+     */
+    error(message, error) {
+        this.logger.error(this.tag, message, error);
+    }
+}
+/**
+ * 日志级别枚举
+ */
+
+/**
+ * @file 事件发射器
+ * @description 提供基础的事件发射和订阅功能
+ * @module core/event-emitter
+ */
+/**
+ * 事件发射器基类
+ * 提供基础的事件发射和订阅功能
+ */
+class EventEmitter {
+    constructor() {
+        /** 事件处理器映射 */
+        this.eventHandlers = new Map();
+    }
+    /**
+     * 订阅事件
+     * @param eventName 事件名称
+     * @param handler 事件处理器
+     */
+    on(eventName, handler) {
+        if (!this.eventHandlers.has(eventName)) {
+            this.eventHandlers.set(eventName, new Set());
+        }
+        this.eventHandlers.get(eventName).add(handler);
+    }
+    /**
+     * 取消订阅事件
+     * @param eventName 事件名称
+     * @param handler 事件处理器，如果不提供则移除该事件的所有处理器
+     */
+    off(eventName, handler) {
+        if (!this.eventHandlers.has(eventName)) {
+            return;
+        }
+        if (handler) {
+            this.eventHandlers.get(eventName).delete(handler);
+            // 如果没有处理器了，删除这个事件
+            if (this.eventHandlers.get(eventName).size === 0) {
+                this.eventHandlers.delete(eventName);
+            }
+        }
+        else {
+            // 移除该事件的所有处理器
+            this.eventHandlers.delete(eventName);
+        }
+    }
+    /**
+     * 订阅事件，但只触发一次
+     * @param eventName 事件名称
+     * @param handler 事件处理器
+     */
+    once(eventName, handler) {
+        const onceHandler = (data) => {
+            handler(data);
+            this.off(eventName, onceHandler);
+        };
+        this.on(eventName, onceHandler);
+    }
+    /**
+     * 发射事件
+     * @param eventName 事件名称
+     * @param data 事件数据
+     */
+    emit(eventName, data) {
+        if (!this.eventHandlers.has(eventName)) {
+            return;
+        }
+        for (const handler of this.eventHandlers.get(eventName)) {
+            try {
+                handler(data);
+            }
+            catch (error) {
+                console.error(`Error in event handler for "${eventName}":`, error);
+            }
+        }
+    }
+    /**
+     * 获取某个事件的处理器数量
+     * @param eventName 事件名称
+     */
+    listenerCount(eventName) {
+        return this.eventHandlers.has(eventName) ? this.eventHandlers.get(eventName).size : 0;
+    }
+    /**
+     * 移除所有事件处理器
+     */
+    removeAllListeners() {
+        this.eventHandlers.clear();
+    }
+    /**
+     * 获取所有事件名称
+     */
+    eventNames() {
+        return Array.from(this.eventHandlers.keys());
+    }
+}
+
+/**
+ * @file 版本号文件
+ * @description 定义库的版本号
+ * @module Version
+ */
+// 当前版本号
+const VERSION = '1.5.0';
+// 构建日期
+const BUILD_DATE = new Date().toISOString();
+
+/**
+ * @file 模块管理器
+ * @description 统一管理库的各功能模块，提供模块的注册、初始化和卸载功能
+ * @module core/module-manager
+ */
+/**
+ * 模块管理器类
+ * 负责管理所有功能模块的生命周期
+ */
+class ModuleManager extends EventEmitter {
+    /**
+     * 获取模块管理器单例
+     */
+    static getInstance() {
+        if (!ModuleManager.instance) {
+            ModuleManager.instance = new ModuleManager();
+        }
+        return ModuleManager.instance;
+    }
+    /**
+     * 私有构造函数，确保单例模式
+     */
+    constructor() {
+        super();
+        this.modules = new Map();
+        this.initialized = false;
+        this.logger = Logger.getInstance();
+        this.logger.debug('ModuleManager', `初始化模块管理器 v${VERSION}`);
+    }
+    /**
+     * 注册模块
+     * @param module 要注册的模块
+     * @returns 模块管理器实例，支持链式调用
+     */
+    register(module) {
+        if (this.modules.has(module.name)) {
+            this.logger.warn('ModuleManager', `模块 "${module.name}" 已经注册，将被覆盖`);
+        }
+        this.modules.set(module.name, module);
+        this.logger.debug('ModuleManager', `注册模块: ${module.name} v${module.version}`);
+        this.emit('module:registered', { name: module.name });
+        return this;
+    }
+    /**
+     * 获取模块
+     * @param name 模块名称
+     * @returns 模块实例
+     */
+    getModule(name) {
+        return this.modules.get(name);
+    }
+    /**
+     * 初始化所有注册的模块
+     */
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        this.logger.debug('ModuleManager', '开始初始化所有模块...');
+        for (const [name, module] of this.modules.entries()) {
+            try {
+                this.logger.debug('ModuleManager', `初始化模块: ${name}`);
+                await module.initialize();
+                this.emit('module:initialized', { name });
+                this.logger.debug('ModuleManager', `模块 ${name} 初始化完成`);
+            }
+            catch (error) {
+                const errorObj = error instanceof Error ? error : new Error(String(error));
+                this.logger.error('ModuleManager', `模块 ${name} 初始化失败`, errorObj);
+                this.emit('module:error', { name, error });
+                throw new Error(`模块 ${name} 初始化失败: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        this.initialized = true;
+        this.logger.debug('ModuleManager', '所有模块初始化完成');
+        this.emit('modules:initialized');
+    }
+    /**
+     * 卸载所有模块并释放资源
+     */
+    async dispose() {
+        this.logger.debug('ModuleManager', '开始释放所有模块资源...');
+        for (const [name, module] of this.modules.entries()) {
+            try {
+                this.logger.debug('ModuleManager', `释放模块资源: ${name}`);
+                await module.dispose();
+                this.emit('module:disposed', { name });
+            }
+            catch (error) {
+                const errorObj = error instanceof Error ? error : new Error(String(error));
+                this.logger.error('ModuleManager', `模块 ${name} 资源释放失败`, errorObj);
+                this.emit('module:error', { name, error });
+            }
+        }
+        this.modules.clear();
+        this.initialized = false;
+        this.logger.debug('ModuleManager', '所有模块资源已释放');
+        this.emit('modules:disposed');
+    }
+    /**
+     * 获取所有已注册的模块名称
+     */
+    getRegisteredModules() {
+        return Array.from(this.modules.keys());
+    }
+    /**
+     * 检查模块是否已注册
+     * @param name 模块名称
+     */
+    hasModule(name) {
+        return this.modules.has(name);
+    }
+}
+
+/**
+ * @file 基础模块
+ * @description 提供基础模块实现，作为所有功能模块的基类
+ * @module core/base-module
+ */
+/**
+ * 基础模块类
+ * 提供模块的基本功能和生命周期管理
+ */
+class BaseModule extends EventEmitter {
+    /**
+     * 构造函数
+     */
+    constructor() {
+        super();
+        /** 模块版本 */
+        this.version = VERSION;
+        /** 模块是否已初始化 */
+        this._isInitialized = false;
+        this.logger = Logger.getInstance();
+    }
+    /**
+     * 获取模块是否已初始化
+     */
+    get isInitialized() {
+        return this._isInitialized;
+    }
+    /**
+     * 释放模块资源
+     * 子类可以覆盖此方法以添加额外的资源释放逻辑
+     */
+    async dispose() {
+        if (!this._isInitialized) {
+            return;
+        }
+        this.logger.debug(this.name, '释放模块资源');
+        // 重置初始化状态
+        this._isInitialized = false;
+        // 删除所有事件监听器
+        this.removeAllListeners();
+        this.logger.debug(this.name, '模块资源已释放');
+    }
+    /**
+     * 检查模块是否已初始化，如果未初始化则抛出错误
+     */
+    ensureInitialized() {
+        if (!this._isInitialized) {
+            throw new Error(`模块 ${this.name} 尚未初始化`);
+        }
+    }
+}
+
+/**
+ * @file 结果包装类
+ * @description 提供统一的操作结果封装
+ * @module core/result
+ */
+/**
+ * 结果类型
+ * 用于封装操作的成功或失败结果
+ */
+class Result {
+    /**
+     * 构造函数
+     * @param success 是否成功
+     * @param data 结果数据
+     * @param error 错误对象
+     * @param meta 元数据
+     */
+    constructor(success, data, error, meta) {
+        this._success = success;
+        this._data = data;
+        this._error = error;
+        this._meta = meta;
+    }
+    /**
+     * 创建成功结果
+     * @param data 结果数据
+     * @param meta 元数据
+     */
+    static success(data, meta) {
+        return new Result(true, data, undefined, meta);
+    }
+    /**
+     * 创建失败结果
+     * @param error 错误对象
+     * @param meta 元数据
+     */
+    static failure(error, meta) {
+        return new Result(false, undefined, error, meta);
+    }
+    /**
+     * 检查结果是否成功
+     */
+    isSuccess() {
+        return this._success;
+    }
+    /**
+     * 检查结果是否失败
+     */
+    isFailure() {
+        return !this._success;
+    }
+    /**
+     * 获取结果数据
+     */
+    get data() {
+        return this._data;
+    }
+    /**
+     * 获取错误对象
+     */
+    get error() {
+        return this._error;
+    }
+    /**
+     * 获取元数据
+     */
+    get meta() {
+        return this._meta;
+    }
+    /**
+     * 映射结果（如果成功）
+     * @param fn 映射函数
+     */
+    map(fn) {
+        if (this.isSuccess() && this._data !== undefined) {
+            try {
+                const newData = fn(this._data);
+                return Result.success(newData, this._meta);
+            }
+            catch (error) {
+                return Result.failure(error instanceof Error ? error : new Error(String(error)), this._meta);
+            }
+        }
+        return Result.failure(this._error, this._meta);
+    }
+    /**
+     * 如果成功，则执行函数
+     * @param fn 要执行的函数
+     */
+    onSuccess(fn) {
+        if (this.isSuccess()) {
+            try {
+                fn(this._data);
+            }
+            catch (error) {
+                console.error('Error in onSuccess handler:', error);
+            }
+        }
+        return this;
+    }
+    /**
+     * 如果失败，则执行函数
+     * @param fn 要执行的函数
+     */
+    onFailure(fn) {
+        if (this.isFailure() && this._error) {
+            try {
+                fn(this._error);
+            }
+            catch (error) {
+                console.error('Error in onFailure handler:', error);
+            }
+        }
+        return this;
+    }
+    /**
+     * 无论成功失败，都执行函数
+     * @param fn 要执行的函数
+     */
+    onFinally(fn) {
+        try {
+            fn();
+        }
+        catch (error) {
+            console.error('Error in onFinally handler:', error);
+        }
+        return this;
+    }
+    /**
+     * 转换为字符串
+     */
+    toString() {
+        if (this.isSuccess()) {
+            return `Success: ${JSON.stringify(this._data)}`;
+        }
+        else {
+            return `Failure: ${this._error?.message || 'Unknown error'}`;
+        }
+    }
+}
+
+/**
+ * @file 身份证模块类型定义
+ * @description 身份证模块相关的类型和接口定义
+ * @module modules/id-card/types
+ */
+/**
+ * 身份证类型枚举
+ */
+var IDCardType;
+(function (IDCardType) {
+    /** 第二代居民身份证正面 */
+    IDCardType["FRONT"] = "front";
+    /** 第二代居民身份证背面 */
+    IDCardType["BACK"] = "back";
+    /** 第一代居民身份证 */
+    IDCardType["FIRST_GENERATION"] = "first_generation";
+    /** 临时身份证 */
+    IDCardType["TEMPORARY"] = "temporary";
+    /** 外国人永久居留证 */
+    IDCardType["FOREIGN_PERMANENT"] = "foreign_permanent";
+    /** 港澳台居民居住证 */
+    IDCardType["HMT_RESIDENT"] = "hmt_resident";
+    /** 未知类型 */
+    IDCardType["UNKNOWN"] = "unknown";
+})(IDCardType || (IDCardType = {}));
+
+/**
+ * @file 身份证检测器
+ * @description 提供身份证检测和解析功能
+ * @module modules/id-card/id-card-detector
+ */
+/**
+ * 身份证检测器类
+ */
+class IDCardDetector extends EventEmitter {
+    /**
+     * 构造函数
+     * @param options 配置选项
+     */
+    constructor(options = {}) {
+        super();
+        this.initialized = false;
+        this.models = {};
+        this.options = {
+            enabled: true,
+            minConfidence: 0.7,
+            detectType: true,
+            detectEdge: true,
+            enableEdgeDetection: false,
+            enableOCR: true,
+            cropAndAlign: true,
+            enableAntiFake: false,
+            returnImage: false,
+            modelPath: '/models/id-card',
+            ...options
+        };
+        this.logger = Logger.getInstance();
+    }
+    /**
+     * 初始化检测器
+     */
+    async initialize() {
+        if (this.initialized || !this.options.enabled) {
+            return;
+        }
+        this.logger.debug('IDCardDetector', '初始化身份证检测器');
+        try {
+            // 加载检测模型
+            await this.loadDetectionModel();
+            // 如果启用OCR，加载OCR模型
+            if (this.options.enableOCR) {
+                await this.loadOCRModel();
+            }
+            // 如果启用防伪检测，加载防伪模型
+            if (this.options.enableAntiFake) {
+                await this.loadAntiFakeModel();
+            }
+            this.initialized = true;
+            this.emit('detector:initialized', {});
+            this.logger.debug('IDCardDetector', '身份证检测器初始化完成');
+        }
+        catch (error) {
+            this.logger.error('IDCardDetector', '身份证检测器初始化失败', error);
+            throw error;
+        }
+    }
+    /**
+     * 加载检测模型
+     * @private
+     */
+    async loadDetectionModel() {
+        // 实际项目中，这里应该加载检测模型
+        this.logger.debug('IDCardDetector', '加载身份证检测模型');
+        // 模拟加载模型的延迟
+        await new Promise(resolve => setTimeout(resolve, 100));
+        // 设置模型
+        this.models.detection = {
+            loaded: true,
+            name: 'id-card-detection'
+        };
+    }
+    /**
+     * 加载OCR模型
+     * @private
+     */
+    async loadOCRModel() {
+        // 实际项目中，这里应该加载OCR模型
+        this.logger.debug('IDCardDetector', '加载身份证OCR模型');
+        // 模拟加载模型的延迟
+        await new Promise(resolve => setTimeout(resolve, 100));
+        // 设置模型
+        this.models.ocr = {
+            loaded: true,
+            name: 'id-card-ocr'
+        };
+    }
+    /**
+     * 加载防伪模型
+     * @private
+     */
+    async loadAntiFakeModel() {
+        // 实际项目中，这里应该加载防伪模型
+        this.logger.debug('IDCardDetector', '加载身份证防伪模型');
+        // 模拟加载模型的延迟
+        await new Promise(resolve => setTimeout(resolve, 100));
+        // 设置模型
+        this.models.antiFake = {
+            loaded: true,
+            name: 'id-card-anti-fake'
+        };
+    }
+    /**
+     * 处理图像
+     * @param image 图像源（可以是ImageData、HTMLImageElement、HTMLCanvasElement等）
+     * @param processOptions 图像处理选项
+     * @returns 处理结果
+     */
+    async processImage(image, processOptions = {}) {
+        if (!this.initialized) {
+            return Result.failure(new Error('身份证检测器未初始化'));
+        }
+        try {
+            this.logger.debug('IDCardDetector', '开始处理图像');
+            // 预处理图像
+            const processedImage = await this.preprocessImage(image, processOptions);
+            // 检测身份证
+            const detectionResult = await this.detectIDCard(processedImage);
+            if (!detectionResult || detectionResult.confidence < (this.options.minConfidence || 0.7)) {
+                return Result.failure(new Error('未检测到身份证或置信度过低'));
+            }
+            let idCardInfo = {
+                type: detectionResult.type,
+                edge: detectionResult.edge,
+                confidence: detectionResult.confidence
+            };
+            // 如果启用OCR识别，提取文字信息
+            if (this.options.enableOCR && this.models.ocr) {
+                // 裁剪并校正图像
+                const alignedImage = this.options.cropAndAlign ?
+                    await this.cropAndAlign(processedImage, detectionResult.edge) :
+                    processedImage;
+                // 识别文字
+                const ocrResult = await this.recognizeText(alignedImage, detectionResult.type);
+                // 合并结果
+                idCardInfo = {
+                    ...idCardInfo,
+                    ...ocrResult
+                };
+            }
+            // 如果启用防伪检测，进行防伪检测
+            if (this.options.enableAntiFake && this.models.antiFake) {
+                const antiFakeResult = await this.detectAntiFake(processedImage, detectionResult);
+                idCardInfo.antiFake = antiFakeResult;
+            }
+            // 如果需要返回原始图像
+            if (this.options.returnImage) {
+                // 根据图像类型获取ImageData
+                if (image instanceof ImageData) {
+                    idCardInfo.image = image;
+                }
+                else if (image instanceof HTMLCanvasElement) {
+                    const context = image.getContext('2d');
+                    if (context) {
+                        idCardInfo.image = context.getImageData(0, 0, image.width, image.height);
+                    }
+                }
+                else if (image instanceof HTMLImageElement && image.complete) {
+                    const canvas = document.createElement('canvas');
+                    canvas.width = image.naturalWidth;
+                    canvas.height = image.naturalHeight;
+                    const context = canvas.getContext('2d');
+                    if (context) {
+                        context.drawImage(image, 0, 0);
+                        idCardInfo.image = context.getImageData(0, 0, canvas.width, canvas.height);
+                    }
+                }
+            }
+            this.logger.debug('IDCardDetector', '图像处理完成');
+            this.emit('detector:result', { result: idCardInfo });
+            return Result.success(idCardInfo);
+        }
+        catch (error) {
+            this.logger.error('IDCardDetector', '图像处理失败', error);
+            return Result.failure(error);
+        }
+    }
+    /**
+     * 预处理图像
+     * @param image 图像源
+     * @param options 处理选项
+     * @returns 处理后的图像
+     * @private
+     */
+    async preprocessImage(image, options) {
+        // 实际项目中，这里应该对图像进行预处理
+        this.logger.debug('IDCardDetector', '预处理图像');
+        // 创建ImageData对象
+        let imageData;
+        if (image instanceof ImageData) {
+            imageData = image;
+        }
+        else {
+            const canvas = document.createElement('canvas');
+            const width = image instanceof HTMLImageElement ? image.naturalWidth : image.width;
+            const height = image instanceof HTMLImageElement ? image.naturalHeight : image.height;
+            canvas.width = width;
+            canvas.height = height;
+            const context = canvas.getContext('2d');
+            if (!context) {
+                throw new Error('无法获取Canvas上下文');
+            }
+            if (image instanceof HTMLImageElement) {
+                context.drawImage(image, 0, 0);
+            }
+            else {
+                context.drawImage(image, 0, 0);
+            }
+            imageData = context.getImageData(0, 0, width, height);
+        }
+        // 应用图像处理选项
+        // 实际项目中，这里应该根据options进行相应的图像处理
+        return imageData;
+    }
+    /**
+     * 检测身份证
+     * @param image 图像数据
+     * @returns 检测结果
+     * @private
+     */
+    async detectIDCard(image) {
+        // 实际项目中，这里应该调用模型进行身份证检测
+        this.logger.debug('IDCardDetector', '检测身份证');
+        // 模拟检测结果
+        // 在实际应用中，这里应该使用机器学习模型进行推理
+        return {
+            type: IDCardType.FRONT,
+            edge: {
+                topLeft: { x: 10, y: 10 },
+                topRight: { x: image.width - 10, y: 10 },
+                bottomRight: { x: image.width - 10, y: image.height - 10 },
+                bottomLeft: { x: 10, y: image.height - 10 }
+            },
+            confidence: 0.95
+        };
+    }
+    /**
+     * 裁剪并校正图像
+     * @param image 图像数据
+     * @param edge 边缘信息
+     * @returns 校正后的图像
+     * @private
+     */
+    async cropAndAlign(image, edge) {
+        // 实际项目中，这里应该进行透视变换以校正图像
+        this.logger.debug('IDCardDetector', '裁剪并校正图像');
+        // 创建Canvas
+        const canvas = document.createElement('canvas');
+        // 设置标准身份证尺寸比例
+        canvas.width = 428;
+        canvas.height = 270;
+        const context = canvas.getContext('2d');
+        if (!context) {
+            throw new Error('无法获取Canvas上下文');
+        }
+        // 创建临时Canvas
+        const tempCanvas = document.createElement('canvas');
+        tempCanvas.width = image.width;
+        tempCanvas.height = image.height;
+        const tempContext = tempCanvas.getContext('2d');
+        if (!tempContext) {
+            throw new Error('无法获取临时Canvas上下文');
+        }
+        // 将ImageData绘制到临时Canvas
+        tempContext.putImageData(image, 0, 0);
+        // 在实际应用中，这里应该使用透视变换算法
+        // 例如使用Canvas的transform或WebGL进行变换
+        // 简化处理：直接裁剪
+        context.drawImage(tempCanvas, edge.topLeft.x, edge.topLeft.y, edge.topRight.x - edge.topLeft.x, edge.bottomLeft.y - edge.topLeft.y, 0, 0, canvas.width, canvas.height);
+        return context.getImageData(0, 0, canvas.width, canvas.height);
+    }
+    /**
+     * 识别文字
+     * @param image 图像数据
+     * @param type 身份证类型
+     * @returns 识别结果
+     * @private
+     */
+    async recognizeText(image, type) {
+        // 实际项目中，这里应该调用OCR模型进行文字识别
+        this.logger.debug('IDCardDetector', '识别文字');
+        // 模拟OCR结果
+        // 在实际应用中，这里应该使用OCR模型进行文字识别
+        if (type === IDCardType.FRONT) {
+            return {
+                name: '张三',
+                gender: '男',
+                ethnicity: '汉',
+                birthDate: '1990-01-01',
+                address: '北京市朝阳区某某街道某某社区1号楼1单元101',
+                idNumber: '110101199001010001',
+                photoRegion: {
+                    x: 300,
+                    y: 40,
+                    width: 100,
+                    height: 130
+                }
+            };
+        }
+        else if (type === IDCardType.BACK) {
+            return {
+                issueAuthority: '北京市公安局朝阳分局',
+                validFrom: '2015-01-01',
+                validTo: '2035-01-01'
+            };
+        }
+        return {};
+    }
+    /**
+     * 检测防伪特征
+     * @param image 图像数据
+     * @param detectionResult 检测结果
+     * @returns 防伪检测结果
+     * @private
+     */
+    async detectAntiFake(image, detectionResult) {
+        // 实际项目中，这里应该调用防伪模型进行特征检测
+        this.logger.debug('IDCardDetector', '检测防伪特征');
+        // 模拟防伪检测结果
+        // 在实际应用中，这里应该使用机器学习模型检测防伪特征
+        return {
+            passed: true,
+            score: 0.92,
+            features: {
+                fluorescent: true,
+                microtext: true,
+                opticalVariable: true,
+                texture: true,
+                watermark: true
+            }
+        };
+    }
+    /**
+     * 释放资源
+     */
+    dispose() {
+        this.logger.debug('IDCardDetector', '释放资源');
+        // 清理模型
+        this.models = {};
+        this.initialized = false;
+        // 清理事件监听
+        this.removeAllListeners();
+    }
+}
+
+/**
+ * @file 图像处理工具类
+ * @description 提供图像预处理功能，用于提高OCR识别率
+ * @module ImageProcessor
+ * @version 1.3.2
+ */
+/**
+ * 图像处理工具类
+ *
+ * 提供各种图像处理功能，用于优化识别效果
+ */
+class ImageProcessor {
+    /**
+     * 将ImageData转换为Canvas元素
+     *
+     * @param {ImageData} imageData - 要转换的图像数据
+     * @returns {HTMLCanvasElement} 包含图像的Canvas元素
+     */
+    static imageDataToCanvas(imageData) {
+        const canvas = document.createElement("canvas");
+        canvas.width = imageData.width;
+        canvas.height = imageData.height;
+        const ctx = canvas.getContext("2d");
+        if (ctx) {
+            ctx.putImageData(imageData, 0, 0);
+        }
+        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;
+    }
+    /**
+     * 将图像转换为灰度图
+     *
+     * @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;
+        }
+        return imageData;
+    }
+    /**
+     * 锐化图像
+     *
+     * @param imageData 原始图像数据
+     * @param amount 锐化程度，默认为2
+     * @returns 锐化后的图像数据
+     */
+    static sharpen(imageData, amount = 2) {
+        if (!imageData || !imageData.data)
+            return imageData;
+        const width = imageData.width;
+        const height = imageData.height;
+        const data = imageData.data;
+        const outputData = new Uint8ClampedArray(data.length);
+        // 锐化卷积核
+        const kernel = [
+            0,
+            -amount,
+            0,
+            -amount,
+            1 + 4 * amount,
+            -amount,
+            0,
+            -amount,
+            0,
+        ];
+        // 应用卷积
+        for (let y = 1; y < height - 1; y++) {
+            for (let x = 1; x < width - 1; x++) {
+                const pos = (y * width + x) * 4;
+                // 对每个通道应用卷积
+                for (let c = 0; c < 3; c++) {
+                    let val = 0;
+                    for (let ky = -1; ky <= 1; ky++) {
+                        for (let kx = -1; kx <= 1; kx++) {
+                            const kernelPos = (ky + 1) * 3 + (kx + 1);
+                            const dataPos = ((y + ky) * width + (x + kx)) * 4 + c;
+                            val += data[dataPos] * kernel[kernelPos];
+                        }
+                    }
+                    outputData[pos + c] = Math.max(0, Math.min(255, val));
+                }
+                outputData[pos + 3] = data[pos + 3]; // 保持透明度不变
+            }
+        }
+        // 处理边缘像素
+        for (let y = 0; y < height; y++) {
+            for (let x = 0; x < width; x++) {
+                if (y === 0 || y === height - 1 || x === 0 || x === width - 1) {
+                    const pos = (y * width + x) * 4;
+                    outputData[pos] = data[pos];
+                    outputData[pos + 1] = data[pos + 1];
+                    outputData[pos + 2] = data[pos + 2];
+                    outputData[pos + 3] = data[pos + 3];
+                }
+            }
+        }
+        // 创建新的ImageData对象
+        return new ImageData(outputData, width, height);
+    }
+    /**
+     * 对图像应用阈值操作，增强对比度
+     *
+     * @param imageData 原始图像数据
+     * @param threshold 阈值 (0-255)
+     * @returns 处理后的图像数据
+     */
+    static threshold(imageData, threshold = 128) {
+        // 先转换为灰度图
+        const grayscaleImage = this.toGrayscale(new ImageData(new Uint8ClampedArray(imageData.data), imageData.width, imageData.height));
+        const data = grayscaleImage.data;
+        const length = data.length;
+        for (let i = 0; i < length; i += 4) {
+            // 二值化处理
+            const value = data[i] < threshold ? 0 : 255;
+            data[i] = data[i + 1] = data[i + 2] = value;
+        }
+        return grayscaleImage;
+    }
+    /**
+     * 将图像转换为黑白图像（二值化）
+     *
+     * @param imageData 原始图像数据
+     * @returns 二值化后的图像数据
+     */
+    static toBinaryImage(imageData) {
+        // 先转换为灰度图
+        const grayscaleImage = this.toGrayscale(new ImageData(new Uint8ClampedArray(imageData.data), imageData.width, imageData.height));
+        // 使用OTSU算法自动确定阈值
+        const threshold = this.getOtsuThreshold(grayscaleImage);
+        return this.threshold(grayscaleImage, threshold);
+    }
+    /**
+     * 使用OTSU算法计算最佳阈值
+     *
+     * @param imageData 灰度图像数据
+     * @returns 最佳阈值
+     */
+    static getOtsuThreshold(imageData) {
+        const data = imageData.data;
+        const histogram = new Array(256).fill(0);
+        // 统计灰度直方图
+        for (let i = 0; i < data.length; i += 4) {
+            histogram[data[i]]++;
+        }
+        const total = imageData.width * imageData.height;
+        let sum = 0;
+        // 计算总灰度值和
+        for (let i = 0; i < 256; i++) {
+            sum += i * histogram[i];
+        }
+        let sumB = 0;
+        let wB = 0;
+        let wF = 0;
+        let maxVariance = 0;
+        let threshold = 0;
+        // 遍历所有可能的阈值，找到最大类间方差
+        for (let t = 0; t < 256; t++) {
+            wB += histogram[t]; // 背景权重
+            if (wB === 0)
+                continue;
+            wF = total - wB; // 前景权重
+            if (wF === 0)
+                break;
+            sumB += t * histogram[t];
+            const mB = sumB / wB; // 背景平均灰度
+            const mF = (sum - sumB) / wF; // 前景平均灰度
+            // 计算类间方差
+            const variance = wB * wF * (mB - mF) * (mB - mF);
+            if (variance > maxVariance) {
+                maxVariance = variance;
+                threshold = t;
+            }
+        }
+        return threshold;
+    }
+    /**
+     * 批量应用图像处理
+     *
+     * @param imageData 原始图像数据
+     * @param options 处理选项
+     * @returns 处理后的图像数据
+     */
+    static batchProcess(imageData, options) {
+        let processedImage = new ImageData(new Uint8ClampedArray(imageData.data), imageData.width, imageData.height);
+        // 应用亮度和对比度调整
+        if (options.brightness !== undefined || options.contrast !== undefined) {
+            processedImage = this.adjustBrightnessContrast(processedImage, options.brightness || 0, options.contrast || 0);
+        }
+        // 应用灰度转换
+        if (options.grayscale) {
+            processedImage = this.toGrayscale(processedImage);
+        }
+        // 应用锐化
+        if (options.sharpen) {
+            processedImage = this.sharpen(processedImage);
+        }
+        // 应用颜色反转
+        if (options.invert) {
+            const data = processedImage.data;
+            for (let i = 0; i < data.length; i += 4) {
+                // 反转RGB值
+                data[i] = 255 - data[i];
+                data[i + 1] = 255 - data[i + 1];
+                data[i + 2] = 255 - data[i + 2];
+                // Alpha通道保持不变
+            }
+        }
+        return processedImage;
+    }
+    /**
+     * 压缩图片文件
+     *
+     * @param file 图片文件
+     * @param options 压缩选项
+     * @returns Promise<File> 压缩后的文件
+     */
+    static async compressImage(file, options) {
+        const defaultOptions = {
+            maxSizeMB: 1,
+            maxWidthOrHeight: 1920,
+            useWebWorker: true,
+            quality: 0.8,
+            fileType: file.type || "image/jpeg",
+        };
+        const compressOptions = { ...defaultOptions, ...options };
+        try {
+            return await imageCompression(file, compressOptions);
+        }
+        catch (error) {
+            console.error("图片压缩失败:", error);
+            return file; // 如果压缩失败，返回原始文件
+        }
+    }
+    /**
+     * 从图片文件创建ImageData
+     *
+     * @param file 图片文件
+     * @returns Promise<ImageData>
+     */
+    static async createImageDataFromFile(file) {
+        return new Promise((resolve, reject) => {
+            try {
+                const img = new Image();
+                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
+                        ctx.drawImage(img, 0, 0);
+                        // 获取图像数据
+                        const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+                        // 释放资源
+                        URL.revokeObjectURL(url);
+                        resolve(imageData);
+                    }
+                    catch (e) {
+                        reject(e);
+                    }
+                };
+                img.onerror = () => {
+                    URL.revokeObjectURL(url);
+                    reject(new Error("图片加载失败"));
+                };
+                img.src = url;
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    /**
+     * 将ImageData转换为File对象
+     *
+     * @param imageData ImageData对象
+     * @param fileName 输出文件名
+     * @param fileType 输出文件类型
+     * @param quality 图片质量 (0-1)
+     * @returns Promise<File>
+     */
+    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.toBlob((blob) => {
+                    if (!blob) {
+                        reject(new Error("无法创建图片Blob"));
+                        return;
+                    }
+                    const file = new File([blob], fileName, { type: fileType });
+                    resolve(file);
+                }, fileType, quality);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    /**
+     * 将图像调整到指定大小
+     * @param image 输入图像
+     * @param maxWidth 最大宽度
+     * @param maxHeight 最大高度
+     * @param keepAspectRatio 是否保持宽高比
+     * @returns 调整后的图像
+     */
+    static resizeImage(image, maxWidth, maxHeight, keepAspectRatio = true) {
+        // 创建canvas元素
+        const canvas = document.createElement('canvas');
+        const ctx = canvas.getContext('2d');
+        if (!ctx) {
+            throw new Error('无法创建Canvas上下文');
+        }
+        // 获取图像尺寸
+        let width;
+        let height;
+        if (image instanceof ImageData) {
+            width = image.width;
+            height = image.height;
+        }
+        else {
+            width = image.width;
+            height = image.height;
+        }
+        // 计算调整后的尺寸
+        let newWidth = width;
+        let newHeight = height;
+        if (keepAspectRatio) {
+            if (width > height) {
+                if (width > maxWidth) {
+                    newHeight = Math.round(height * (maxWidth / width));
+                    newWidth = maxWidth;
+                }
+            }
+            else {
+                if (height > maxHeight) {
+                    newWidth = Math.round(width * (maxHeight / height));
+                    newHeight = maxHeight;
+                }
+            }
+        }
+        else {
+            newWidth = Math.min(width, maxWidth);
+            newHeight = Math.min(height, maxHeight);
+        }
+        // 设置canvas尺寸
+        canvas.width = newWidth;
+        canvas.height = newHeight;
+        // 绘制调整后的图像
+        if (image instanceof ImageData) {
+            // 创建临时canvas存储ImageData
+            const tempCanvas = document.createElement('canvas');
+            const tempCtx = tempCanvas.getContext('2d');
+            if (!tempCtx) {
+                throw new Error('无法创建临时Canvas上下文');
+            }
+            tempCanvas.width = image.width;
+            tempCanvas.height = image.height;
+            tempCtx.putImageData(image, 0, 0);
+            // 绘制调整后的图像
+            ctx.drawImage(tempCanvas, 0, 0, width, height, 0, 0, newWidth, newHeight);
+        }
+        else {
+            ctx.drawImage(image, 0, 0, width, height, 0, 0, newWidth, newHeight);
+        }
+        // 返回调整后的ImageData
+        return ctx.getImageData(0, 0, newWidth, newHeight);
+    }
+    /**
+     * 边缘检测算法，用于识别图像中的边缘
+     * 基于Sobel算子实现
+     *
+     * @param imageData 原始图像数据，应已转为灰度图
+     * @param threshold 边缘阈值，默认为30
+     * @returns 检测到边缘的图像数据
+     */
+    static detectEdges(imageData, threshold = 30) {
+        // 确保输入图像是灰度图
+        const grayscaleImage = this.toGrayscale(new ImageData(new Uint8ClampedArray(imageData.data), imageData.width, imageData.height));
+        const width = grayscaleImage.width;
+        const height = grayscaleImage.height;
+        const inputData = grayscaleImage.data;
+        const outputData = new Uint8ClampedArray(inputData.length);
+        // Sobel算子 - 水平和垂直方向
+        const sobelX = [-1, 0, 1, -2, 0, 2, -1, 0, 1];
+        const sobelY = [-1, -2, -1, 0, 0, 0, 1, 2, 1];
+        // 对每个像素应用Sobel算子
+        for (let y = 1; y < height - 1; y++) {
+            for (let x = 1; x < width - 1; x++) {
+                let gx = 0;
+                let gy = 0;
+                // 应用卷积
+                for (let ky = -1; ky <= 1; ky++) {
+                    for (let kx = -1; kx <= 1; kx++) {
+                        const pixelPos = ((y + ky) * width + (x + kx)) * 4;
+                        const pixelVal = inputData[pixelPos]; // 灰度值
+                        const kernelIdx = (ky + 1) * 3 + (kx + 1);
+                        gx += pixelVal * sobelX[kernelIdx];
+                        gy += pixelVal * sobelY[kernelIdx];
+                    }
+                }
+                // 计算梯度强度
+                let magnitude = Math.sqrt(gx * gx + gy * gy);
+                // 应用阈值
+                magnitude = magnitude > threshold ? 255 : 0;
+                // 设置输出像素
+                const pos = (y * width + x) * 4;
+                outputData[pos] = outputData[pos + 1] = outputData[pos + 2] = magnitude;
+                outputData[pos + 3] = 255; // 透明度保持完全不透明
+            }
+        }
+        // 处理边缘像素
+        for (let i = 0; i < width * 4; i++) {
+            // 顶部和底部行
+            outputData[i] = 0;
+            outputData[(height - 1) * width * 4 + i] = 0;
+        }
+        for (let i = 0; i < height; i++) {
+            // 左右两侧列
+            const leftPos = i * width * 4;
+            const rightPos = (i * width + width - 1) * 4;
+            for (let j = 0; j < 4; j++) {
+                outputData[leftPos + j] = 0;
+                outputData[rightPos + j] = 0;
+            }
+        }
+        return new ImageData(outputData, width, height);
+    }
+    /**
+     * 卡尼-德里奇边缘检测
+     * 相比Sobel更精确的边缘检测算法
+     *
+     * @param imageData 灰度图像数据
+     * @param lowThreshold 低阈值
+     * @param highThreshold 高阈值
+     * @returns 边缘检测结果
+     */
+    static cannyEdgeDetection(imageData, lowThreshold = 20, highThreshold = 50) {
+        const grayscaleImage = this.toGrayscale(new ImageData(new Uint8ClampedArray(imageData.data), imageData.width, imageData.height));
+        // 1. 高斯模糊
+        const blurredImage = this.gaussianBlur(grayscaleImage, 1.5);
+        // 2. 使用Sobel算子计算梯度
+        const { gradientMagnitude, gradientDirection } = this.computeGradients(blurredImage);
+        // 3. 非极大值抛弃
+        const nonMaxSuppressed = this.nonMaxSuppression(gradientMagnitude, gradientDirection, blurredImage.width, blurredImage.height);
+        // 4. 双阈值处理
+        const thresholdResult = this.hysteresisThresholding(nonMaxSuppressed, blurredImage.width, blurredImage.height, lowThreshold, highThreshold);
+        // 创建输出图像
+        const outputData = new Uint8ClampedArray(imageData.data.length);
+        // 将结果转换为ImageData
+        for (let i = 0; i < thresholdResult.length; i++) {
+            const pos = i * 4;
+            const value = thresholdResult[i] ? 255 : 0;
+            outputData[pos] = outputData[pos + 1] = outputData[pos + 2] = value;
+            outputData[pos + 3] = 255;
+        }
+        return new ImageData(outputData, blurredImage.width, blurredImage.height);
+    }
+    /**
+     * 高斯模糊
+     */
+    static gaussianBlur(imageData, sigma = 1.5) {
+        const width = imageData.width;
+        const height = imageData.height;
+        const inputData = imageData.data;
+        const outputData = new Uint8ClampedArray(inputData.length);
+        // 生成高斯核
+        const kernelSize = Math.max(3, Math.floor(sigma * 3) * 2 + 1);
+        const halfKernel = Math.floor(kernelSize / 2);
+        const kernel = this.generateGaussianKernel(kernelSize, sigma);
+        // 应用高斯核
+        for (let y = 0; y < height; y++) {
+            for (let x = 0; x < width; x++) {
+                let sum = 0;
+                let weightSum = 0;
+                for (let ky = -halfKernel; ky <= halfKernel; ky++) {
+                    for (let kx = -halfKernel; kx <= halfKernel; kx++) {
+                        const pixelY = Math.min(Math.max(y + ky, 0), height - 1);
+                        const pixelX = Math.min(Math.max(x + kx, 0), width - 1);
+                        const pixelPos = (pixelY * width + pixelX) * 4;
+                        const kernelY = ky + halfKernel;
+                        const kernelX = kx + halfKernel;
+                        const weight = kernel[kernelY * kernelSize + kernelX];
+                        sum += inputData[pixelPos] * weight;
+                        weightSum += weight;
+                    }
+                }
+                const pos = (y * width + x) * 4;
+                const value = Math.round(sum / weightSum);
+                outputData[pos] = outputData[pos + 1] = outputData[pos + 2] = value;
+                outputData[pos + 3] = 255;
+            }
+        }
+        return new ImageData(outputData, width, height);
+    }
+    /**
+     * 生成高斯核
+     */
+    static generateGaussianKernel(size, sigma) {
+        const kernel = new Array(size * size);
+        const center = Math.floor(size / 2);
+        let sum = 0;
+        for (let y = 0; y < size; y++) {
+            for (let x = 0; x < size; x++) {
+                const distance = Math.sqrt((x - center) ** 2 + (y - center) ** 2);
+                const value = Math.exp(-(distance ** 2) / (2 * sigma ** 2));
+                kernel[y * size + x] = value;
+                sum += value;
+            }
+        }
+        // 归一化
+        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];
+                    }
+                }
+                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;
+                }
+            }
+        }
+        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;
+                // 将方向量化为四个方向: 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 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;
+    }
+}
+
+/**
+ * @file 性能优化工具
+ * @description 提供性能优化相关的工具函数
+ * @module utils/performance
+ */
+/**
+ * LRU缓存实现
+ */
+class LRUCache {
+    /**
+     * 构造函数
+     * @param capacity 缓存容量
+     */
+    constructor(capacity = 100) {
+        this.capacity = capacity;
+        this.cache = new Map();
+    }
+    /**
+     * 获取缓存项
+     * @param key 键
+     * @returns 值，如果不存在则返回undefined
+     */
+    get(key) {
+        if (!this.cache.has(key)) {
+            return undefined;
+        }
+        // 获取值
+        const value = this.cache.get(key);
+        // 删除旧位置
+        this.cache.delete(key);
+        // 添加到最新位置
+        this.cache.set(key, value);
+        return value;
+    }
+    /**
+     * 设置缓存项
+     * @param key 键
+     * @param value 值
+     */
+    set(key, value) {
+        // 如果已存在，先删除
+        if (this.cache.has(key)) {
+            this.cache.delete(key);
+        }
+        // 如果缓存已满，删除最旧的项
+        else if (this.cache.size >= this.capacity) {
+            this.cache.delete(this.cache.keys().next().value);
+        }
+        // 添加新项
+        this.cache.set(key, value);
+    }
+    /**
+     * 检查键是否存在
+     * @param key 键
+     * @returns 是否存在
+     */
+    has(key) {
+        return this.cache.has(key);
+    }
+    /**
+     * 删除缓存项
+     * @param key 键
+     * @returns 是否成功删除
+     */
+    delete(key) {
+        return this.cache.delete(key);
+    }
+    /**
+     * 清空缓存
+     */
+    clear() {
+        this.cache.clear();
+    }
+    /**
+     * 获取缓存大小
+     */
+    get size() {
+        return this.cache.size;
+    }
+    /**
+     * 获取所有键
+     */
+    keys() {
+        return this.cache.keys();
+    }
+    /**
+     * 获取所有值
+     */
+    values() {
+        return this.cache.values();
+    }
+    /**
+     * 获取所有项
+     */
+    entries() {
+        return this.cache.entries();
+    }
+}
+/**
+ * 计算图像指纹
+ * @param imageData 图像数据
+ * @returns 图像指纹
+ */
+function calculateImageFingerprint(imageData) {
+    const { width, height, data } = imageData;
+    // 缩小图像以加快计算速度
+    const scale = Math.min(1, 32 / Math.max(width, height));
+    const scaledWidth = Math.max(8, Math.floor(width * scale));
+    const scaledHeight = Math.max(8, Math.floor(height * scale));
+    // 创建缩小的图像
+    const canvas = document.createElement('canvas');
+    const ctx = canvas.getContext('2d');
+    if (!ctx) {
+        throw new Error('无法创建Canvas上下文');
+    }
+    // 设置canvas尺寸
+    canvas.width = scaledWidth;
+    canvas.height = scaledHeight;
+    // 创建临时canvas存储原始ImageData
+    const tempCanvas = document.createElement('canvas');
+    const tempCtx = tempCanvas.getContext('2d');
+    if (!tempCtx) {
+        throw new Error('无法创建临时Canvas上下文');
+    }
+    tempCanvas.width = width;
+    tempCanvas.height = height;
+    tempCtx.putImageData(imageData, 0, 0);
+    // 绘制缩小的图像
+    ctx.drawImage(tempCanvas, 0, 0, width, height, 0, 0, scaledWidth, scaledHeight);
+    // 获取缩小的图像数据
+    const scaledImageData = ctx.getImageData(0, 0, scaledWidth, scaledHeight);
+    // 计算灰度值
+    const grayValues = new Uint8Array(scaledWidth * scaledHeight);
+    for (let i = 0; i < scaledWidth * scaledHeight; i++) {
+        const idx = i * 4;
+        grayValues[i] = Math.round(0.299 * scaledImageData.data[idx] +
+            0.587 * scaledImageData.data[idx + 1] +
+            0.114 * scaledImageData.data[idx + 2]);
+    }
+    // 计算平均值
+    let sum = 0;
+    for (let i = 0; i < grayValues.length; i++) {
+        sum += grayValues[i];
+    }
+    const avg = sum / grayValues.length;
+    // 计算哈希值
+    let hash = '';
+    for (let i = 0; i < grayValues.length; i++) {
+        hash += grayValues[i] >= avg ? '1' : '0';
+    }
+    return hash;
+}
+
+/**
+ * @file Worker工具
+ * @description 提供Web Worker相关的工具函数
+ * @module utils/worker
+ */
+/**
+ * 检查是否支持Web Worker
+ * @returns 是否支持Web Worker
+ */
+function isWorkerSupported() {
+    return typeof Worker !== 'undefined';
+}
+/**
+ * 创建Worker
+ * @param workerFunction Worker函数
+ * @returns Worker实例
+ */
+function createWorker(workerFunction) {
+    // 检查是否支持Web Worker
+    if (!isWorkerSupported()) {
+        // 回退到主线程执行
+        return {
+            postMessage: async (input) => {
+                return await Promise.resolve(workerFunction(input));
+            },
+            terminate: () => { }
+        };
+    }
+    // 将函数转换为字符串
+    const workerFunctionStr = workerFunction.toString();
+    // 创建Worker脚本
+    const workerScript = `
+    // 定义Worker函数
+    const workerFunction = ${workerFunctionStr};
+    
+    // 监听消息
+    self.addEventListener('message', async (event) => {
+      try {
+        const input = event.data;
+        const result = await workerFunction(input);
+        self.postMessage({ success: true, result });
+      } catch (error) {
+        self.postMessage({ 
+          success: false, 
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    });
+  `;
+    // 创建Blob URL
+    const blob = new Blob([workerScript], { type: 'application/javascript' });
+    const url = URL.createObjectURL(blob);
+    // 创建Worker
+    const worker = new Worker(url);
+    // 创建Promise映射
+    const promiseMap = new Map();
+    // 消息计数器
+    let messageCounter = 0;
+    // 监听Worker消息
+    worker.addEventListener('message', (event) => {
+        const { messageId, success, result, error } = event.data;
+        // 查找对应的Promise
+        const promiseHandlers = promiseMap.get(messageId);
+        if (promiseHandlers) {
+            if (success) {
+                promiseHandlers.resolve(result);
+            }
+            else {
+                promiseHandlers.reject(new Error(error));
+            }
+            // 删除Promise映射
+            promiseMap.delete(messageId);
+        }
+    });
+    // 返回Worker接口
+    return {
+        postMessage: (input) => {
+            return new Promise((resolve, reject) => {
+                // 生成消息ID
+                const messageId = messageCounter++;
+                // 保存Promise处理函数
+                promiseMap.set(messageId, { resolve, reject });
+                // 发送消息到Worker
+                worker.postMessage({ messageId, input });
+            });
+        },
+        terminate: () => {
+            // 终止Worker
+            worker.terminate();
+            // 释放Blob URL
+            URL.revokeObjectURL(url);
+            // 拒绝所有未完成的Promise
+            for (const [, { reject }] of promiseMap) {
+                reject(new Error('Worker已终止'));
+            }
+            // 清空Promise映射
+            promiseMap.clear();
+        }
+    };
+}
+
+/**
+ * @file OCR Worker
+ * @description OCR处理的Worker线程实现
+ * @module modules/id-card/ocr-worker
+ */
+/**
+ * 在Worker中处理OCR识别
+ * @param input OCR处理输入参数
+ * @returns OCR处理结果
+ */
+async function processOCRInWorker(input) {
+    const startTime = performance.now();
+    try {
+        // 导入Tesseract.js
+        const { createWorker } = await import('tesseract.js');
+        // 创建Tesseract Worker
+        const worker = createWorker({
+            logger: input.tessWorkerOptions?.logger
+        });
+        // 初始化Worker
+        await worker.load();
+        await worker.loadLanguage('chi_sim');
+        await worker.initialize('chi_sim');
+        // 设置识别参数
+        await worker.setParameters({
+            tessedit_char_whitelist: '0123456789X年月日壹贰叁肆伍陆柒捌玖拾民族汉满回维吾尔藏苗彝壮朝鲜侗瑶白土家哈尼哈萨克傣黎傈僳佤高山拉祜水东乡纳西景颇柯尔克孜达斡尔仫佬羌布朗撒拉毛南仡佬锡伯阿昌普米塔吉克怒乌孜别克俄罗斯鄂温克德昂保安裕固京塔塔尔独龙鄂伦春赫哲门巴珞巴基诺男女住址出生公民身份号码签发机关有效期省市区县乡镇街道号楼单元室ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
+            tessedit_pageseg_mode: 7, // PSM_SINGLE_LINE
+            preserve_interword_spaces: '1'
+        });
+        // 识别图像
+        const { data } = await worker.recognize(input.imageBase64);
+        // 解析身份证信息
+        const idCardInfo = parseIDCardText(data.text);
+        // 释放Worker资源
+        await worker.terminate();
+        const processingTime = performance.now() - startTime;
+        return { idCardInfo, processingTime };
+    }
+    catch (error) {
+        console.error('OCR处理错误:', error);
+        return {
+            idCardInfo: {},
+            processingTime: performance.now() - startTime
+        };
+    }
+}
+/**
+ * 解析身份证文本
+ * @param text OCR识别的文本
+ * @returns 解析后的身份证信息
+ */
+function parseIDCardText(text) {
+    const info = {};
+    // 预处理文本，清除多余空白
+    const processedText = text.replace(/\s+/g, ' ').trim();
+    // 解析身份证号码
+    const idNumberRegex = /(\d{17}[\dX])/;
+    const idNumberWithPrefixRegex = /公民身份号码[\s\:]*(\d{17}[\dX])/;
+    const basicMatch = processedText.match(idNumberRegex);
+    const prefixMatch = processedText.match(idNumberWithPrefixRegex);
+    if (prefixMatch && prefixMatch[1]) {
+        info.idNumber = prefixMatch[1];
+    }
+    else if (basicMatch && basicMatch[1]) {
+        info.idNumber = basicMatch[1];
+    }
+    // 解析姓名
+    const nameWithLabelRegex = /姓名[\s\:]*([一-龥]{2,4})/;
+    const nameMatch = processedText.match(nameWithLabelRegex);
+    if (nameMatch && nameMatch[1]) {
+        info.name = nameMatch[1].trim();
+    }
+    else {
+        // 备用方案：查找短行且内容全是汉字
+        const lines = processedText.split('\n').filter(line => line.trim());
+        for (const line of lines) {
+            if (line.length >= 2 &&
+                line.length <= 5 &&
+                /^[一-龥]+$/.test(line) &&
+                !/性别|民族|住址|公民|签发|有效/.test(line)) {
+                info.name = line.trim();
+                break;
+            }
+        }
+    }
+    // 解析性别和民族
+    const genderAndNationalityRegex = /性别[\s\:]*([男女])[\s ]*民族[\s\:]*([一-龥]+族)/;
+    const genderOnlyRegex = /性别[\s\:]*([男女])/;
+    const nationalityOnlyRegex = /民族[\s\:]*([一-龥]+族)/;
+    const genderNationalityMatch = processedText.match(genderAndNationalityRegex);
+    const genderOnlyMatch = processedText.match(genderOnlyRegex);
+    const nationalityOnlyMatch = processedText.match(nationalityOnlyRegex);
+    if (genderNationalityMatch) {
+        info.gender = genderNationalityMatch[1];
+        info.ethnicity = genderNationalityMatch[2];
+    }
+    else {
+        if (genderOnlyMatch)
+            info.gender = genderOnlyMatch[1];
+        if (nationalityOnlyMatch)
+            info.ethnicity = nationalityOnlyMatch[1];
+    }
+    // 根据内容判断身份证类型
+    if (processedText.includes('出生') || processedText.includes('公民身份号码')) {
+        info.type = IDCardType.FRONT; // 确保类型为枚举值而不是字符串
+    }
+    else if (processedText.includes('签发机关') || processedText.includes('有效期')) {
+        info.type = IDCardType.BACK; // 确保类型为枚举值而不是字符串
+    }
+    // 解析出生日期
+    const birthDateRegex1 = /出生[\s\:]*(\d{4})年(\d{1,2})月(\d{1,2})[日号]/;
+    const birthDateRegex2 = /出生[\s\:]*(\d{4})[-\/\.](\d{1,2})[-\/\.](\d{1,2})/;
+    const birthDateRegex3 = /出生日期[\s\:]*(\d{4})[-\/\.\u5e74](\d{1,2})[-\/\.\u6708](\d{1,2})[日号]?/;
+    let 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处理器
+ * @description 提供身份证OCR识别功能
+ * @module modules/id-card/ocr-processor
+ */
+/**
+ * OCR处理器类
+ *
+ * 使用Tesseract.js实现对身份证图像的OCR文字识别和信息提取功能
+ *
+ * @example
+ * ```typescript
+ * // 创建OCR处理器
+ * const ocrProcessor = new OCRProcessor();
+ *
+ * // 初始化OCR引擎
+ * await ocrProcessor.initialize();
+ *
+ * // 处理身份证图像
+ * const idInfo = await ocrProcessor.processIDCard(idCardImageData);
+ * console.log('识别到的身份证信息:', idInfo);
+ *
+ * // 使用结束后释放资源
+ * await ocrProcessor.terminate();
+ * ```
+ */
+class OCRProcessor {
+    /**
+     * 创建OCR处理器实例
+     *
+     * @param options OCR处理器选项
+     */
+    constructor(options = {}) {
+        this.worker = null; // 使用导入的 TesseractWorker 类型
+        this.ocrWorker = null;
+        this.initialized = false;
+        this.options = {
+            useWorker: isWorkerSupported(),
+            enableCache: true,
+            cacheSize: 50,
+            maxImageDimension: 1000,
+            logger: console.log,
+            ...options,
+        };
+        // 初始化缓存
+        this.resultCache = new LRUCache(this.options.cacheSize);
+    }
+    /**
+     * 初始化OCR引擎
+     *
+     * 加载Tesseract OCR引擎和中文简体语言包，并设置适合身份证识别的参数
+     *
+     * @returns {Promise<void>} 初始化完成的Promise
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        if (this.options.useWorker) {
+            // 使用自定义Worker线程处理OCR
+            this.ocrWorker = createWorker(processOCRInWorker); // 使用类型断言解决类型不兼容问题
+            this.initialized = true;
+            this.options.logger?.("OCR Worker 初始化完成");
+        }
+        else {
+            // 使用主线程处理OCR
+            this.worker = createWorker$1({
+                logger: this.options.logger,
+            });
+            await this.worker.load();
+            await this.worker.loadLanguage("chi_sim");
+            await this.worker.initialize("chi_sim");
+            await this.worker.setParameters({
+                tessedit_char_whitelist: "0123456789X年月日壹贰叁肆伍陆柒捌玖拾民族汉满回维吾尔藏苗彝壮朝鲜侗瑶白土家哈尼哈萨克傣黎傈僳佤高山拉祜水东乡纳西景颇柯尔克孜达斡尔仫佬羌布朗撒拉毛南仡佬锡伯阿昌普米塔吉克怒乌孜别克俄罗斯鄂温克德昂保安裕固京塔塔尔独龙鄂伦春赫哲门巴珞巴基诺男女住址出生公民身份号码签发机关有效期省市区县乡镇街道号楼单元室ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", // 优化字符白名单，增加常见地址字符，移除部分不常用汉字
+            });
+            // 增加一些针对性的参数，提高识别率
+            await this.worker.setParameters({
+                tessedit_pageseg_mode: 7, // PSM_SINGLE_LINE，使用数字而不是字符串
+                preserve_interword_spaces: "1", // 保留单词间的空格
+            });
+            this.initialized = true;
+            this.options.logger?.("OCR引擎初始化完成");
+        }
+    }
+    /**
+     * 处理身份证图像并提取信息
+     * @param imageData 要处理的身份证图像数据
+     * @returns 提取的身份证信息
+     */
+    async processIDCard(imageData) {
+        if (!this.initialized) {
+            await this.initialize();
+        }
+        // 计算图像指纹，用于缓存查找
+        if (this.options.enableCache) {
+            const fingerprint = calculateImageFingerprint(imageData);
+            // 检查缓存中是否有结果
+            const cachedResult = this.resultCache.get(fingerprint);
+            if (cachedResult) {
+                this.options.logger?.("使用缓存的OCR结果");
+                return cachedResult;
+            }
+        }
+        // 调整图像大小以提高性能和准确性
+        const downsampledImage = ImageProcessor.resizeImage(imageData, this.options.maxImageDimension || 1000, this.options.maxImageDimension || 1000, true // 保持宽高比
+        );
+        // 提高图像质量以获得更好的OCR结果
+        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有益
+        });
+        // 转换为base64供Tesseract处理
+        // 创建一个canvas元素
+        const canvas = document.createElement("canvas");
+        canvas.width = enhancedImage.width;
+        canvas.height = enhancedImage.height;
+        const ctx = canvas.getContext("2d");
+        if (!ctx) {
+            throw new Error("无法创建canvas上下文");
+        }
+        // 将ImageData绘制到canvas
+        ctx.putImageData(enhancedImage, 0, 0);
+        // 转换为Base64
+        const base64Image = canvas.toDataURL("image/jpeg", 0.7);
+        // OCR识别
+        try {
+            let idCardInfo;
+            if (this.options.useWorker && this.ocrWorker) {
+                // 使用Worker线程处理
+                const result = await this.ocrWorker.postMessage({
+                    imageBase64: base64Image,
+                    // 不传递函数对象，避免DataCloneError
+                    tessWorkerOptions: {},
+                });
+                idCardInfo = result.idCardInfo;
+                this.options.logger?.(`OCR处理完成，用时: ${result.processingTime.toFixed(2)}ms`);
+            }
+            else {
+                // 使用主线程处理
+                const startTime = performance.now();
+                // 转换ImageData为Canvas
+                const canvas = ImageProcessor.imageDataToCanvas(enhancedImage);
+                // 确保worker已初始化
+                if (!this.worker) {
+                    throw new Error("OCR引擎未初始化");
+                }
+                const { data } = (await this.worker.recognize(canvas));
+                // 解析身份证信息
+                idCardInfo = this.parseIDCardText(data.text);
+                const processingTime = performance.now() - startTime;
+                this.options.logger?.(`OCR处理完成，用时: ${processingTime.toFixed(2)}ms`);
+            }
+            // 缓存结果
+            if (this.options.enableCache) {
+                const fingerprint = calculateImageFingerprint(imageData);
+                this.resultCache.set(fingerprint, idCardInfo);
+            }
+            return idCardInfo;
+        }
+        catch (error) {
+            // 改进错误处理
+            const errorMessage = error instanceof Error
+                ? error.message
+                : typeof error === 'object'
+                    ? JSON.stringify(error)
+                    : String(error);
+            this.options.logger?.(`OCR识别错误: ${errorMessage}`);
+            // 返回空对象，避免完全失败
+            return {};
+        }
+    }
+    /**
+     * 解析身份证文本信息
+     *
+     * 从OCR识别到的文本中提取结构化的身份证信息
+     *
+     * @private
+     * @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;
+    }
+    /**
+     * 清除结果缓存
+     */
+    clearCache() {
+        this.resultCache.clear();
+        this.options.logger?.("OCR结果缓存已清除");
+    }
+    /**
+     * 终止OCR引擎并释放资源
+     *
+     * @returns {Promise<void>} 终止完成的Promise
+     */
+    async terminate() {
+        if (this.worker) {
+            await this.worker.terminate();
+            this.worker = null;
+        }
+        if (this.ocrWorker) {
+            this.ocrWorker.terminate();
+            this.ocrWorker = null;
+        }
+        this.initialized = false;
+        this.options.logger?.("OCR引擎已终止");
+    }
+    /**
+     * 释放资源
+     */
+    dispose() {
+        return this.terminate();
+    }
+}
+
+/**
+ * @file 身份证防伪检测模块
+ * @description 提供身份证防伪特征识别功能，区分真假身份证
+ * @module AntiFakeDetector
+ * @version 1.3.2
+ */
+/**
+ * 身份证防伪特征检测器
+ *
+ * 基于图像分析技术检测身份证中的多种防伪特征，包括：
+ * 1. 荧光油墨特征
+ * 2. 微缩文字
+ * 3. 光变图案
+ * 4. 雕刻凹印
+ * 5. 隐形图案
+ *
+ * @example
+ * ```typescript
+ * // 创建防伪检测器
+ * const antiFakeDetector = new AntiFakeDetector({
+ *   sensitivity: 0.8,
+ *   enableCache: true
+ * });
+ *
+ * // 分析身份证图像
+ * const imageData = await ImageProcessor.createImageDataFromFile(idCardFile);
+ * const result = await antiFakeDetector.detect(imageData);
+ *
+ * if (result.isAuthentic) {
+ *   console.log('身份证真实，检测到防伪特征:', result.detectedFeatures);
+ * } else {
+ *   console.log('警告!', result.message);
+ * }
+ * ```
+ */
+class AntiFakeDetector {
+    /**
+     * 创建身份证防伪检测器实例
+     *
+     * @param options 防伪检测器配置
+     */
+    constructor(options = {}) {
+        this.options = {
+            sensitivity: 0.7,
+            enableCache: true,
+            cacheSize: 50,
+            logger: console.log,
+            ...options,
+        };
+        // 初始化缓存
+        this.resultCache = new LRUCache(this.options.cacheSize);
+    }
+    /**
+     * 检测身份证图像的防伪特征
+     *
+     * @param imageData 身份证图像数据
+     * @returns 防伪检测结果
+     */
+    async detect(imageData) {
+        const startTime = performance.now();
+        // 检查缓存
+        if (this.options.enableCache) {
+            const fingerprint = calculateImageFingerprint(imageData);
+            const cachedResult = this.resultCache.get(fingerprint);
+            if (cachedResult) {
+                this.options.logger("使用缓存的防伪检测结果");
+                return cachedResult;
+            }
+        }
+        // 图像预处理增强防伪特征
+        const enhancedImage = this.enhanceAntiFakeFeatures(imageData);
+        // 执行多种防伪特征检测
+        const featureResults = await Promise.all([
+            this.detectUVInkFeatures(enhancedImage),
+            this.detectMicroText(enhancedImage),
+            this.detectOpticalVariable(enhancedImage),
+            this.detectIntaglioPrinting(enhancedImage),
+            this.detectGhostImage(enhancedImage),
+        ]);
+        // 汇总检测结果
+        const detectedFeatures = [];
+        let totalConfidence = 0;
+        for (const [feature, detected, confidence] of featureResults) {
+            if (detected && confidence > 0.5) {
+                detectedFeatures.push(feature);
+                totalConfidence += confidence;
+            }
+        }
+        // 计算最终结果
+        const normalizedConfidence = featureResults.length > 0 ? totalConfidence / featureResults.length : 0;
+        // 根据敏感度和检测到的特征决定是否通过验证
+        const isAuthentic = normalizedConfidence >= this.options.sensitivity &&
+            detectedFeatures.length >= 2;
+        // 生成结果消息
+        let message = isAuthentic
+            ? `身份证真实，检测到${detectedFeatures.length}个防伪特征`
+            : detectedFeatures.length > 0
+                ? `可疑身份证，仅检测到${detectedFeatures.length}个防伪特征，置信度不足`
+                : "未检测到有效防伪特征，可能为伪造证件";
+        const result = {
+            isAuthentic,
+            confidence: normalizedConfidence,
+            detectedFeatures,
+            message,
+            processingTime: performance.now() - startTime,
+        };
+        // 缓存结果
+        if (this.options.enableCache) {
+            const fingerprint = calculateImageFingerprint(imageData);
+            this.resultCache.set(fingerprint, result);
+        }
+        return result;
+    }
+    /**
+     * 增强身份证图像中的防伪特征
+     *
+     * @param imageData 原始图像数据
+     * @returns 增强后的图像数据
+     * @private
+     */
+    enhanceAntiFakeFeatures(imageData) {
+        // 应用特定的图像处理增强防伪特征
+        return ImageProcessor.batchProcess(imageData, {
+            contrast: 30, // 增强对比度
+            brightness: 10, // 轻微提高亮度
+            sharpen: true, // 锐化图像突出细节
+        });
+    }
+    /**
+     * 检测荧光油墨特征
+     *
+     * @param imageData 图像数据
+     * @returns [特征名称, 是否检测到, 置信度]
+     * @private
+     */
+    async detectUVInkFeatures(imageData) {
+        // 在真实身份证上，荧光油墨会在特定反光条件下呈现特定颜色特征
+        // 在普通可见光下，我们分析蓝色和紫外色通道分布特征
+        // 1. 提取蓝色通道并增强对比度
+        const blueChannel = this.extractColorChannel(imageData, "blue");
+        // 2. 分析蓝色通道的分布特征
+        const { peaks, variance } = this.analyzeChannelDistribution(blueChannel);
+        // 3. 分析特定区域的颜色模式
+        const patternScore = this.detectUVColorPattern(imageData);
+        // 4. 计算综合得分
+        // 特征分析：荧光油墨在蓝色通道通常有显著峰值，且分布更聚集
+        let score = 0;
+        // 过多的峰值表明可能是真实身份证上的荧光特征
+        if (peaks > 3 && peaks < 10) {
+            score += 0.4;
+        }
+        // 方差越大，表示颜色对比度越高，更可能有荧光特征
+        if (variance > 1000) {
+            score += 0.3;
+        }
+        // 颜色模式得分
+        score += patternScore * 0.3;
+        // 重要区域分析
+        // 身份证头像区域通常不应具有荧光特征
+        const hasPortraitAreaFeatures = this.analyzePortraitArea(imageData);
+        if (hasPortraitAreaFeatures) {
+            // 头像区域不应该有荧光特征，如果有可能是伪造的
+            score -= 0.2;
+        }
+        // 求出最终分数并限制在[0,1]范围内
+        const confidence = Math.max(0, Math.min(1, score));
+        const detected = confidence > 0.55;
+        return ["荧光油墨", detected, confidence];
+    }
+    /**
+     * 从图像数据中提取指定颜色通道
+     * @param imageData 原始图像数据
+     * @param channel 通道名称（red, green, blue）
+     */
+    extractColorChannel(imageData, channel) {
+        const { data, width, height } = imageData;
+        const channelOffset = channel === "red" ? 0 : channel === "green" ? 1 : 2;
+        const channelData = new Uint8ClampedArray(width * height);
+        for (let i = 0; i < data.length; i += 4) {
+            const pixelIndex = i / 4;
+            channelData[pixelIndex] = data[i + channelOffset];
+        }
+        return channelData;
+    }
+    /**
+     * 分析颜色通道分布特征
+     * @param channelData 颜色通道数据
+     */
+    analyzeChannelDistribution(channelData) {
+        // 计算直方图
+        const histogram = new Array(256).fill(0);
+        for (let i = 0; i < channelData.length; i++) {
+            histogram[channelData[i]]++;
+        }
+        // 平滑直方图以减少噪声
+        const smoothedHistogram = this.smoothHistogram(histogram, 3);
+        // 计算峰值数量
+        let peaks = 0;
+        for (let i = 1; i < 255; i++) {
+            if (smoothedHistogram[i] > smoothedHistogram[i - 1] &&
+                smoothedHistogram[i] > smoothedHistogram[i + 1] &&
+                smoothedHistogram[i] > channelData.length * 0.01) {
+                // 只计算显著峰值
+                peaks++;
+            }
+        }
+        // 计算方差
+        let mean = 0;
+        for (let i = 0; i < channelData.length; i++) {
+            mean += channelData[i];
+        }
+        mean /= channelData.length;
+        let variance = 0;
+        for (let i = 0; i < channelData.length; i++) {
+            variance += Math.pow(channelData[i] - mean, 2);
+        }
+        variance /= channelData.length;
+        return { peaks, variance };
+    }
+    /**
+     * 平滑直方图以减少噪声
+     */
+    smoothHistogram(histogram, windowSize) {
+        const result = new Array(histogram.length).fill(0);
+        const halfWindow = Math.floor(windowSize / 2);
+        for (let i = 0; i < histogram.length; i++) {
+            let sum = 0;
+            let count = 0;
+            for (let j = Math.max(0, i - halfWindow); j <= Math.min(histogram.length - 1, i + halfWindow); j++) {
+                sum += histogram[j];
+                count++;
+            }
+            result[i] = sum / count;
+        }
+        return result;
+    }
+    /**
+     * 检测图像中的荧光颜色模式
+     */
+    detectUVColorPattern(imageData) {
+        // 分析特定组合颜色的出现频率，荧光油墨在可见光下也有特定的颜色特征
+        const { data, width, height } = imageData;
+        let uvColorCount = 0;
+        // 寻找可能为荧光油墨的特定颜色模式
+        // 这些颜色通常是特定的蓝紫色调和高对比度
+        for (let i = 0; i < data.length; i += 4) {
+            const r = data[i];
+            const g = data[i + 1];
+            const b = data[i + 2];
+            // 检查是否是荧光油墨特有的颜色范围
+            // 这里使用简化的追踪条件，实际应用中应使用更复杂的颜色模型
+            if (b > 1.5 * r && b > 1.3 * g && b > 100) {
+                uvColorCount++;
+            }
+        }
+        // 计算荧光颜色像素占比
+        const totalPixels = width * height;
+        const uvColorRatio = uvColorCount / totalPixels;
+        // 对于真实身份证，荧光颜色的占比应该在一定范围内
+        // 如果占比过高或过低，可能是伪造的
+        const idealRatio = 0.05; // 理想占比
+        const deviation = Math.abs(uvColorRatio - idealRatio) / idealRatio;
+        // 将差异转换为0-1的置信度分数
+        return Math.max(0, 1 - Math.min(1, deviation * 2));
+    }
+    /**
+     * 分析头像区域是否存在荧光特征
+     * 这个方法用于检测伪造的身份证，因为头像区域不应该有荧光特征
+     */
+    analyzePortraitArea(imageData) {
+        // 假设头像区域大约占据图片右上方四分之一的区域
+        const { width, height, data } = imageData;
+        const portraitX = Math.floor(width * 0.6);
+        const portraitY = Math.floor(height * 0.2);
+        const portraitWidth = Math.floor(width * 0.3);
+        const portraitHeight = Math.floor(height * 0.3);
+        let uvFeatureCount = 0;
+        let totalPixels = 0;
+        // 检查头像区域的荧光特征
+        for (let y = portraitY; y < portraitY + portraitHeight; y++) {
+            for (let x = portraitX; x < portraitX + portraitWidth; x++) {
+                if (x >= 0 && x < width && y >= 0 && y < height) {
+                    const i = (y * width + x) * 4;
+                    const r = data[i];
+                    const g = data[i + 1];
+                    const b = data[i + 2];
+                    // 使用与上面相同的荧光颜色检测标准
+                    if (b > 1.5 * r && b > 1.3 * g && b > 100) {
+                        uvFeatureCount++;
+                    }
+                    totalPixels++;
+                }
+            }
+        }
+        // 如果头像区域的荧光特征占比过高，可能是伪造的
+        return totalPixels > 0 && uvFeatureCount / totalPixels > 0.1;
+    }
+    /**
+     * 检测微缩文字
+     *
+     * @param imageData 图像数据
+     * @returns [特征名称, 是否检测到, 置信度]
+     * @private
+     */
+    async detectMicroText(imageData) {
+        // 微缩文字检测 - 身份证上的微缩文字是重要的防伪特征
+        // 这些文字很小，但会呈现规则的线条和高频组件
+        // 1. 转换图像为灰度图
+        const grayscale = ImageProcessor.toGrayscale(new ImageData(new Uint8ClampedArray(imageData.data), imageData.width, imageData.height));
+        // 2. 执行边缘检测突出微缩文字
+        const edgeData = ImageProcessor.detectEdges(grayscale, 40); // 强化的边缘检测
+        // 3. 分析频率特征 - 微缩文字呈现高频的边缘过渡
+        const frequencyFeatures = this.analyzeFrequencyFeatures(edgeData);
+        // 4. 检测微缩文字的具体区域
+        const microTextRegions = this.detectMicroTextRegions(edgeData);
+        // 5. 综合分析结果计算置信度
+        let score = 0;
+        // 频率特征分数
+        score += frequencyFeatures.score * 0.6;
+        // 区域特征分数
+        if (microTextRegions.count > 0) {
+            // 过多的区域也可能表示噪声，因此有一个最佳范围
+            const normalizedCount = Math.min(microTextRegions.count, 5) / 5;
+            score += normalizedCount * 0.4;
+        }
+        // 对置信度进行最终调整
+        const confidence = Math.max(0, Math.min(1, score));
+        const detected = confidence > 0.5;
+        return ["微缩文字", detected, confidence];
+    }
+    /**
+     * 分析边缘图像的频率特征
+     * 微缩文字呈现高频的边缘过渡
+     */
+    analyzeFrequencyFeatures(edgeData) {
+        const { data, width, height } = edgeData;
+        // 计算边缘像素的数量
+        for (let i = 0; i < data.length; i += 4) {
+            if (data[i] > 200) ;
+        }
+        // 计算高频边缘分布
+        // 统计边缘过渡的变化频率
+        let highFreqTransitions = 0;
+        // 检测行方向的边缘变化
+        for (let y = 0; y < height; y++) {
+            let prevEdge = false;
+            let transitions = 0;
+            for (let x = 0; x < width; x++) {
+                const i = (y * width + x) * 4;
+                const isEdge = data[i] > 200;
+                if (isEdge !== prevEdge) {
+                    transitions++;
+                    prevEdge = isEdge;
+                }
+            }
+            // 每行的过渡频率
+            if (transitions > width * 0.1) {
+                // 高频过渡行
+                highFreqTransitions++;
+            }
+        }
+        // 计算列方向的边缘变化
+        let colHighFreqTransitions = 0;
+        for (let x = 0; x < width; x++) {
+            let prevEdge = false;
+            let transitions = 0;
+            for (let y = 0; y < height; y++) {
+                const i = (y * width + x) * 4;
+                const isEdge = data[i] > 200;
+                if (isEdge !== prevEdge) {
+                    transitions++;
+                    prevEdge = isEdge;
+                }
+            }
+            // 每列的过渡频率
+            if (transitions > height * 0.1) {
+                // 高频过渡列
+                colHighFreqTransitions++;
+            }
+        }
+        // 综合计算高频特征比例
+        const rowHighFreqRatio = highFreqTransitions / height;
+        const colHighFreqRatio = colHighFreqTransitions / width;
+        const highFreqRatio = (rowHighFreqRatio + colHighFreqRatio) / 2;
+        // 计算最终分数
+        // 真实的微缩文字应该有适度的高频特征，而不是极端的高或低
+        const idealRatio = 0.15; // 理想的高频比例
+        const deviationFactor = Math.abs(highFreqRatio - idealRatio) / idealRatio;
+        const score = Math.max(0, 1 - Math.min(1, deviationFactor * 3));
+        return { score, highFreqRatio };
+    }
+    /**
+     * 检测微缩文字区域
+     * 微缩文字通常呈现呈现规则的组合排列
+     */
+    detectMicroTextRegions(edgeData) {
+        const { data, width, height } = edgeData;
+        const visitedMap = new Array(width * height).fill(false);
+        const regions = [];
+        // 使用满足条件的连通区域寻找微缩文字区域
+        for (let y = 0; y < height; y++) {
+            for (let x = 0; x < width; x++) {
+                const idx = y * width + x;
+                const i = idx * 4;
+                // 如果是边缘像素且未访问过
+                if (data[i] > 200 && !visitedMap[idx]) {
+                    // 使用深度优先搜索找到连通的边缘区域
+                    const regionPoints = this.floodFillEdge(edgeData, x, y, visitedMap);
+                    // 分析区域
+                    if (regionPoints.length > 10) {
+                        // 小区域忽略
+                        const [minX, minY, maxX, maxY] = this.getBoundingBox(regionPoints);
+                        const regionWidth = maxX - minX + 1;
+                        const regionHeight = maxY - minY + 1;
+                        // 检查区域大小和纹理特征
+                        if (regionWidth > 5 &&
+                            regionHeight > 5 &&
+                            regionWidth < width * 0.2 &&
+                            regionHeight < height * 0.2) {
+                            // 计算区域密度
+                            const density = regionPoints.length / (regionWidth * regionHeight);
+                            // 检查并添加符合微缩文字特征的区域
+                            if (density > 0.1 && density < 0.5) {
+                                // 合适的密度范围
+                                regions.push({
+                                    x: minX,
+                                    y: minY,
+                                    w: regionWidth,
+                                    h: regionHeight,
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return { count: regions.length, regions };
+    }
+    /**
+     * 深度优先搜索连通的边缘区域
+     */
+    floodFillEdge(edgeData, startX, startY, visitedMap) {
+        const { data, width, height } = edgeData;
+        const stack = [];
+        const points = [];
+        const dx = [-1, 0, 1, -1, 1, -1, 0, 1];
+        const dy = [-1, -1, -1, 0, 0, 1, 1, 1];
+        // 起始点
+        stack.push({ x: startX, y: startY });
+        visitedMap[startY * width + startX] = true;
+        while (stack.length > 0) {
+            const { x, y } = stack.pop();
+            points.push({ x, y });
+            // 检查88个相邻方向
+            for (let i = 0; i < 8; i++) {
+                const nx = x + dx[i];
+                const ny = y + dy[i];
+                if (nx >= 0 && nx < width && ny >= 0 && ny < height) {
+                    const nidx = ny * width + nx;
+                    const ni = nidx * 4;
+                    if (data[ni] > 200 && !visitedMap[nidx]) {
+                        stack.push({ x: nx, y: ny });
+                        visitedMap[nidx] = true;
+                    }
+                }
+            }
+        }
+        return points;
+    }
+    /**
+     * 获取点集的外接矩形
+     */
+    getBoundingBox(points) {
+        let minX = Number.MAX_SAFE_INTEGER;
+        let minY = Number.MAX_SAFE_INTEGER;
+        let maxX = 0;
+        let maxY = 0;
+        for (const { x, y } of points) {
+            minX = Math.min(minX, x);
+            minY = Math.min(minY, y);
+            maxX = Math.max(maxX, x);
+            maxY = Math.max(maxY, y);
+        }
+        return [minX, minY, maxX, maxY];
+    }
+    /**
+     * 检测光变图案
+     *
+     * @param imageData 图像数据
+     * @returns [特征名称, 是否检测到, 置信度]
+     * @private
+     */
+    async detectOpticalVariable(imageData) {
+        // 提取特定区域并分析颜色变化
+        // 在实际实现中需要定位光变图案区域并分析其特征
+        // 这里使用模拟实现
+        // 模拟检测: 65%的概率检测到，置信度0.6-0.9
+        const detected = Math.random() > 0.35;
+        const confidence = detected ? 0.6 + Math.random() * 0.3 : 0;
+        return ["光变图案", detected, confidence];
+    }
+    /**
+     * 检测凹印雕刻特征
+     *
+     * @param imageData 图像数据
+     * @returns [特征名称, 是否检测到, 置信度]
+     * @private
+     */
+    async detectIntaglioPrinting(imageData) {
+        // 使用特定滤镜增强凹印效果
+        // 在实际实现中应分析阴影和纹理模式
+        // 这里使用模拟实现
+        // 模拟检测: 75%的概率检测到，置信度0.65-0.9
+        const detected = Math.random() > 0.25;
+        const confidence = detected ? 0.65 + Math.random() * 0.25 : 0;
+        return ["雕刻凹印", detected, confidence];
+    }
+    /**
+     * 检测隐形图案(幽灵图像)
+     *
+     * @param imageData 图像数据
+     * @returns [特征名称, 是否检测到, 置信度]
+     * @private
+     */
+    async detectGhostImage(imageData) {
+        // 调整对比度和亮度显现隐形图案
+        // 在实际实现中应使用特定滤镜和图像处理算法
+        // 这里使用模拟实现
+        // 模拟检测: 60%的概率检测到，置信度0.55-0.85
+        const detected = Math.random() > 0.4;
+        const confidence = detected ? 0.55 + Math.random() * 0.3 : 0;
+        return ["隐形图案", detected, confidence];
+    }
+    /**
+     * 清除结果缓存
+     */
+    clearCache() {
+        this.resultCache.clear();
+        this.options.logger("防伪检测结果缓存已清除");
+    }
+    /**
+     * 释放资源
+     */
+    dispose() {
+        this.resultCache.clear();
+    }
+}
+
+/**
+ * @file 身份证模块入口
+ * @description 提供身份证识别和验证功能的模块入口
+ * @module modules/id-card
+ */
+/**
+ * 身份证识别模块
+ * 提供身份证检测、OCR识别、防伪检测等功能
+ */
+class IDCardModule extends BaseModule {
+    /**
+     * 构造函数
+     * @param options 模块配置选项
+     */
+    constructor(options = {}) {
+        super();
+        /** 模块名称 */
+        this.name = 'id-card';
+        this.options = {
+            enabled: true,
+            detector: {
+                minConfidence: 0.7,
+                enableOCR: true,
+                enableAntiFake: false,
+                ...options.detector
+            },
+            ocr: {
+                useWorker: true,
+                maxImageDimension: 1000,
+                brightness: 10,
+                contrast: 20,
+                ...options.ocr
+            },
+            antiFake: {
+                sensitivity: 0.8,
+                minConfidence: 0.7,
+                ...options.antiFake
+            },
+            ...options
+        };
+        // 创建检测器
+        this.detector = new IDCardDetector({
+            minConfidence: this.options.detector?.minConfidence,
+            enableEdgeDetection: true,
+            returnImage: true
+        });
+    }
+    /**
+     * 初始化模块
+     */
+    async initialize() {
+        if (this._isInitialized) {
+            return;
+        }
+        this.logger.debug(this.name, '初始化身份证模块');
+        try {
+            // 初始化检测器
+            await this.detector.initialize();
+            // 如果启用OCR，初始化OCR处理器
+            if (this.options.detector?.enableOCR) {
+                this.ocrProcessor = new OCRProcessor({
+                    useWorker: this.options.ocr?.useWorker,
+                    maxImageDimension: this.options.ocr?.maxImageDimension,
+                    brightness: this.options.ocr?.brightness,
+                    contrast: this.options.ocr?.contrast
+                });
+                await this.ocrProcessor.initialize();
+            }
+            // 如果启用防伪检测，初始化防伪检测器
+            if (this.options.detector?.enableAntiFake) {
+                this.antiFakeDetector = new AntiFakeDetector({
+                    sensitivity: this.options.antiFake?.sensitivity
+                });
+                // AntiFakeDetector 不需要初始化
+            }
+            this._isInitialized = true;
+            this.emit('initialized');
+            this.logger.debug(this.name, '身份证模块初始化完成');
+        }
+        catch (error) {
+            this.logger.error(this.name, '身份证模块初始化失败', error instanceof Error ? error : new Error(String(error)));
+            throw new Error(`身份证模块初始化失败: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * 识别身份证图像
+     * @param image 图像源
+     * @returns 识别结果
+     */
+    async recognize(image) {
+        this.ensureInitialized();
+        try {
+            // 检测身份证
+            const detectionResult = await this.detector.processImage(image);
+            if (!detectionResult.isSuccess() || !detectionResult.data) {
+                throw new Error('未检测到身份证');
+            }
+            // 创建结果对象
+            const idCardInfo = {
+                type: detectionResult.data.type || IDCardType.FRONT,
+                confidence: detectionResult.data.confidence
+            };
+            // 如果启用OCR且OCR处理器已初始化
+            if (this.options.detector?.enableOCR && this.ocrProcessor) {
+                // 裁剪并处理图像
+                const processedImage = detectionResult.data.image || this.convertToImageData(image);
+                // 识别文本信息
+                const ocrResult = await this.ocrProcessor.processIDCard(processedImage);
+                // 合并OCR结果
+                Object.assign(idCardInfo, ocrResult);
+            }
+            // 如果启用防伪检测且防伪检测器已初始化
+            if (this.options.detector?.enableAntiFake && this.antiFakeDetector) {
+                const processedImage = this.convertToImageData(image);
+                const antiFakeResult = await this.antiFakeDetector.detect(processedImage);
+                // 转换防伪检测结果格式
+                idCardInfo.antiFake = {
+                    passed: antiFakeResult.isAuthentic,
+                    score: antiFakeResult.confidence,
+                    features: {
+                        // 转换检测到的特征
+                        fluorescent: antiFakeResult.detectedFeatures.includes('荧光油墨特征'),
+                        microtext: antiFakeResult.detectedFeatures.includes('微缩文字'),
+                        opticalVariable: antiFakeResult.detectedFeatures.includes('光变图案'),
+                        texture: antiFakeResult.detectedFeatures.includes('雕刻凹印'),
+                        watermark: antiFakeResult.detectedFeatures.includes('隐形图案')
+                    }
+                };
+            }
+            // 保存最后一次检测结果
+            this.lastDetectionResult = idCardInfo;
+            // 触发事件
+            this.emit('recognized', { idCardInfo });
+            return idCardInfo;
+        }
+        catch (error) {
+            this.logger.error(this.name, '身份证识别失败', error instanceof Error ? error : new Error(String(error)));
+            throw new Error(`身份证识别失败: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * 验证身份证信息
+     * @param idCardInfo 身份证信息
+     * @returns 验证结果
+     */
+    verify(idCardInfo) {
+        this.ensureInitialized();
+        const result = {
+            isValid: true,
+            score: 1.0,
+            details: {
+                idNumberValid: true,
+                issueDateValid: true,
+                isExpired: false,
+                antiFakePassed: true
+            }
+        };
+        // 验证身份证号码
+        if (idCardInfo.idNumber) {
+            result.details.idNumberValid = this.validateIDNumber(idCardInfo.idNumber);
+            if (!result.details.idNumberValid) {
+                result.isValid = false;
+                result.score -= 0.3;
+                result.failureReason = '身份证号码无效';
+            }
+        }
+        // 验证有效期
+        if (idCardInfo.validTo) {
+            result.details.isExpired = this.isIDCardExpired(idCardInfo.validTo);
+            if (result.details.isExpired) {
+                result.isValid = false;
+                result.score -= 0.2;
+                result.failureReason = '身份证已过期';
+            }
+        }
+        // 验证防伪结果
+        if (idCardInfo.antiFake) {
+            result.details.antiFakePassed = idCardInfo.antiFake.passed;
+            if (!result.details.antiFakePassed) {
+                result.isValid = false;
+                result.score -= 0.5;
+                result.failureReason = '防伪检测未通过';
+            }
+        }
+        return result;
+    }
+    /**
+     * 获取最后一次识别结果
+     */
+    getLastRecognitionResult() {
+        return this.lastDetectionResult;
+    }
+    /**
+     * 释放模块资源
+     */
+    async dispose() {
+        if (!this._isInitialized) {
+            return;
+        }
+        this.logger.debug(this.name, '释放身份证模块资源');
+        try {
+            // 释放检测器资源
+            await this.detector.dispose();
+            // 释放OCR处理器资源
+            if (this.ocrProcessor) {
+                await this.ocrProcessor.terminate();
+            }
+            // 释放防伪检测器资源
+            if (this.antiFakeDetector) {
+                await this.antiFakeDetector.dispose();
+            }
+            // 调用基类的dispose方法
+            await super.dispose();
+        }
+        catch (error) {
+            this.logger.error(this.name, '身份证模块资源释放失败', error instanceof Error ? error : new Error(String(error)));
+            throw new Error(`身份证模块资源释放失败: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * 验证身份证号码是否有效
+     * @param idNumber 身份证号码
+     * @returns 是否有效
+     */
+    validateIDNumber(idNumber) {
+        // 基本格式验证
+        if (!idNumber || !/^\d{17}[\dX]$/.test(idNumber)) {
+            return false;
+        }
+        // 验证出生日期
+        const year = parseInt(idNumber.substring(6, 10));
+        const month = parseInt(idNumber.substring(10, 12));
+        const day = parseInt(idNumber.substring(12, 14));
+        if (year < 1900 || year > new Date().getFullYear() ||
+            month < 1 || month > 12 ||
+            day < 1 || day > 31) {
+            return false;
+        }
+        // 验证校验位
+        const weights = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2];
+        const validationCodes = ['1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2'];
+        let sum = 0;
+        for (let i = 0; i < 17; i++) {
+            sum += parseInt(idNumber[i]) * weights[i];
+        }
+        const validationCode = validationCodes[sum % 11];
+        return validationCode === idNumber[17].toUpperCase();
+    }
+    /**
+     * 检查身份证是否过期
+     * @param validTo 有效期截止日期
+     * @returns 是否过期
+     */
+    isIDCardExpired(validTo) {
+        // 如果是"长期"，则视为未过期
+        if (validTo === '长期' || validTo === '长期有效') {
+            return false;
+        }
+        try {
+            // 解析日期字符串
+            const parts = validTo.split('-');
+            if (parts.length !== 3) {
+                return true; // 格式错误，视为过期
+            }
+            const year = parseInt(parts[0]);
+            const month = parseInt(parts[1]) - 1; // 月份从0开始
+            const day = parseInt(parts[2]);
+            const expiryDate = new Date(year, month, day);
+            const today = new Date();
+            // 设置时间为当天结束
+            today.setHours(0, 0, 0, 0);
+            return expiryDate < today;
+        }
+        catch {
+            return true; // 解析错误，视为过期
+        }
+    }
+    /**
+     * 检测身份证
+     * @param image 图像源
+     * @returns 检测结果
+     */
+    async detect(image) {
+        this.ensureInitialized();
+        try {
+            // 调用检测器处理图像
+            const result = await this.detector.processImage(image);
+            if (!result.isSuccess() || !result.data) {
+                return { success: false, confidence: 0 };
+            }
+            return {
+                success: true,
+                type: result.data.type,
+                confidence: result.data.confidence || 0,
+                croppedImage: result.data.image
+            };
+        }
+        catch (error) {
+            this.logger.error(this.name, '身份证检测失败', error instanceof Error ? error : new Error(String(error)));
+            return { success: false, confidence: 0 };
+        }
+    }
+    /**
+     * 将图像转换为 ImageData
+     * @param image 图像源
+     * @returns ImageData 对象
+     */
+    convertToImageData(image) {
+        // 如果已经是 ImageData，直接返回
+        if (image instanceof ImageData) {
+            return image;
+        }
+        // 创建 Canvas 用于转换
+        const canvas = document.createElement('canvas');
+        const width = image instanceof HTMLImageElement ? image.naturalWidth : image.width;
+        const height = image instanceof HTMLImageElement ? image.naturalHeight : image.height;
+        canvas.width = width;
+        canvas.height = height;
+        const ctx = canvas.getContext('2d');
+        if (!ctx) {
+            throw new Error('无法创建 Canvas 上下文');
+        }
+        // 绘制图像到 Canvas
+        ctx.drawImage(image, 0, 0);
+        // 返回 ImageData
+        return ctx.getImageData(0, 0, width, height);
+    }
+    /**
+     * 确保模块已初始化
+     * @protected
+     */
+    ensureInitialized() {
+        if (!this._isInitialized) {
+            throw new Error('身份证模块尚未初始化');
+        }
+    }
+}
+
+/**
+ * @file 二维码扫描器
+ * @description 提供二维码检测和解析功能
+ * @module modules/qrcode/qr-code-scanner
+ */
+/**
+ * 二维码扫描器类
+ */
+class QRCodeScanner extends EventEmitter {
+    /**
+     * 构造函数
+     * @param options 配置选项
+     */
+    constructor(options = {}) {
+        super();
+        this.initialized = false;
+        this.options = {
+            minConfidence: 0.6,
+            returnImage: false,
+            imageProcess: {
+                preprocess: true,
+                enhanceContrast: true,
+                threshold: 128,
+                ...options.imageProcess
+            },
+            ...options
+        };
+        this.logger = Logger.getInstance();
+    }
+    /**
+     * 初始化扫描器
+     */
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        this.logger.debug('QRCodeScanner', '初始化二维码扫描器');
+        // 验证jsQR是否可用
+        if (typeof jsQR !== 'function') {
+            throw new Error('jsQR库未加载，请确保已安装jsqr依赖');
+        }
+        this.initialized = true;
+        this.logger.debug('QRCodeScanner', '二维码扫描器初始化完成');
+    }
+    /**
+     * 扫描图像中的二维码
+     * @param image 图像源
+     * @returns 二维码扫描结果
+     */
+    async scan(image) {
+        if (!this.initialized) {
+            await this.initialize();
+        }
+        // 将输入转换为ImageData
+        const imageData = this.getImageData(image);
+        // 图像预处理
+        const processedImage = this.options.imageProcess?.preprocess
+            ? this.preprocessImage(imageData)
+            : imageData;
+        // 使用jsQR进行扫描
+        const code = jsQR(processedImage.data, processedImage.width, processedImage.height, {
+            inversionAttempts: 'dontInvert'
+        });
+        if (!code) {
+            return undefined;
+        }
+        // 构建结果
+        const result = {
+            data: code.data,
+            boundingBox: {
+                topLeft: code.location.topLeftCorner,
+                topRight: code.location.topRightCorner,
+                bottomRight: code.location.bottomRightCorner,
+                bottomLeft: code.location.bottomLeftCorner
+            },
+            center: {
+                x: Math.round((code.location.topLeftCorner.x + code.location.bottomRightCorner.x) / 2),
+                y: Math.round((code.location.topLeftCorner.y + code.location.bottomRightCorner.y) / 2)
+            },
+            confidence: 1.0 // jsQR不提供置信度，默认为1.0
+        };
+        // 如果需要返回原始图像
+        if (this.options.returnImage) {
+            result.image = imageData;
+        }
+        this.logger.debug('QRCodeScanner', `扫描到二维码: ${result.data.substring(0, 20)}${result.data.length > 20 ? '...' : ''}`);
+        return result;
+    }
+    /**
+     * 将各种图像源转换为ImageData
+     * @param image 图像源
+     * @returns ImageData
+     */
+    getImageData(image) {
+        // 如果已经是ImageData，直接返回
+        if (image instanceof ImageData) {
+            return image;
+        }
+        // 创建canvas并获取2D上下文
+        const canvas = document.createElement('canvas');
+        const ctx = canvas.getContext('2d');
+        if (!ctx) {
+            throw new Error('无法创建Canvas上下文');
+        }
+        // 设置canvas尺寸
+        canvas.width = image.width;
+        canvas.height = image.height;
+        // 绘制图像
+        ctx.drawImage(image, 0, 0);
+        // 获取ImageData
+        return ctx.getImageData(0, 0, canvas.width, canvas.height);
+    }
+    /**
+     * 图像预处理
+     * @param imageData 原始图像数据
+     * @returns 处理后的图像数据
+     */
+    preprocessImage(imageData) {
+        // 创建canvas并获取2D上下文
+        const canvas = document.createElement('canvas');
+        const ctx = canvas.getContext('2d');
+        if (!ctx) {
+            return imageData;
+        }
+        // 设置canvas尺寸
+        canvas.width = imageData.width;
+        canvas.height = imageData.height;
+        // 绘制原始图像
+        ctx.putImageData(imageData, 0, 0);
+        // 增强对比度
+        if (this.options.imageProcess?.enhanceContrast) {
+            ctx.filter = 'contrast(150%)';
+            ctx.drawImage(canvas, 0, 0);
+            ctx.filter = 'none';
+        }
+        // 应用二值化
+        const threshold = this.options.imageProcess?.threshold || 128;
+        const processedData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+        const data = processedData.data;
+        for (let i = 0; i < data.length; i += 4) {
+            // 计算灰度值
+            const gray = 0.299 * data[i] + 0.587 * data[i + 1] + 0.114 * data[i + 2];
+            // 二值化
+            const value = gray < threshold ? 0 : 255;
+            data[i] = data[i + 1] = data[i + 2] = value;
+        }
+        return processedData;
+    }
+    /**
+     * 释放资源
+     */
+    async dispose() {
+        if (!this.initialized) {
+            return;
+        }
+        this.logger.debug('QRCodeScanner', '释放二维码扫描器资源');
+        // 移除所有事件监听器
+        this.removeAllListeners();
+        this.initialized = false;
+        this.logger.debug('QRCodeScanner', '二维码扫描器资源已释放');
+    }
+}
+
+/**
+ * @file 二维码模块入口
+ * @description 提供二维码识别和解析功能的模块入口
+ * @module modules/qrcode
+ */
+/**
+ * 二维码模块
+ * 提供二维码检测和解析功能
+ */
+class QRCodeModule extends BaseModule {
+    /**
+     * 构造函数
+     * @param options 模块配置选项
+     */
+    constructor(options = {}) {
+        super();
+        /** 模块名称 */
+        this.name = 'qrcode';
+        this.options = {
+            enabled: true,
+            scanner: {
+                minConfidence: 0.6,
+                tryMultipleScan: true,
+                returnImage: false,
+                ...options.scanner
+            },
+            imageProcess: {
+                preprocess: true,
+                enhanceContrast: true,
+                threshold: 128,
+                ...options.imageProcess
+            },
+            ...options
+        };
+        // 创建扫描器
+        this.scanner = new QRCodeScanner({
+            minConfidence: this.options.scanner?.minConfidence,
+            returnImage: this.options.scanner?.returnImage,
+            imageProcess: this.options.imageProcess
+        });
+    }
+    /**
+     * 初始化模块
+     */
+    async initialize() {
+        if (this._isInitialized) {
+            return;
+        }
+        this.logger.debug(this.name, '初始化二维码模块');
+        try {
+            // 初始化扫描器
+            await this.scanner.initialize();
+            this._isInitialized = true;
+            this.emit('initialized');
+            this.logger.debug(this.name, '二维码模块初始化完成');
+        }
+        catch (error) {
+            this.logger.error(this.name, '二维码模块初始化失败', error);
+            throw new Error(`二维码模块初始化失败: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * 扫描图像中的二维码
+     * @param image 图像源
+     * @returns 二维码扫描结果
+     */
+    async scan(image) {
+        this.ensureInitialized();
+        try {
+            // 扫描二维码
+            const scanResult = await this.scanner.scan(image);
+            if (scanResult) {
+                // 保存最后一次扫描结果
+                this.lastScanResult = scanResult;
+                // 触发事件
+                this.emit('qrcode:scanned', { result: scanResult });
+            }
+            return scanResult;
+        }
+        catch (error) {
+            this.logger.error(this.name, '二维码扫描失败', error);
+            throw new Error(`二维码扫描失败: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * 获取最后一次扫描结果
+     */
+    getLastScanResult() {
+        return this.lastScanResult;
+    }
+    /**
+     * 解析二维码数据
+     * @param data 二维码数据
+     * @returns 解析后的数据对象
+     */
+    parseQRCodeData(data) {
+        try {
+            // 尝试解析为JSON
+            return JSON.parse(data);
+        }
+        catch {
+            // 不是JSON，尝试解析为URL参数
+            if (data.includes('=')) {
+                try {
+                    const params = {};
+                    const urlParams = new URLSearchParams(data.includes('?') ? data.split('?')[1] : data);
+                    urlParams.forEach((value, key) => {
+                        params[key] = value;
+                    });
+                    return params;
+                }
+                catch {
+                    // 解析URL参数失败，返回原始字符串
+                    return data;
+                }
+            }
+            // 返回原始字符串
+            return data;
+        }
+    }
+    /**
+     * 释放模块资源
+     */
+    async dispose() {
+        if (!this._isInitialized) {
+            return;
+        }
+        this.logger.debug(this.name, '释放二维码模块资源');
+        try {
+            // 释放扫描器资源
+            await this.scanner.dispose();
+            // 调用基类的dispose方法
+            await super.dispose();
+        }
+        catch (error) {
+            this.logger.error(this.name, '二维码模块资源释放失败', error);
+            throw new Error(`二维码模块资源释放失败: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}
+
+/**
+ * @file 人脸模块入口
+ * @description 提供人脸检测、活体检测和人脸比对功能的模块入口
+ * @module modules/face
+ */
+/**
+ * 人脸模块
+ * 提供人脸检测、活体检测和人脸比对功能
+ */
+class FaceModule extends BaseModule {
+    /**
+     * 构造函数
+     * @param options 模块配置选项
+     */
+    constructor(options = {}) {
+        super();
+        /** 模块名称 */
+        this.name = 'face';
+        this.options = {
+            enabled: true,
+            detector: {
+                minConfidence: 0.7,
+                detectLandmarks: true,
+                detectAttributes: true,
+                returnFaceImage: false,
+                ...options.detector
+            },
+            liveness: {
+                enabled: false,
+                type: 'passive',
+                minConfidence: 0.8,
+                timeout: 10000,
+                ...options.liveness
+            },
+            comparison: {
+                minSimilarity: 0.8,
+                ...options.comparison
+            },
+            ...options
+        };
+    }
+    /**
+     * 初始化模块
+     */
+    async initialize() {
+        if (this._isInitialized) {
+            return;
+        }
+        this.logger.debug(this.name, '初始化人脸模块');
+        try {
+            // 在此处初始化人脸检测、活体检测和人脸比对所需的模型
+            // 这里只是示例，实际实现需要根据具体的人脸识别库来实现
+            this._isInitialized = true;
+            this.emit('initialized');
+            this.logger.debug(this.name, '人脸模块初始化完成');
+        }
+        catch (error) {
+            this.logger.error(this.name, '人脸模块初始化失败', error);
+            throw new Error(`人脸模块初始化失败: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * 检测图像中的人脸
+     * @param image 图像源
+     * @returns 人脸检测结果
+     */
+    async detectFace(image) {
+        this.ensureInitialized();
+        try {
+            // 在此处实现人脸检测逻辑
+            // 这里只是示例，实际实现需要根据具体的人脸识别库来实现
+            const faceDetectionResult = {
+                boundingBox: {
+                    x: 0,
+                    y: 0,
+                    width: 100,
+                    height: 100
+                },
+                confidence: 0.9
+            };
+            // 保存最后一次检测结果
+            this.lastDetectionResult = faceDetectionResult;
+            // 触发事件
+            this.emit('face:detected', { result: faceDetectionResult });
+            return faceDetectionResult;
+        }
+        catch (error) {
+            this.logger.error(this.name, '人脸检测失败', error);
+            throw new Error(`人脸检测失败: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * 进行活体检测
+     * @param image 图像源
+     * @returns 活体检测结果
+     */
+    async detectLiveness(image) {
+        this.ensureInitialized();
+        if (!this.options.liveness?.enabled) {
+            throw new Error('活体检测未启用');
+        }
+        try {
+            // 在此处实现活体检测逻辑
+            // 这里只是示例，实际实现需要根据具体的活体检测算法来实现
+            const livenessResult = true;
+            // 触发事件
+            this.emit('face:liveness', { passed: livenessResult });
+            return livenessResult;
+        }
+        catch (error) {
+            this.logger.error(this.name, '活体检测失败', error);
+            throw new Error(`活体检测失败: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * 比对两个人脸
+     * @param face1 第一个人脸图像
+     * @param face2 第二个人脸图像
+     * @returns 人脸比对结果
+     */
+    async compareFaces(face1, face2) {
+        this.ensureInitialized();
+        try {
+            // 在此处实现人脸比对逻辑
+            // 这里只是示例，实际实现需要根据具体的人脸比对算法来实现
+            const similarity = 0.85;
+            const isMatch = similarity >= (this.options.comparison?.minSimilarity || 0.8);
+            const comparisonResult = {
+                isMatch,
+                similarity,
+                confidence: 0.9
+            };
+            // 触发事件
+            this.emit('face:compared', { result: comparisonResult });
+            return comparisonResult;
+        }
+        catch (error) {
+            this.logger.error(this.name, '人脸比对失败', error);
+            throw new Error(`人脸比对失败: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * 获取最后一次检测结果
+     */
+    getLastDetectionResult() {
+        return this.lastDetectionResult;
+    }
+    /**
+     * 释放模块资源
+     */
+    async dispose() {
+        if (!this._isInitialized) {
+            return;
+        }
+        this.logger.debug(this.name, '释放人脸模块资源');
+        try {
+            // 在此处释放人脸检测、活体检测和人脸比对所需的模型资源
+            // 这里只是示例，实际实现需要根据具体的人脸识别库来实现
+            // 调用基类的dispose方法
+            await super.dispose();
+        }
+        catch (error) {
+            this.logger.error(this.name, '人脸模块资源释放失败', error);
+            throw new Error(`人脸模块资源释放失败: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}
+
+/**
+ * @file 错误处理模块
+ * @description 定义ID-Scanner-Lib的错误类层次结构
+ * @module core/errors
+ */
+/**
+ * ID-Scanner-Lib 基础错误类
+ * 所有库特定错误的基类
+ */
+class IDScannerError extends Error {
+    /**
+     * 构造函数
+     * @param message 错误消息
+     * @param options 错误选项
+     */
+    constructor(message, options) {
+        super(message);
+        // 设置错误名称
+        this.name = this.constructor.name;
+        // 设置错误代码
+        this.code = options?.code || 'UNKNOWN_ERROR';
+        // 设置错误原因
+        this.cause = options?.cause;
+        // 捕获堆栈
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+}
+/**
+ * 初始化错误
+ * 当库初始化失败时抛出
+ */
+class InitializationError extends IDScannerError {
+    constructor(message, details) {
+        super(`初始化失败: ${message}${details ? ` (${details})` : ''}`, { code: 'INIT_FAILED' });
+        this.name = 'InitializationError';
+    }
+}
+/**
+ * 设备错误
+ * 当访问硬件设备(如摄像头)失败时抛出
+ */
+class DeviceError extends IDScannerError {
+    constructor(message) {
+        super(`设备错误: ${message}`, { code: 'DEVICE_ERROR' });
+        this.name = 'DeviceError';
+    }
+}
+/**
+ * 摄像头访问错误
+ * 当无法访问或启动摄像头时抛出
+ */
+class CameraAccessError extends IDScannerError {
+    constructor(message, options) {
+        super(`摄像头访问失败: ${message}`, {
+            code: options?.code || 'CAMERA_ACCESS_FAILED',
+            cause: options?.cause
+        });
+        this.name = 'CameraAccessError';
+    }
+}
+/**
+ * 人脸检测错误
+ * 当人脸检测过程失败时抛出
+ */
+class FaceDetectionError extends IDScannerError {
+    constructor(message) {
+        super(`人脸检测失败: ${message}`, { code: 'FACE_DETECTION_FAILED' });
+        this.name = 'FaceDetectionError';
+    }
+}
+/**
+ * 人脸比对错误
+ * 当人脸比对过程失败时抛出
+ */
+class FaceComparisonError extends IDScannerError {
+    constructor(message) {
+        super(`人脸比对失败: ${message}`, { code: 'FACE_COMPARISON_FAILED' });
+        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';
+    }
+}
+/**
+ * 资源加载错误
+ * 当无法加载必要资源(如模型)时抛出
+ */
+class ResourceLoadError extends IDScannerError {
+    constructor(resource, reason) {
+        super(`无法加载资源 ${resource}: ${reason}`, { code: 'RESOURCE_LOAD_FAILED' });
+        this.name = 'ResourceLoadError';
+    }
+}
+/**
+ * 参数错误
+ * 当提供的参数无效时抛出
+ */
+class InvalidArgumentError extends IDScannerError {
+    constructor(paramName, reason) {
+        super(`无效的参数 ${paramName}: ${reason}`, { code: 'INVALID_ARGUMENT' });
+        this.name = 'InvalidArgumentError';
+    }
+}
+/**
+ * 不支持错误
+ * 当尝试使用不支持的功能或当前环境无法使用的功能时抛出
+ */
+class NotSupportedError extends IDScannerError {
+    constructor(feature) {
+        super(`不支持的功能: ${feature}`, { code: 'NOT_SUPPORTED' });
+        this.name = 'NotSupportedError';
+    }
+}
+
+/**
+ * @file 主入口文件
+ * @description ID Scanner库的主入口点，提供统一的API和模块导出
+ * @module index
+ */
+/**
+ * IDScanner类
+ * 提供整合的身份证、二维码和人脸识别功能
+ */
+class IDScanner {
+    /**
+     * 构造函数
+     * @param options 配置选项
+     */
+    constructor(options = {}) {
+        /** 是否已经初始化 */
+        this.initialized = false;
+        // 配置日志级别
+        this.logger = Logger.getInstance();
+        if (options.logLevel !== undefined) {
+            this.logger.setLevel(options.logLevel);
+        }
+        this.moduleManager = ModuleManager.getInstance();
+        // 注册模块
+        if (options.enableIDCard !== false) {
+            this.moduleManager.register(new IDCardModule(options.idCard));
+        }
+        if (options.enableQRCode !== false) {
+            this.moduleManager.register(new QRCodeModule(options.qrCode));
+        }
+        if (options.enableFace !== false) {
+            this.moduleManager.register(new FaceModule(options.face));
+        }
+    }
+    /**
+     * 初始化库
+     */
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        this.logger.info('IDScanner', `初始化 IDScanner v${VERSION}`);
+        try {
+            // 初始化所有模块
+            await this.moduleManager.initialize();
+            this.initialized = true;
+            this.logger.info('IDScanner', 'IDScanner初始化完成');
+        }
+        catch (error) {
+            this.logger.error('IDScanner', 'IDScanner初始化失败', error);
+            throw new Error(`IDScanner初始化失败: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * 获取身份证模块实例
+     * @returns 身份证模块
+     */
+    getIDCardModule() {
+        return this.moduleManager.getModule('id-card');
+    }
+    /**
+     * 获取二维码模块实例
+     * @returns 二维码模块
+     */
+    getQRCodeModule() {
+        return this.moduleManager.getModule('qrcode');
+    }
+    /**
+     * 获取人脸识别模块实例
+     * @returns 人脸识别模块
+     */
+    getFaceModule() {
+        return this.moduleManager.getModule('face');
+    }
+    /**
+     * 释放所有资源
+     */
+    async dispose() {
+        if (!this.initialized) {
+            return;
+        }
+        this.logger.info('IDScanner', '释放IDScanner资源');
+        try {
+            await this.moduleManager.dispose();
+            this.initialized = false;
+            this.logger.info('IDScanner', 'IDScanner资源已释放');
+        }
+        catch (error) {
+            this.logger.error('IDScanner', 'IDScanner资源释放失败', error);
+            throw new Error(`IDScanner资源释放失败: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}
+/** 版本号 */
+IDScanner.VERSION = VERSION;
+/** 构建日期 */
+IDScanner.BUILD_DATE = BUILD_DATE;
+
+export { CameraAccessError, ConsoleLogHandler, DeviceError, FaceComparisonError, FaceDetectionError, FaceModule, IDCardDetectionError, IDCardModule, IDCardType, IDScanner, IDScannerError, InitializationError, InvalidArgumentError, LivenessDetectionError, LogLevel, Logger, MemoryLogHandler, ModuleManager, NotSupportedError, OCRProcessingError, QRCodeModule, QRScanError, RemoteLogHandler, ResourceLoadError, TaggedLogger, IDScanner as default };
+//# sourceMappingURL=id-scanner-lib.esm.js.map