a2bei4-utils 1.0.0 → 1.0.2

package/dist/a2bei4.utils.cjs.js

@@ -1,32 +1,308 @@
 '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" });
 }
 
 /**
@@ -87,7 +363,7 @@ function getSearchParam(key) {
 
 /**
  * 返回任意值的运行时类型字符串（小写形式）。
- * 
+ *
  * @param {*} obj 待检测的值
  * @returns {keyof globalThis|"blob"|"file"|"formdata"|string} 小写类型名
  */
@@ -100,7 +376,7 @@ function getDataType(obj) {
 
 /**
  * 判断值是否为原生 Blob（含 File）。
- * 
+ *
  * @param {*} obj - 待检测的值
  * @returns {obj is Blob}
  */
@@ -110,7 +386,7 @@ function isBlob(obj) {
 
 /**
  * 判断值是否为**纯粹**的 Object（即 `{}` 或 `new Object()`，不含数组、null、自定义类等）。
- * 
+ *
  * @param {*} obj - 待检测的值
  * @returns {obj is Record<PropertyKey, any>}
  */
@@ -120,7 +396,7 @@ function isPlainObject(obj) {
 
 /**
  * 判断值是否为 Promise（含 Promise 子类）。
- * 
+ *
  * @param {*} obj - 待检测的值
  * @returns {obj is Promise<any>}
  */
@@ -140,7 +416,7 @@ function isDate(t) {
 
 /**
  * 判断值是否为函数（含异步函数、生成器函数、类）。
- * 
+ *
  * @param {*} obj - 待检测的值
  * @returns {obj is Function}
  */
@@ -150,7 +426,7 @@ function isFunction(obj) {
 
 /**
  * 判断值是否为**非空**字符串。
- * 
+ *
  * @param {*} obj - 待检测的值
  * @returns {obj is string}
  */
@@ -642,6 +918,7 @@ function formatDurationMaxHour(totalSeconds, options = {}) {
 
 /**
  * 通过动态创建 `<a>` 标签触发浏览器下载。
+ * 注意：此方法可能无法强制下载浏览器原生支持的文件（如图片、PDF），浏览器可能会选择直接打开。
  *
  * @param {string} url - 任意可下载地址（同源或允许跨域）
  * @param {string} [fileName] - 保存到本地的文件名；不传时使用时间戳
@@ -702,224 +979,265 @@ function downloadJSON(data, fileName) {
     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");
+    }
 }
 
 /**
@@ -927,7 +1245,6 @@ class MyId {
  * 每次任务执行完成后才计算下一次间隔，避免任务堆积。
  */
 class IntervalTimer {
-    
     /**
      * 创建定时器实例。
      * @param {() => void} fn - 每次间隔要执行的业务函数
@@ -1068,10 +1385,491 @@ const findObjAttrValueById = function findObjAttrValueByIdFn(id, arr, resultKey
     }
 };
 
+/**
+ * 从服务端返回的已选 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, event);
+            } catch (e) {
+                this._emit("message", event.data, event);
+            }
+        } else {
+            this._emit("message", event.data, event);
+        }
+    }
+
+    _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.getPingMessage) {
+            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;
@@ -1081,6 +1879,8 @@ exports.downloadByData = downloadByData;
 exports.downloadByUrl = downloadByUrl;
 exports.downloadExcel = downloadExcel;
 exports.downloadJSON = downloadJSON;
+exports.extractFullyCheckedKeys = extractFullyCheckedKeys;
+exports.fetchOrDownloadByUrl = fetchOrDownloadByUrl;
 exports.findObjAttrValueById = findObjAttrValueById;
 exports.flatCompleteTree2NestedTree = flatCompleteTree2NestedTree;
 exports.formatDuration = formatDuration;
@@ -1100,6 +1900,7 @@ exports.isPlainObject = isPlainObject;
 exports.isPromise = isPromise;
 exports.moveItem = moveItem;
 exports.nestedTree2IdMap = nestedTree2IdMap;
+exports.pcmToWavBlob = pcmToWavBlob;
 exports.randomDateInRange = randomDateInRange;
 exports.randomEnLetter = randomEnLetter;
 exports.randomHan = randomHan;