a2bei4-utils 1.0.0 → 1.0.1

package/dist/a2bei4.utils.umd.js

@@ -4,33 +4,309 @@
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.a2bei4Utils = {}));
 })(this, (function (exports) { 'use strict';
 
-    /**
-     * 使用 Fisher-Yates 算法对数组 **原地** 随机乱序。
-     * @template T
-     * @param {T[]} arr - 要乱序的数组
-     * @returns {T[]} 返回传入的同一数组实例（已乱序）
-     */
-    function shuffle(arr) {
-        //  方式一：
-        // arr.sort(() => Math.random() - 0.5);
-        //  方式二：
-        for (let i = arr.length - 1; i > 0; i--) {
-            const j = Math.floor(Math.random() * (i + 1));
-            [arr[i], arr[j]] = [arr[j], arr[i]];
-        }
-        return arr;
-    }
-
-    /**
-     * 将数组中的元素从 `fromIndex` 移动到 `toIndex`，**原地** 修改并返回该数组。
-     * @template T
-     * @param {T[]} arr - 要操作的数组
-     * @param {number} fromIndex - 原始下标
-     * @param {number} toIndex - 目标下标
-     * @returns {T[]} 返回传入的同一数组实例
-     */
-    function moveItem(arr, fromIndex, toIndex) {
-        arr.splice(toIndex, 0, arr.splice(fromIndex, 1)[0]);
+    /**
+     * 使用 Fisher-Yates 算法对数组 **原地** 随机乱序。
+     * @template T
+     * @param {T[]} arr - 要乱序的数组
+     * @returns {T[]} 返回传入的同一数组实例（已乱序）
+     */
+    function shuffle(arr) {
+        //  方式一：
+        // arr.sort(() => Math.random() - 0.5);
+        //  方式二：
+        for (let i = arr.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [arr[i], arr[j]] = [arr[j], arr[i]];
+        }
+        return arr;
+    }
+
+    /**
+     * 将数组中的元素从 `fromIndex` 移动到 `toIndex`，**原地** 修改并返回该数组。
+     * @template T
+     * @param {T[]} arr - 要操作的数组
+     * @param {number} fromIndex - 原始下标
+     * @param {number} toIndex - 目标下标
+     * @returns {T[]} 返回传入的同一数组实例
+     */
+    function moveItem(arr, fromIndex, toIndex) {
+        arr.splice(toIndex, 0, arr.splice(fromIndex, 1)[0]);
+    }
+
+    const AudioStreamResamplerProcessorCode = `
+class AudioStreamResamplerProcessor extends AudioWorkletProcessor {
+    constructor(options) {
+        super();
+        const config = options.processorOptions || {};
+        this.targetSampleRate = config.targetSampleRate || 16000;
+        this.sourceSampleRate = sampleRate;
+        this.downsampleRatio = this.sourceSampleRate / this.targetSampleRate;
+
+        // 16000Hz 用 60ms chunk (960 samples)，其他用 1024
+        this.chunkSize = this.targetSampleRate === 16000 ? 960 : 1024;
+
+        const sourceBufferSize = config.sourceBufferSize || 16384; // ~340ms @48kHz
+        const pcmBufferSize = config.pcmBufferSize || (this.chunkSize * 10); // 更大缓冲，减少溢出概率
+
+        this.sourceBuffer = new Float32Array(sourceBufferSize);
+        this.sourceBufferLength = 0;
+
+        this.pcmBuffer = new Int16Array(pcmBufferSize);
+        this.pcmBufferIndex = 0;
+    }
+
+    process(inputs, outputs, parameters) {
+        const input = inputs[0];
+        if (!input || input.length === 0 || input[0].length === 0) return true;
+        const inputChannel = input[0];
+
+        // 1. 写入源缓冲区（溢出时覆盖最旧数据）
+        const newLength = this.sourceBufferLength + inputChannel.length;
+        if (newLength > this.sourceBuffer.length) {
+            const overflow = newLength - this.sourceBuffer.length;
+            this.sourceBuffer.copyWithin(0, overflow);
+            this.sourceBufferLength = this.sourceBuffer.length - inputChannel.length;
+        }
+        this.sourceBuffer.set(inputChannel, this.sourceBufferLength);
+        this.sourceBufferLength += inputChannel.length;
+
+        // 2. 计算可降采样样本数
+        const availableOutputSamples = Math.floor(this.sourceBufferLength / this.downsampleRatio);
+        if (availableOutputSamples === 0) return true;
+
+        // 3. 线性插值降采样
+        const downsampled = new Float32Array(availableOutputSamples);
+        for (let i = 0; i < availableOutputSamples; i++) {
+            const srcIndex = i * this.downsampleRatio;
+            const srcIndexInt = Math.floor(srcIndex);
+            const fraction = srcIndex - srcIndexInt;
+            const val0 = this.sourceBuffer[srcIndexInt];
+            const val1 = srcIndexInt + 1 < this.sourceBufferLength ? this.sourceBuffer[srcIndexInt + 1] : val0;
+            downsampled[i] = val0 + (val1 - val0) * fraction;
+        }
+
+        // 4. Float32 → Int16 PCM
+        const pcmData = this.floatTo16BitPCM(downsampled);
+
+        // 5. 写入 PCM 缓冲区（空间不足时直接覆盖最旧，缓冲区足够大基本不会触发）
+        if (this.pcmBufferIndex + pcmData.length > this.pcmBuffer.length) {
+            // 简单策略：从头覆盖（丢弃最旧数据）
+            this.pcmBufferIndex = 0;
+        }
+        this.pcmBuffer.set(pcmData, this.pcmBufferIndex);
+        this.pcmBufferIndex += pcmData.length;
+
+        // 6. 发送所有完整的 chunk（关键：复制到新数组再转移）
+        while (this.pcmBufferIndex >= this.chunkSize) {
+            // 方法1：推荐，使用 slice（隐式复制到新 ArrayBuffer）
+            const chunk = this.pcmBuffer.slice(0, this.chunkSize);
+
+            // 方法2：等价写法
+            // const chunk = new Int16Array(this.pcmBuffer.subarray(0, this.chunkSize));
+
+            this.port.postMessage(chunk, [chunk.buffer]); // 转移新缓冲区，安全！
+
+            // 移动剩余数据到开头
+            this.pcmBuffer.copyWithin(0, this.chunkSize, this.pcmBufferIndex);
+            this.pcmBufferIndex -= this.chunkSize;
+        }
+
+        // 7. 清理已消费的源数据
+        const consumedSrc = Math.floor(availableOutputSamples * this.downsampleRatio + 0.5); // 四舍五入更准
+        if (consumedSrc > 0) {
+            this.sourceBuffer.copyWithin(0, consumedSrc, this.sourceBufferLength);
+            this.sourceBufferLength -= consumedSrc;
+        }
+
+        return true;
+    }
+
+    floatTo16BitPCM(input) {
+        const output = new Int16Array(input.length);
+        for (let i = 0; i < input.length; i++) {
+            const s = Math.max(-1, Math.min(1, input[i]));
+            output[i] = s < 0 ? s * 0x8000 : s * 0x7FFF;
+        }
+        return output;
+    }
+}
+
+registerProcessor('audio-stream-resampler-processor', AudioStreamResamplerProcessor);
+`;
+
+    /**
+     * 浏览器端实时音频流重采样器。
+     * 基于 AudioWorklet 将麦克风/媒体流转换为 16 kHz、16-bit、单声道 PCM，
+     * 并通过回调逐块输出，可选保存完整 PCM 用于后续合并。
+     */
+    class AudioStreamResampler {
+        /**
+         * @param {object} config
+         * @param {function(Int16Array)} config.onData - 收到一个 chunk PCM 数据的回调
+         * @param {function(string, string)} [config.onStateChange] - 状态变化回调
+         * @param {object} [config.processorOptions] - 传递给 AudioWorklet 的选项
+         * @param {boolean} [config.saveFullPcm=false] - 是否在内部保存所有 PCM 用于 stop 时合并（长时间录音建议关闭）
+         */
+        constructor(config) {
+            this.onData = config.onData || (() => {});
+            this.onStateChange = config.onStateChange || (() => {});
+            this.processorOptions = config.processorOptions || {};
+            this.saveFullPcm = config.saveFullPcm ?? false;
+
+            this.audioContext = null;
+            this.workletNode = null;
+            this.source = null;
+            this.workletUrl = null;
+            this.fullPcmData = this.saveFullPcm ? [] : null;
+
+            this.isInitialized = false;
+            this.isProcessing = false;
+        }
+
+        /**
+         * 初始化 AudioContext 并加载 AudioWorklet。
+         * 完成后状态变为 `"ready"`。
+         */
+        async init() {
+            this.onStateChange("initializing", "正在初始化音频环境...");
+            try {
+                this.audioContext = new (window.AudioContext || window.webkitAudioContext)();
+
+                const blob = new Blob([AudioStreamResamplerProcessorCode], { type: "application/javascript" });
+                this.workletUrl = URL.createObjectURL(blob);
+                await this.audioContext.audioWorklet.addModule(this.workletUrl);
+
+                this.workletNode = new AudioWorkletNode(this.audioContext, "audio-stream-resampler-processor", {
+                    processorOptions: this.processorOptions
+                });
+
+                this.workletNode.port.onmessage = (event) => {
+                    const chunk = event.data; // Int16Array
+                    this.onData(chunk);
+                    if (this.saveFullPcm) {
+                        this.fullPcmData.push(chunk);
+                    }
+                };
+
+                this.isInitialized = true;
+                this.onStateChange("ready", "音频环境已就绪");
+            } catch (err) {
+                console.error("AudioStreamResampler init error:", err);
+                this.onStateChange("error", `初始化失败: ${err.message}`);
+            }
+        }
+
+        /**
+         * 绑定媒体流，开始实时处理。
+         * @param {MediaStream} stream - 通过 getUserMedia 或其他方式获得的流
+         */
+        setMediaStream(stream) {
+            if (!this.isInitialized) {
+                console.error("请先调用 init()");
+                return;
+            }
+
+            if (this.source) {
+                this.source.disconnect();
+            }
+
+            this.source = this.audioContext.createMediaStreamSource(stream);
+            this.source.connect(this.workletNode);
+            // workletNode 默认连接到 destination，可选断开以静音
+            // this.workletNode.connect(this.audioContext.destination);
+
+            this.isProcessing = true;
+            this.onStateChange("processing", "正在处理音频流...");
+        }
+
+        /**
+         * 停止处理并释放资源。
+         * @param {(fullPcm: Int16Array) => void} [callback] - 若构造时 `saveFullPcm=true`，会把合并后的完整 PCM 通过此回调传出
+         */
+        stop(callback) {
+            if (!this.isProcessing) return;
+
+            this.onStateChange("stopping", "正在停止...");
+
+            if (this.source) {
+                this.source.disconnect();
+                this.source = null;
+            }
+
+            this._cleanup();
+
+            this.onStateChange("stopped", "已停止");
+
+            if (this.saveFullPcm && callback && typeof callback === "function") {
+                const totalLength = this.fullPcmData.reduce((sum, chunk) => sum + chunk.length, 0);
+                const combined = new Int16Array(totalLength);
+                let offset = 0;
+                for (const chunk of this.fullPcmData) {
+                    combined.set(chunk, offset);
+                    offset += chunk.length;
+                }
+                callback(combined);
+            }
+        }
+
+        _cleanup() {
+            if (this.workletNode) {
+                this.workletNode.disconnect();
+                this.workletNode.port.close();
+                this.workletNode = null;
+            }
+            if (this.audioContext && this.audioContext.state !== "closed") {
+                this.audioContext.close();
+                this.audioContext = null;
+            }
+            if (this.workletUrl) {
+                URL.revokeObjectURL(this.workletUrl);
+                this.workletUrl = null;
+            }
+
+            this.isProcessing = false;
+            this.isInitialized = false;
+            if (this.fullPcmData) {
+                this.fullPcmData.length = 0;
+            }
+        }
+    }
+
+    /**
+     * 将 16-bit 单声道 PCM 数据封装成标准 WAV Blob。
+     *
+     * @param {Int16Array} pcmData - PCM 采样数据
+     * @param {number} [sampleRate=16000] - 采样率，默认 16 kHz
+     * @returns {Blob} audio/wav Blob
+     */
+    function pcmToWavBlob(pcmData, sampleRate = 16000) {
+        const length = pcmData.length;
+        const buffer = new ArrayBuffer(44 + length * 2);
+        const view = new DataView(buffer);
+        const writeString = (offset, string) => {
+            for (let i = 0; i < string.length; i++) {
+                view.setUint8(offset + i, string.charCodeAt(i));
+            }
+        };
+        writeString(0, "RIFF");
+        view.setUint32(4, 36 + length * 2, true);
+        writeString(8, "WAVE");
+        writeString(12, "fmt ");
+        view.setUint32(16, 16, true);
+        view.setUint16(20, 1, true);
+        view.setUint16(22, 1, true);
+        view.setUint32(24, sampleRate, true);
+        view.setUint32(28, sampleRate * 2, true);
+        view.setUint16(32, 2, true);
+        view.setUint16(34, 16, true);
+        writeString(36, "data");
+        view.setUint32(40, length * 2, true);
+        let offset = 44;
+        for (let i = 0; i < length; i++) {
+            view.setInt16(offset, pcmData[i], true);
+            offset += 2;
+        }
+        return new Blob([buffer], { type: "audio/wav" });
     }
 
     /**
@@ -91,7 +367,7 @@
 
     /**
      * 返回任意值的运行时类型字符串（小写形式）。
-     * 
+     *
      * @param {*} obj 待检测的值
      * @returns {keyof globalThis|"blob"|"file"|"formdata"|string} 小写类型名
      */
@@ -104,7 +380,7 @@
 
     /**
      * 判断值是否为原生 Blob（含 File）。
-     * 
+     *
      * @param {*} obj - 待检测的值
      * @returns {obj is Blob}
      */
@@ -114,7 +390,7 @@
 
     /**
      * 判断值是否为**纯粹**的 Object（即 `{}` 或 `new Object()`，不含数组、null、自定义类等）。
-     * 
+     *
      * @param {*} obj - 待检测的值
      * @returns {obj is Record<PropertyKey, any>}
      */
@@ -124,7 +400,7 @@
 
     /**
      * 判断值是否为 Promise（含 Promise 子类）。
-     * 
+     *
      * @param {*} obj - 待检测的值
      * @returns {obj is Promise<any>}
      */
@@ -144,7 +420,7 @@
 
     /**
      * 判断值是否为函数（含异步函数、生成器函数、类）。
-     * 
+     *
      * @param {*} obj - 待检测的值
      * @returns {obj is Function}
      */
@@ -154,7 +430,7 @@
 
     /**
      * 判断值是否为**非空**字符串。
-     * 
+     *
      * @param {*} obj - 待检测的值
      * @returns {obj is string}
      */
@@ -646,6 +922,7 @@
 
     /**
      * 通过动态创建 `<a>` 标签触发浏览器下载。
+     * 注意：此方法可能无法强制下载浏览器原生支持的文件（如图片、PDF），浏览器可能会选择直接打开。
      *
      * @param {string} url - 任意可下载地址（同源或允许跨域）
      * @param {string} [fileName] - 保存到本地的文件名；不传时使用时间戳
@@ -706,224 +983,265 @@
         downloadByData(data, fileName, "application/json");
     }
 
-    /**
-     * 简单、高性能的通用事件总线。
-     * - 支持命名空间事件
-     * - 支持一次性监听器
-     * - 返回唯一 flag，用于精确卸载
-     * - emit 时可选自定义 this 指向
-     */
-    class MyEvent {
-        constructor() {
-            this.evtPool = new Map();
-        }
-
-        /**
-         * 注册事件监听器。
-         * @param {string} name - 事件名
-         * @param {Function} fn - 回调函数
-         * @returns {string} flag - 唯一标识，用于 off
-         */
-        on(name, fn) {
-            let flag = Date.now() + "_" + parseInt(Math.random() * 1e8);
-            const evtItem = {
-                flag,
-                fn
-            };
-            if (this.evtPool.has(name)) {
-                this.evtPool.get(name).push(evtItem);
-            } else {
-                this.evtPool.set(name, [evtItem]);
-            }
-            return flag;
-        }
-
-        /**
-         * 注册一次性监听器，触发后自动移除。
-         * @param {string} name - 事件名
-         * @param {Function} fn - 回调函数
-         * @returns {string} flag - 唯一标识
-         */
-        once(name, fn) {
-            const _this = this;
-            let wrapper;
-            wrapper = function (data) {
-                _this.off(name, wrapper);
-                fn.call(this, data);
-            };
-            return this.on(name, wrapper);
-        }
-
-        /**
-         * 移除指定事件监听器。
-         * @param {string} name - 事件名
-         * @param {Function|string} fnOrFlag - 回调函数或 flag
-         */
-        off(name, fnOrFlag) {
-            if (!this.evtPool.has(name)) return;
-            const evtItems = this.evtPool.get(name);
-            const filtered = evtItems.filter((item) => item.fn !== fnOrFlag && item.flag !== fnOrFlag);
-            if (filtered.length === 0) {
-                this.evtPool.delete(name);
-            } else {
-                this.evtPool.set(name, filtered);
-            }
-        }
-
-        /**
-         * 触发事件（同步执行）。
-         * @param {string} name - 事件名
-         * @param {*} [data] - 任意载荷
-         * @param {*} [fnThis] - 回调内部 this 指向，默认 undefined
-         */
-        emit(name, data, fnThis) {
-            if (!this.evtPool.has(name)) return;
-            const evtItems = this.evtPool.get(name);
-            evtItems.forEach((item) => {
-                try {
-                    item.fn.call(fnThis, data);
-                } catch (err) {
-                    console.error(`Error in event listener for "${name}":`, err);
-                }
-            });
-        }
-    }
-
-    /**
-     * 跨页通信插件：通过 localStorage + storage 事件将当前实例的 emit 广播到其他同源页面。
-     * 支持节流、命名空间隔离。
-     */
-    const MyEvent_CrossPagePlugin = (() => {
-        const INSTALLED = new WeakSet(); // 防止重复安装
-
-        return {
-            /**
-             * 为指定 MyEvent 实例安装跨页插件。
-             * @param {MyEvent} bus - 事件总线实例
-             * @param {Options} [opts] - 配置项
-             */
-            install(bus, opts = {}) {
-                if (INSTALLED.has(bus)) return;
-                INSTALLED.add(bus);
-
-                const ns = `___my-event-cross-page-${opts.namespace || "default"}___`;
-                const delay = opts.throttle || 16;
-                let last = 0;
-
-                //  1、重写 emit
-                const rawEmit = bus.emit;
-                bus.emit = function (name, data, fnThis) {
-                    rawEmit.call(bus, name, data, fnThis); // 本地先执行
-                    const now = Date.now();
-                    if (now - last < delay) return;
-                    last = now;
-                    const key = ns + name;
-                    try {
-                        localStorage.setItem(key, JSON.stringify({ name, data, ts: now }));
-                        localStorage.removeItem(key); // 触发 storage 事件
-                    } catch (e) {}
-                };
-
-                //  2、监听其他页广播
-                function onStorageHandler(e) {
-                    if (!e.key || !e.key.startsWith(ns)) return;
-                    let payload;
-                    try {
-                        payload = JSON.parse(e.newValue || "{}");
-                    } catch {
-                        return;
-                    }
-                    if (!payload.ts || payload.ts <= last) return;
-                    rawEmit.call(bus, e.key.slice(ns.length), payload.data); // 仅本地
-                }
-                addEventListener("storage", onStorageHandler);
-
-                //  3、保存卸载器
-                bus._uninstallCrossPage = () => {
-                    removeEventListener("storage", onStorageHandler);
-                    bus.emit = rawEmit;
-                    INSTALLED.delete(bus);
-                };
-            },
-
-            /**
-             * 卸载插件，恢复原始 emit 并停止监听。
-             * @param {MyEvent} bus - 事件总线实例
-             */
-            uninstall(bus) {
-                if (typeof bus._uninstallCrossPage === "function") bus._uninstallCrossPage();
-            }
-        };
+    /**
+     * 通过 `fetch` 获取资源并强制下载，避免浏览器直接打开文件。
+     * 此方法适用于下载图片、PDF 等浏览器默认会打开的文件类型。
+     * 如果 `fetch` 失败（如 CORS 策略阻止），会回退到 `downloadByUrl` 方法作为备选方案。
+     *
+     * @param {string} url - 文件的 URL 地址
+     * @param {string} [fileName] - 保存到本地的文件名。如果不提供，会尝试从 URL 中自动提取
+     * @returns {Promise<void>} 返回一个 Promise，在下载开始或失败后 resolve
+     */
+    async function fetchOrDownloadByUrl(url, fileName) {
+        // 如果未提供文件名，尝试从 URL 路径中提取
+        if (!fileName) {
+            try {
+                const urlPathname = new URL(url).pathname;
+                // 获取路径的最后一部分作为文件名，并移除可能的查询参数
+                fileName = urlPathname.substring(urlPathname.lastIndexOf("/") + 1).split("?")[0];
+            } catch (e) {}
+            // 如果提取后文件名为空（例如 URL 以 '/' 结尾），也使用时间戳
+            if (!fileName) {
+                fileName = Date.now().toString();
+            }
+        }
+
+        try {
+            const response = await fetch(url, {
+                method: "GET",
+                mode: "cors",
+                cache: "no-cache"
+            });
+
+            if (!response.ok) {
+                throw new Error(`HTTP error! ${response.status}: ${response.statusText}`);
+            }
+
+            const blob = await response.blob();
+            downloadByBlob(blob, fileName);
+        } catch (error) {
+            downloadByUrl(url, fileName);
+        }
+    }
+
+    /**
+     * 简单、高性能的通用事件总线。
+     * - 支持命名空间事件
+     * - 支持一次性监听器
+     * - 返回唯一 flag，用于精确卸载
+     * - emit 时可选自定义 this 指向
+     */
+    class MyEvent {
+        constructor() {
+            this.evtPool = new Map();
+        }
+
+        /**
+         * 注册事件监听器。
+         * @param {string} name - 事件名
+         * @param {Function} fn - 回调函数
+         * @returns {string} flag - 唯一标识，用于 off
+         */
+        on(name, fn) {
+            let flag = Date.now() + "_" + parseInt(Math.random() * 1e8);
+            const evtItem = {
+                flag,
+                fn
+            };
+            if (this.evtPool.has(name)) {
+                this.evtPool.get(name).push(evtItem);
+            } else {
+                this.evtPool.set(name, [evtItem]);
+            }
+            return flag;
+        }
+
+        /**
+         * 注册一次性监听器，触发后自动移除。
+         * @param {string} name - 事件名
+         * @param {Function} fn - 回调函数
+         * @returns {string} flag - 唯一标识
+         */
+        once(name, fn) {
+            const _this = this;
+            let wrapper;
+            wrapper = function (data) {
+                _this.off(name, wrapper);
+                fn.call(this, data);
+            };
+            return this.on(name, wrapper);
+        }
+
+        /**
+         * 移除指定事件监听器。
+         * @param {string} name - 事件名
+         * @param {Function|string} fnOrFlag - 回调函数或 flag
+         */
+        off(name, fnOrFlag) {
+            if (!this.evtPool.has(name)) return;
+            const evtItems = this.evtPool.get(name);
+            const filtered = evtItems.filter((item) => item.fn !== fnOrFlag && item.flag !== fnOrFlag);
+            if (filtered.length === 0) {
+                this.evtPool.delete(name);
+            } else {
+                this.evtPool.set(name, filtered);
+            }
+        }
+
+        /**
+         * 触发事件（同步执行）。
+         * @param {string} name - 事件名
+         * @param {*} [data] - 任意载荷
+         * @param {*} [fnThis] - 回调内部 this 指向，默认 undefined
+         */
+        emit(name, data, fnThis) {
+            if (!this.evtPool.has(name)) return;
+            const evtItems = this.evtPool.get(name);
+            evtItems.forEach((item) => {
+                try {
+                    item.fn.call(fnThis, data);
+                } catch (err) {
+                    console.error(`Error in event listener for "${name}":`, err);
+                }
+            });
+        }
+    }
+
+    /**
+     * 跨页通信插件：通过 localStorage + storage 事件将当前实例的 emit 广播到其他同源页面。
+     * 支持节流、命名空间隔离。
+     */
+    const MyEvent_CrossPagePlugin = (() => {
+        const INSTALLED = new WeakSet(); // 防止重复安装
+
+        return {
+            /**
+             * 为指定 MyEvent 实例安装跨页插件。
+             * @param {MyEvent} bus - 事件总线实例
+             * @param {Options} [opts] - 配置项
+             */
+            install(bus, opts = {}) {
+                if (INSTALLED.has(bus)) return;
+                INSTALLED.add(bus);
+
+                const ns = `___my-event-cross-page-${opts.namespace || "default"}___`;
+                const delay = opts.throttle || 16;
+                let last = 0;
+
+                //  1、重写 emit
+                const rawEmit = bus.emit;
+                bus.emit = function (name, data, fnThis) {
+                    rawEmit.call(bus, name, data, fnThis); // 本地先执行
+                    const now = Date.now();
+                    if (now - last < delay) return;
+                    last = now;
+                    const key = ns + name;
+                    try {
+                        localStorage.setItem(key, JSON.stringify({ name, data, ts: now }));
+                        localStorage.removeItem(key); // 触发 storage 事件
+                    } catch (e) {}
+                };
+
+                //  2、监听其他页广播
+                function onStorageHandler(e) {
+                    if (!e.key || !e.key.startsWith(ns)) return;
+                    let payload;
+                    try {
+                        payload = JSON.parse(e.newValue || "{}");
+                    } catch {
+                        return;
+                    }
+                    if (!payload.ts || payload.ts <= last) return;
+                    rawEmit.call(bus, e.key.slice(ns.length), payload.data); // 仅本地
+                }
+                addEventListener("storage", onStorageHandler);
+
+                //  3、保存卸载器
+                bus._uninstallCrossPage = () => {
+                    removeEventListener("storage", onStorageHandler);
+                    bus.emit = rawEmit;
+                    INSTALLED.delete(bus);
+                };
+            },
+
+            /**
+             * 卸载插件，恢复原始 emit 并停止监听。
+             * @param {MyEvent} bus - 事件总线实例
+             */
+            uninstall(bus) {
+                if (typeof bus._uninstallCrossPage === "function") bus._uninstallCrossPage();
+            }
+        };
     })();
 
-    /**
-     * 生成 RFC4122 版本 4 的 GUID/UUID。
-     * 收集来源：《基于mvc的javascript web富应用开发》 书中介绍是Robert Kieffer写的，还留了网址 http://goo.gl/0b0hu ，但实际访问不了。
-     * 格式：`xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx`
-     *
-     * @returns {string} 36 位大写 GUID
-     *
-     * @example
-     * // A2E0F340-6C3B-4D7F-B8C1-1E4F6A8B9C0D
-     * console.log(getGUID())
-     */
-    function getGUID() {
-        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
-            let r = (Math.random() * 16) | 0,
-                v = c == "x" ? r : (r & 0x3) | 0x8;
-            return v.toString(16).toUpperCase();
-        });
-    }
-
-    /**
-     * 分布式短 ID 生成器。
-     * 格式：`${timestamp}${flag}${serial}`，其中：
-     * - timestamp：毫秒级时间戳
-     * - flag：客户端标识串（自定义）
-     * - serial：同一毫秒内的序号，左补零到固定长度
-     */
-    class MyId {
-        #ts = Date.now(); //	时间戳
-        #sn = 0; //	序号（保证同一客户端之间的唯一项）
-        #flag = ""; //	客户端标识（保证不同客户端之间的唯一项）
-        #len = 5; //	序号位长度（我的电脑测试，同一时间戳内可以for循环执行了1000次左右，没有一次超过3k，所以5位应该够用了）
-        //  测试代码
-        //  let obj = {[Date.now()]:[]}; try { for (let i = 0; i < 100000; i++) { obj[Date.now()].push(i); } } catch { console.log(obj[Object.getOwnPropertyNames(obj)[0]].length); }
-
-        /**
-         * @param {object} [option]
-         * @param {string} [option.flag] - 客户端标识，默认空串
-         * @param {number} [option.len=5] - 序号位长度（位数），安全范围 ≥0
-         */
-        constructor(option = {}) {
-            if (option) {
-                if (typeof option.flag === "string") {
-                    this.#flag = option.flag;
-                }
-                if (Number.isSafeInteger(option.len) && len >= 0) {
-                    this.#len = option.len;
-                }
-            }
-        }
-
-        /**
-         * 生成下一个全局唯一字符串 ID。
-         * 同一毫秒序号自动递增；序号溢出时会在控制台警告。
-         * @returns {string}
-         */
-        nextId() {
-            let ts = Date.now();
-            if (ts === this.#ts) {
-                this.#sn++;
-                if (this.#sn >= 10 ** this.#len) {
-                    console.log("长度不够用了！！！");
-                }
-            } else {
-                this.#sn = 0;
-                this.#ts = ts;
-            }
-            return ts.toString() + this.#flag + this.#sn.toString().padStart(this.#len, "0");
-        }
+    /**
+     * 生成 RFC4122 版本 4 的 GUID/UUID。
+     * 收集来源：《基于mvc的javascript web富应用开发》 书中介绍是Robert Kieffer写的，还留了网址 http://goo.gl/0b0hu ，但实际访问不了。
+     * 格式：`xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx`
+     *
+     * @returns {string} 36 位大写 GUID
+     *
+     * @example
+     * // A2E0F340-6C3B-4D7F-B8C1-1E4F6A8B9C0D
+     * console.log(getGUID())
+     */
+    function getGUID() {
+        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+            let r = (Math.random() * 16) | 0,
+                v = c == "x" ? r : (r & 0x3) | 0x8;
+            return v.toString(16).toUpperCase();
+        });
+    }
+
+    /**
+     * 分布式短 ID 生成器。
+     * 格式：`${timestamp}${flag}${serial}`，其中：
+     * - timestamp：毫秒级时间戳
+     * - flag：客户端标识串（自定义）
+     * - serial：同一毫秒内的序号，左补零到固定长度
+     */
+    class MyId {
+        #ts = Date.now(); //	时间戳
+        #sn = 0; //	序号（保证同一客户端之间的唯一项）
+        #flag = ""; //	客户端标识（保证不同客户端之间的唯一项）
+        #len = 5; //	序号位长度（我的电脑测试，同一时间戳内可以for循环执行了1000次左右，没有一次超过3k，所以5位应该够用了）
+        //  测试代码
+        //  let obj = {[Date.now()]:[]}; try { for (let i = 0; i < 100000; i++) { obj[Date.now()].push(i); } } catch { console.log(obj[Object.getOwnPropertyNames(obj)[0]].length); }
+
+        /**
+         * @param {object} [option]
+         * @param {string} [option.flag] - 客户端标识，默认空串
+         * @param {number} [option.len=5] - 序号位长度（位数），安全范围 ≥0
+         */
+        constructor(option = {}) {
+            if (option) {
+                if (typeof option.flag === "string") {
+                    this.#flag = option.flag;
+                }
+                if (Number.isSafeInteger(option.len) && len >= 0) {
+                    this.#len = option.len;
+                }
+            }
+        }
+
+        /**
+         * 生成下一个全局唯一字符串 ID。
+         * 同一毫秒序号自动递增；序号溢出时会在控制台警告。
+         * @returns {string}
+         */
+        nextId() {
+            let ts = Date.now();
+            if (ts === this.#ts) {
+                this.#sn++;
+                if (this.#sn >= 10 ** this.#len) {
+                    console.log("长度不够用了！！！");
+                }
+            } else {
+                this.#sn = 0;
+                this.#ts = ts;
+            }
+            return ts.toString() + this.#flag + this.#sn.toString().padStart(this.#len, "0");
+        }
     }
 
     /**
@@ -931,7 +1249,6 @@
      * 每次任务执行完成后才计算下一次间隔，避免任务堆积。
      */
     class IntervalTimer {
-        
         /**
          * 创建定时器实例。
          * @param {() => void} fn - 每次间隔要执行的业务函数
@@ -1072,10 +1389,491 @@
         }
     };
 
+    /**
+     * 从服务端返回的已选 id 数组里，提取出
+     * 1. 叶子节点
+     * 2. 所有子节点都被选中的父节点
+     * 其余父节点一律丢弃（由前端 Tree 自动算半选）
+     *
+     * @param {Array}  treeData     完整树
+     * @param {Array}  selectedKeys 后端给的选中 id 数组
+     * @param {String} idKey        节点唯一字段
+     * @param {String} childrenKey  子节点字段
+     * @returns {{checked: string[], halfChecked: string[]}}
+     */
+    function extractFullyCheckedKeys(treeData, selectedKeys, idKey = "id", childrenKey = "children") {
+        const selectedSet = new Set(selectedKeys);
+        const checked = new Set();
+        const halfChecked = new Set();
+
+        /* 返回值含义
+            0 - 未选中
+            1 - 半选
+            2 - 全选
+            */
+        function dfs(node) {
+            const nodeId = node[idKey];
+            const children = node[childrenKey] || [];
+
+            // 叶子
+            if (!children.length) {
+                if (selectedSet.has(nodeId)) {
+                    checked.add(nodeId);
+                    return 2;
+                }
+                return 0;
+            }
+
+            // 非叶子
+            let allChecked = true;
+            let someChecked = false;
+
+            children.forEach((child) => {
+                const childState = dfs(child);
+                if (childState !== 2) allChecked = false;
+                if (childState >= 1) someChecked = true;
+            });
+
+            // 当前节点本身在 selectedKeys 里，但子节点未全选 → 只能算半选
+            if (selectedSet.has(nodeId)) {
+                if (allChecked) {
+                    checked.add(nodeId);
+                    return 2;
+                }
+                halfChecked.add(nodeId);
+                return 1;
+            }
+
+            // 当前节点不在 selectedKeys 里，看子节点
+            if (allChecked) {
+                checked.add(nodeId);
+                return 2;
+            }
+            if (someChecked) {
+                halfChecked.add(nodeId);
+                return 1;
+            }
+            return 0;
+        }
+
+        treeData.forEach(dfs);
+        return {
+            checked: [...checked],
+            halfChecked: [...halfChecked]
+        };
+    }
+
+    /**
+     * @class WebSocketManager - 一个功能强大、高度可定制的 WebSocket 助手类
+     *
+     * @features
+     * - 智能断线重连 (指数退避算法)
+     * - 网络状态监听
+     * - 高度可定制的心跳保活机制 (通过注入函数实现)
+     * - 页面可见性 API 集成
+     * - 消息发送队列
+     * - 事件驱动的消息分发
+     * - 清晰的生命周期管理
+     * - 优雅的资源销毁
+     * - 可配置的数据序列化/反序列化
+     */
+    class WebSocketManager {
+        /**
+         * @param {string} url - WebSocket 服务器的地址
+         * @param {object} [options={}] - 配置选项
+         * @param {number} [options.heartbeatInterval=30000] - 心跳间隔 (毫秒)
+         * @param {number} [options.heartbeatTimeout=10000] - 心跳超时时间 (毫秒)
+         * @param {number} [options.reconnectBaseInterval=1000] - 重连基础间隔 (毫秒)
+         * @param {number} [options.maxReconnectInterval=30000] - 最大重连间隔 (毫秒)
+         * @param {number} [options.maxReconnectAttempts=Infinity] - 最大重连次数
+         * @param {boolean} [options.autoConnect=true] - 是否在实例化后自动连接
+         * @param {boolean} [options.serializeData=false] - 发送数据时是否自动序列化为JSON字符串
+         * @param {boolean} [options.deserializeData=false] - 接收数据时是否自动反序列化为JSON对象
+         * @param {function|null} [options.getPingMessage=null] - 返回要发送的 ping 消息内容的函数。如果为 null，则不发送心跳。
+         * @param {function|null} [options.isPongMessage=null] - 判断接收到的消息是否为 pong 的函数。接收 MessageEvent 对象作为参数，返回布尔值。
+         * @param {object} [options.protocols] - WebSocket 协议
+         */
+        constructor(url, options = {}) {
+            this.url = url;
+
+            // 默认的心跳实现，用于向后兼容
+            const defaultGetPingMessage = () => JSON.stringify({ type: "ping" });
+            const defaultIsPongMessage = (event) => {
+                try {
+                    const message = JSON.parse(event.data);
+                    return message.type === "pong";
+                } catch (e) {
+                    return false;
+                }
+            };
+
+            this.options = {
+                heartbeatInterval: 30000,
+                heartbeatTimeout: 10000,
+                reconnectBaseInterval: 1000,
+                maxReconnectInterval: 30000,
+                maxReconnectAttempts: Infinity,
+                autoConnect: true,
+                serializeData: false,
+                deserializeData: false,
+                getPingMessage: defaultGetPingMessage, // 默认提供 ping 消息生成器
+                isPongMessage: defaultIsPongMessage, // 默认提供 pong 消息判断器
+                ...options
+            };
+
+            // WebSocket 实例
+            this.ws = null;
+
+            // 状态管理
+            this.readyState = WebSocket.CLOSED;
+            this.reconnectAttempts = 0;
+            this.forcedClose = false;
+            this.isReconnecting = false;
+
+            // 定时器
+            this.heartbeatTimer = null;
+            this.heartbeatTimeoutTimer = null;
+            this.reconnectTimer = null;
+
+            // 消息队列
+            this.messageQueue = [];
+
+            // 事件监听器
+            this.listeners = new Map();
+
+            // 绑定方法上下文
+            this._onOpen = this._onOpen.bind(this);
+            this._onMessage = this._onMessage.bind(this);
+            this._onClose = this._onClose.bind(this);
+            this._onError = this._onError.bind(this);
+            this._handleVisibilityChange = this._handleVisibilityChange.bind(this);
+            this._handleOnline = this._handleOnline.bind(this);
+            this._handleOffline = this._handleOffline.bind(this);
+
+            this._setupEventListeners();
+
+            if (this.options.autoConnect) {
+                this.connect();
+            }
+        }
+
+        // --- 公共 API ---
+
+        /**
+         * 连接到 WebSocket 服务器
+         */
+        connect() {
+            if (this.ws && (this.ws.readyState === WebSocket.CONNECTING || this.ws.readyState === WebSocket.OPEN)) {
+                return;
+            }
+
+            this.forcedClose = false;
+            this._updateReadyState(WebSocket.CONNECTING);
+            console.log(`[WS] 正在连接到 ${this.url}...`);
+            this._emit("connecting");
+
+            try {
+                this.ws = new WebSocket(this.url, this.options.protocols);
+                this.ws.onopen = this._onOpen;
+                this.ws.onmessage = this._onMessage;
+                this.ws.onclose = this._onClose;
+                this.ws.onerror = this._onError;
+            } catch (error) {
+                console.error("[WS] 连接失败:", error);
+                this._onError(error);
+            }
+        }
+
+        /**
+         * 发送数据
+         * @param {string|object|ArrayBuffer|Blob} data - 要发送的数据
+         */
+        send(data) {
+            if (this.readyState === WebSocket.OPEN) {
+                let message;
+                // 根据配置决定是否序列化数据
+                if (this.options.serializeData) {
+                    message = JSON.stringify(data);
+                } else {
+                    message = data;
+                }
+                this.ws.send(message);
+                console.log("[WS] 消息已发送:", message);
+            } else {
+                console.warn("[WS] 连接未打开，消息已加入队列:", data);
+                this.messageQueue.push(data);
+            }
+        }
+
+        /**
+         * 主动关闭连接
+         * @param {number} [code=1000] - 关闭代码
+         * @param {string} [reason=''] - 关闭原因
+         */
+        close(code = 1000, reason = "Normal closure") {
+            this.forcedClose = true;
+            this._stopHeartbeat();
+            this._clearReconnectTimer();
+            if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+                this.ws.close(code, reason);
+            } else {
+                this._updateReadyState(WebSocket.CLOSED);
+                this._emit("close", { code, reason, wasClean: true });
+            }
+        }
+
+        /**
+         * 彻底销毁实例，清理所有资源
+         */
+        destroy() {
+            console.log("[WS] 正在销毁实例...");
+            this.close(1000, "Instance destroyed");
+            this._removeEventListeners();
+            this.messageQueue = [];
+            this.listeners.clear();
+            this.ws = null;
+        }
+
+        /**
+         * 添加事件监听器
+         * @param {string} eventName - 事件名 (e.g., 'open', 'message', 'close', 'error', 'reconnect')
+         * @param {function} callback - 回调函数
+         */
+        on(eventName, callback) {
+            if (!this.listeners.has(eventName)) {
+                this.listeners.set(eventName, []);
+            }
+            this.listeners.get(eventName).push(callback);
+        }
+
+        /**
+         * 移除事件监听器
+         * @param {string} eventName - 事件名
+         * @param {function} callback - 回调函数
+         */
+        off(eventName, callback) {
+            if (this.listeners.has(eventName)) {
+                const callbacks = this.listeners.get(eventName);
+                const index = callbacks.indexOf(callback);
+                if (index > -1) {
+                    callbacks.splice(index, 1);
+                }
+            }
+        }
+
+        // --- 内部方法 ---
+
+        _onOpen(event) {
+            console.log("[WS] 连接已建立");
+            this._updateReadyState(WebSocket.OPEN);
+            this.reconnectAttempts = 0;
+            this.isReconnecting = false;
+
+            // 如果配置了 getPingMessage，则启动心跳
+            if (this.options.getPingMessage) {
+                this._startHeartbeat();
+            }
+
+            this._flushMessageQueue();
+            this._emit("open", event);
+        }
+
+        /**
+         * 优化后的消息处理方法，使用注入的函数来判断心跳
+         * @param {MessageEvent} event
+         */
+        _onMessage(event) {
+            // --- 步骤 1: 使用注入的函数优先处理内部心跳机制 ---
+            if (this.options.isPongMessage && this.options.isPongMessage(event)) {
+                this._handlePong();
+                return; // 是心跳消息，处理完毕，直接返回
+            }
+
+            // --- 步骤 2: 根据用户配置处理业务消息 ---
+            if (this.options.deserializeData) {
+                try {
+                    const parsedMessage = JSON.parse(event.data);
+                    this._emit("message", parsedMessage);
+                } catch (e) {
+                    this._emit("message", event.data);
+                }
+            } else {
+                this._emit("message", event.data);
+            }
+        }
+
+        _onClose(event) {
+            console.log("[WS] 连接已关闭", event);
+            this._updateReadyState(WebSocket.CLOSED);
+            this._stopHeartbeat();
+            this._emit("close", event);
+
+            if (!this.forcedClose) {
+                this._scheduleReconnect();
+            }
+        }
+
+        _onError(event) {
+            console.error("[WS] 连接发生错误:", event);
+            this._emit("error", event);
+        }
+
+        // --- 心跳机制 (重构) ---
+        _startHeartbeat() {
+            // 如果没有配置 getPingMessage，则无法启动心跳
+            if (!this.options.getPingMessage) {
+                return;
+            }
+
+            this._stopHeartbeat();
+            this.heartbeatTimer = setInterval(() => {
+                if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+                    try {
+                        // 调用注入的函数获取消息内容并发送
+                        const pingMessage = this.options.getPingMessage();
+                        this.ws.send(pingMessage);
+                        console.log("[WS] 发送 Ping:", pingMessage);
+                        this._setHeartbeatTimeout();
+                    } catch (error) {
+                        console.error("[WS] 发送 Ping 消息失败:", error);
+                    }
+                }
+            }, this.options.heartbeatInterval);
+        }
+
+        _stopHeartbeat() {
+            if (this.heartbeatTimer) {
+                clearInterval(this.heartbeatTimer);
+                this.heartbeatTimer = null;
+            }
+            this._clearHeartbeatTimeout();
+        }
+
+        _setHeartbeatTimeout() {
+            this._clearHeartbeatTimeout();
+            this.heartbeatTimeoutTimer = setTimeout(() => {
+                console.error("[WS] 心跳超时，主动断开连接");
+                this.ws.close(1006, "Heartbeat timeout");
+            }, this.options.heartbeatTimeout);
+        }
+
+        _clearHeartbeatTimeout() {
+            if (this.heartbeatTimeoutTimer) {
+                clearTimeout(this.heartbeatTimeoutTimer);
+                this.heartbeatTimeoutTimer = null;
+            }
+        }
+
+        _handlePong() {
+            console.log("[WS] 收到 Pong");
+            this._clearHeartbeatTimeout();
+        }
+
+        // --- 重连机制 ---
+        _scheduleReconnect() {
+            if (this.forcedClose || this.isReconnecting || this.reconnectAttempts >= this.options.maxReconnectAttempts) {
+                if (this.reconnectAttempts >= this.options.maxReconnectAttempts) {
+                    console.error("[WS] 已达到最大重连次数，停止重连");
+                    this._emit("reconnect-failed");
+                }
+                return;
+            }
+
+            this.isReconnecting = true;
+            const interval = Math.min(this.options.reconnectBaseInterval * Math.pow(2, this.reconnectAttempts), this.options.maxReconnectInterval);
+
+            console.log(`[WS] ${interval / 1000}秒后将尝试第 ${this.reconnectAttempts + 1} 次重连...`);
+            this._emit("reconnect-attempt", { attempt: this.reconnectAttempts + 1, interval });
+
+            this.reconnectTimer = setTimeout(() => {
+                this.reconnectAttempts++;
+                this.connect();
+            }, interval);
+        }
+
+        _clearReconnectTimer() {
+            if (this.reconnectTimer) {
+                clearTimeout(this.reconnectTimer);
+                this.reconnectTimer = null;
+            }
+        }
+
+        // --- 消息队列 ---
+        _flushMessageQueue() {
+            if (this.messageQueue.length === 0) return;
+            console.log(`[WS] 发送队列中的 ${this.messageQueue.length} 条消息`);
+            const queue = [...this.messageQueue];
+            this.messageQueue = [];
+            queue.forEach((data) => this.send(data));
+        }
+
+        // --- 事件系统 ---
+        _emit(eventName, ...args) {
+            if (this.listeners.has(eventName)) {
+                this.listeners.get(eventName).forEach((callback) => callback(...args));
+            }
+        }
+
+        // --- 状态与监听器管理 ---
+        _updateReadyState(newState) {
+            this.readyState = newState;
+            this._emit("ready-state-change", newState);
+        }
+
+        _setupEventListeners() {
+            document.addEventListener("visibilitychange", this._handleVisibilityChange);
+            window.addEventListener("online", this._handleOnline);
+            window.addEventListener("offline", this._handleOffline);
+        }
+
+        _removeEventListeners() {
+            document.removeEventListener("visibilitychange", this._handleVisibilityChange);
+            window.removeEventListener("online", this._handleOnline);
+            window.removeEventListener("offline", this._handleOffline);
+        }
+
+        _handleVisibilityChange() {
+            // 如果未启用心跳，不需要处理页面可见性变化
+            if (!this.options.enableHeartbeat) {
+                return;
+            }
+
+            if (document.hidden) {
+                console.log("[WS] 页面隐藏，停止心跳");
+                this._stopHeartbeat();
+            } else {
+                console.log("[WS] 页面可见，检查连接状态");
+                if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+                    this._startHeartbeat();
+                } else if (!this.forcedClose && !this.isReconnecting) {
+                    this.connect();
+                }
+            }
+        }
+
+        _handleOnline() {
+            console.log("[WS] 网络已恢复，尝试重连");
+            if (!this.forcedClose && this.readyState !== WebSocket.OPEN) {
+                this._clearReconnectTimer(); // 清除当前的重连计划
+                this.connect(); // 立即尝试连接
+            }
+        }
+
+        _handleOffline() {
+            console.log("[WS] 网络已断开");
+            this._clearReconnectTimer(); // 停止重连尝试
+            // ws.onclose 会被触发，从而启动重连逻辑，但我们已经停止了
+            // 所以这里可以手动触发一次 close 事件来通知应用层
+            if (this.ws) this.ws.onclose({ code: 1006, reason: "Network offline" });
+        }
+    }
+
+    exports.AudioStreamResampler = AudioStreamResampler;
     exports.IntervalTimer = IntervalTimer;
     exports.MyEvent = MyEvent;
     exports.MyEvent_CrossPagePlugin = MyEvent_CrossPagePlugin;
     exports.MyId = MyId;
+    exports.WebSocketManager = WebSocketManager;
     exports.assignExisting = assignExisting;
     exports.calcTimeDifference = calcTimeDifference;
     exports.debounce = debounce;
@@ -1085,6 +1883,8 @@
     exports.downloadByUrl = downloadByUrl;
     exports.downloadExcel = downloadExcel;
     exports.downloadJSON = downloadJSON;
+    exports.extractFullyCheckedKeys = extractFullyCheckedKeys;
+    exports.fetchOrDownloadByUrl = fetchOrDownloadByUrl;
     exports.findObjAttrValueById = findObjAttrValueById;
     exports.flatCompleteTree2NestedTree = flatCompleteTree2NestedTree;
     exports.formatDuration = formatDuration;
@@ -1104,6 +1904,7 @@
     exports.isPromise = isPromise;
     exports.moveItem = moveItem;
     exports.nestedTree2IdMap = nestedTree2IdMap;
+    exports.pcmToWavBlob = pcmToWavBlob;
     exports.randomDateInRange = randomDateInRange;
     exports.randomEnLetter = randomEnLetter;
     exports.randomHan = randomHan;