@openclaw/qqbot 2026.5.20 → 2026.5.22

package/node_modules/@tencent-connect/qqbot-connector/dist/esm/qr-connect.d.ts

@@ -0,0 +1,83 @@
+/**
+ * QR Code Connect — 核心对外接口
+ *
+ * 支持两种使用模式：
+ * 1. Promise 风格：始终在控制台打印二维码，等待扫码后 resolve
+ * 2. 回调风格：可通过 displayQrCodeToConsole 控制是否在控制台打印二维码，
+ *    无论是否打印，onQrDisplayed 都会在轮询开始前回调二维码 URL
+ */
+export interface QrConnectCredentials {
+    appId: string;
+    appSecret: string;
+}
+export interface QrConnectCallbacks {
+    /** 扫码成功，返回凭据 */
+    onSuccess: (credentials: QrConnectCredentials[]) => void;
+    /** 流程失败或被取消 */
+    onFailure: (error: Error) => void;
+    /** 二维码 URL 就绪，在轮询开始前始终触发 */
+    onQrDisplayed?: (url: string) => void;
+    /** 二维码已过期，即将刷新（可选回调） */
+    onQrExpired?: () => void;
+}
+export interface QrConnectOptions {
+    /**
+     * 是否在控制台打印二维码，默认 true。
+     * 在 Promise 风格（qrConnect）下此参数始终为 true，不可关闭。
+     */
+    displayQrCodeToConsole?: boolean;
+    /**
+     * AbortSignal，支持外部取消。
+     * 传入后可通过 AbortController.abort() 中止扫码轮询流程。
+     */
+    signal?: AbortSignal;
+    /** 调用来源标识，会拼接到二维码 URL 中 */
+    source?: string;
+}
+/**
+ * 轮询等待扫码结果（回调风格）。
+ *
+ * 可通过 `options.displayQrCodeToConsole` 控制是否在控制台打印二维码（默认 true）。
+ * 无论是否打印，`onQrDisplayed` 都会在轮询开始前回调二维码 URL。
+ *
+ * @returns 一个 dispose 函数，调用后可中止轮询流程
+ *
+ * @example
+ * ```ts
+ * const stop = startQrConnect({
+ *   onSuccess([{ appId, appSecret }]) {
+ *     console.log('成功', appId, appSecret);
+ *   },
+ *   onFailure(err) {
+ *     console.error('失败', err.message);
+ *   },
+ *   onQrDisplayed(url) {
+ *     // 自行处理二维码 URL，例如生成图片发送给用户
+ *   },
+ * });
+ *
+ * // 需要取消时：
+ * stop();
+ * ```
+ */
+export declare function startQrConnect(callbacks: QrConnectCallbacks, options?: QrConnectOptions): () => void;
+/**
+ * 在控制台展示二维码并轮询等待扫码结果（Promise 风格）。
+ *
+ * 始终在控制台打印二维码（displayQrCodeToConsole 固定为 true）。
+ * 如果需要自行处理二维码 URL（不打印），请使用 {@link startQrConnect} 回调风格。
+ *
+ * @returns Promise 解析为 `QrConnectCredentials[]` 或 reject Error
+ *
+ * @example
+ * ```ts
+ * try {
+ *   const [{ appId, appSecret }] = await qrConnect();
+ *   console.log('成功', appId, appSecret);
+ * } catch (err) {
+ *   console.error('失败', err.message);
+ * }
+ * ```
+ */
+export declare function qrConnect(options?: Omit<QrConnectOptions, 'displayQrCodeToConsole'>): Promise<QrConnectCredentials[]>;
+//# sourceMappingURL=qr-connect.d.ts.map

package/node_modules/@tencent-connect/qqbot-connector/dist/esm/qr-connect.js

@@ -0,0 +1,3 @@
+import d from"qrcode-terminal";import{BindStatus as i,buildConnectUrl as w,createBindTask as b,decryptSecret as f,pollBindResult as A}from"./qqbot-session.js";const l=2e3;function F(o){return new Promise(r=>{d.generate(o,{small:!0},t=>{r(t)})})}function E(o,r){return new Promise((t,n)=>{if(r?.aborted){n(new DOMException("Aborted","AbortError"));return}const e=setTimeout(t,o);r?.addEventListener("abort",()=>{clearTimeout(e),n(new DOMException("Aborted","AbortError"))},{once:!0})})}async function m(o,r,t){for(;!t?.aborted;){let n;try{n=await A(o)}catch{await E(l,t);continue}if(n.status===i.COMPLETED){const e=f(n.botEncryptSecret,r);return{outcome:"scanned",appId:n.botAppId,appSecret:e}}if(n.status===i.EXPIRED)return{outcome:"expired"};await E(l,t)}throw new DOMException("Aborted","AbortError")}function p(o,r){const t=new AbortController,n=r?.signal?AbortSignal.any([t.signal,r.signal]):t.signal;return(async()=>{const e=r?.displayQrCodeToConsole??!0;for(;;){if(n.aborted)throw new DOMException("Aborted","AbortError");let a;try{a=await b()}catch(u){throw new Error(`\u83B7\u53D6\u7ED1\u5B9A\u4EFB\u52A1\u5931\u8D25: ${u instanceof Error?u.message:String(u)}`,{cause:u})}const s=w(a.taskId,r?.source);if(e){const u=await F(s);console.log(u),console.log(`\u8BF7\u4F7F\u7528\u624B\u673A QQ \u626B\u63CF\u4E0A\u65B9\u4E8C\u7EF4\u7801\uFF0C\u5B8C\u6210\u673A\u5668\u4EBA\u7ED1\u5B9A\u3002
+`)}o.onQrDisplayed?.(s);const c=await m(a.taskId,a.key,n);if(c.outcome==="scanned"){o.onSuccess([{appId:c.appId,appSecret:c.appSecret}]);return}o.onQrExpired?.(),e&&console.log(`\u4E8C\u7EF4\u7801\u5DF2\u8FC7\u671F\uFF0C\u6B63\u5728\u5237\u65B0\u2026
+`)}})().catch(e=>{if(e instanceof DOMException&&e.name==="AbortError"){o.onFailure(new Error("\u5DF2\u53D6\u6D88"));return}o.onFailure(e instanceof Error?e:new Error(String(e)))}),()=>t.abort()}function C(o){return new Promise((r,t)=>{p({onSuccess:r,onFailure:t},{...o,displayQrCodeToConsole:!0})})}export{C as qrConnect,p as startQrConnect};

package/node_modules/@tencent-connect/qqbot-connector/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@tencent-connect/qqbot-connector",
+  "version": "1.1.0",
+  "description": "QQ Bot Connector SDK - 扫码连接 QQ 机器人，获取 AppID 与 AppSecret",
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "UNLICENSED",
+  "author": "",
+  "type": "module",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/esm/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    }
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "scripts": {
+    "build": "tsc -b && tsc -p tsconfig.cjs.json && node scripts/fix-cjs.js && node scripts/obfuscate.js",
+    "typecheck": "tsc --noEmit",
+    "commitlint": "commitlint",
+    "prepack": "npm run build",
+    "posttest": "npm run lint",
+    "lint": "eslint .",
+    "ci:prepare-test-pkg": "node scripts/prepare-test-pkg.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "semantic-release": "semantic-release"
+  },
+  "dependencies": {
+    "qrcode-terminal": "^0.12"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^20.5.0",
+    "@commitlint/config-conventional": "^20.5.0",
+    "@eslint/js": "^10.0.1",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/exec": "^7.1.0",
+    "@semantic-release/git": "^10.0.1",
+    "@types/node": "^22",
+    "@types/qrcode-terminal": "^0.12.2",
+    "@vitest/coverage-v8": "^4.1.2",
+    "esbuild": "^0.28.0",
+    "eslint": "^10.1.0",
+    "globals": "^17.4.0",
+    "semantic-release": "^25.0.3",
+    "typescript": "^5",
+    "typescript-eslint": "^8.57.2",
+    "vitest": "^4.1.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/node_modules/@wasm-audio-decoders/common/index.js

@@ -0,0 +1,5 @@
+import WASMAudioDecoderCommon from "./src/WASMAudioDecoderCommon.js";
+import WASMAudioDecoderWorker from "./src/WASMAudioDecoderWorker.js";
+import { assignNames } from "./src/utilities.js";
+
+export { WASMAudioDecoderCommon, WASMAudioDecoderWorker, assignNames };

package/node_modules/@wasm-audio-decoders/common/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@wasm-audio-decoders/common",
+  "version": "9.0.7",
+  "description": "Web Assembly Audio Decoders Common",
+  "module": "index.js",
+  "main": "index.js",
+  "exports": {
+    "types": "./types.d.ts",
+    "default": "./index.js"
+  },
+  "types": "types.d.ts",
+  "sideEffects": false,
+  "files": [
+    "index.js",
+    "types.d.ts",
+    "src/*"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eshaz/wasm-audio-decoders.git"
+  },
+  "type": "module",
+  "author": {
+    "name": "Ethan Halsall",
+    "email": "ethanhalsall@pm.me"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/eshaz/wasm-audio-decoders/issues"
+  },
+  "homepage": "https://github.com/eshaz/wasm-audio-decoders/tree/master/src/common",
+  "dependencies": {
+    "@eshaz/web-worker": "1.2.2",
+    "simple-yenc": "^1.0.4"
+  }
+}

package/node_modules/@wasm-audio-decoders/common/src/WASMAudioDecoderCommon.js

@@ -0,0 +1,231 @@
+import { decode } from "simple-yenc";
+
+export default function WASMAudioDecoderCommon() {
+  // setup static methods
+  const uint8Array = Uint8Array;
+  const float32Array = Float32Array;
+
+  if (!WASMAudioDecoderCommon.modules) {
+    Object.defineProperties(WASMAudioDecoderCommon, {
+      modules: {
+        value: new WeakMap(),
+      },
+
+      setModule: {
+        value(Ref, module) {
+          WASMAudioDecoderCommon.modules.set(Ref, Promise.resolve(module));
+        },
+      },
+
+      getModule: {
+        value(Ref, wasmString) {
+          let module = WASMAudioDecoderCommon.modules.get(Ref);
+
+          if (!module) {
+            if (!wasmString) {
+              wasmString = Ref.wasm;
+              module = WASMAudioDecoderCommon.inflateDynEncodeString(
+                wasmString,
+              ).then((data) => WebAssembly.compile(data));
+            } else {
+              module = WebAssembly.compile(decode(wasmString));
+            }
+
+            WASMAudioDecoderCommon.modules.set(Ref, module);
+          }
+
+          return module;
+        },
+      },
+
+      concatFloat32: {
+        value(buffers, length) {
+          let ret = new float32Array(length),
+            i = 0,
+            offset = 0;
+
+          while (i < buffers.length) {
+            ret.set(buffers[i], offset);
+            offset += buffers[i++].length;
+          }
+
+          return ret;
+        },
+      },
+
+      getDecodedAudio: {
+        value: (errors, channelData, samplesDecoded, sampleRate, bitDepth) => ({
+          errors,
+          channelData,
+          samplesDecoded,
+          sampleRate,
+          bitDepth,
+        }),
+      },
+
+      getDecodedAudioMultiChannel: {
+        value(
+          errors,
+          input,
+          channelsDecoded,
+          samplesDecoded,
+          sampleRate,
+          bitDepth,
+        ) {
+          let channelData = [],
+            i,
+            j;
+
+          for (i = 0; i < channelsDecoded; i++) {
+            const channel = [];
+            for (j = 0; j < input.length; ) channel.push(input[j++][i] || []);
+            channelData.push(
+              WASMAudioDecoderCommon.concatFloat32(channel, samplesDecoded),
+            );
+          }
+
+          return WASMAudioDecoderCommon.getDecodedAudio(
+            errors,
+            channelData,
+            samplesDecoded,
+            sampleRate,
+            bitDepth,
+          );
+        },
+      },
+
+      /*
+       ******************
+       * Compression Code
+       ******************
+       */
+
+      inflateDynEncodeString: {
+        value(source) {
+          source = decode(source);
+
+          return new Promise((resolve) => {
+            // prettier-ignore
+            const puffString = String.raw`dynEncode012804c7886d(‰›•)((()>+ˆ*§§)§ˆ,§§§§)§ˆ+§§§)§+.-()(*)-+)(ˆ.7*§)i¸¸,3§(i¸¸,3/G+.••—š¡*(,˜ŽŽ(,3‡‡‰˜‡Š‰›+)2å:-œ),§H(P*DI*H(P*@I++hH)H*r,hH(H(P*<J,i)’^*<H,H(P*4’U((I-H(H*i0’J,^*DH+H-H*œšI+H,I*4)33H(H*H)“^*DH(H+H)^*@H+i§H)œi§›™3æ*).§K(iH“I/+§H,iHn,§H+i(H+i(rCJ0I,H*I-+hH,,hH(H-V)(i)œ’J.H.W)(i)’c)(H,i)“I,H-i*’I-4)33i(I.*hH(V)(H+n5(H(i*’I-i(I,i)I.+hH,i*’J+iHn,hi(I-i*I,+hH,H/’H-c)(H,iFn,hi(I,+hH,H0n5-H*V)(J(,hH/H(i)œ’J(H(V)(J(i)’c)(H)H(i)œ’H,c)(3H*i*’I*H,i)’I,4(3(-H(H,’W)(H-’I-H,i*’I,4)3(3(3H,H-’I1H+I,H.i)œH1V)(“J.i(v5(33H.-H(H,’i(c)(H,i*’I,4)333–)-§i*I*+§H*iHn,hiž73H,H(i)8(H+šJ+H)P*(H*’V)(J-“r,§H)P*,H.i)œ’H+H,“i)œ’V)(-H*i*’I*H+i)œI+H-H.’I.H,H-’i)œI,4)333Ã+)-§iø7i(^*(iü7I,*h+hH+iDn,h*hilI+i)I,+hH+,hH+iô7’H,c)(i)H+i´8’W)(œH,’I,H+i*’I+4)-+hH(H)8*J-i(p5.*h*h*hH-i')u,hH(P*(J+,hH(P*0J,H(P*,n50H+H,’H-b((3H(P*0i)’I.4)3H-i¨*n5*H-iÅ*s,hiž73H-i)œJ+V)&+I,H(H+V)æ,8(I.H(H*8*J-i(p51H-i)œJ+i¸7’V)(H(H+iø7’V)(8(’J/H(P*0J+s,hi73H+H,H.’J,’I.H(P*(m5(H.H(P*,s5.+hH,m5*H(P*(J.H+’H.H+H/“’U((b((H(H(P*0i)’J+^*0H,i)“I,4(3(3H(H.^*03H-i¨*o5)33i(73(3(3-H,H+i)žc)(H,i*’I,H+i)’I+4)33i)I-3H-3!2)0§K(i2“J,L(H,H(^*(H,H*^*4H,i(^*0H,i(^*DH,j(_*<H,H)P*(^*,H,H+P*(^*8*h*h+hH,i)8(I3i§I**h*h*h*h*h*h*hH,i*8(6+(),03H,j(_*@i*I-H,P*<J.i,’J(H,P*8J/s50H,H.i+’J0^*<i¦I*H.H,P*4J1’J.U(*H.U((J2›i')o5/H.U()I.H,H(^*<H0H1’U((H.i0œJ.i§›i0ži')™o5/H/H.H2šJ*H(’J.q50H,P*0J/H*’I-H,P*(J0,hH,P*,H-q,hi)I-423+hH*m5+H/H0’H(H1’U((b((H/i)’I/H(i)’I(H*i)“I*4(3(3H,H.^*<H,H-^*04*3iØ1U((5+i(I(i¨7i1^*(i$6iè1^*(i°7iè6^*(i¬7iÈ6^*(+hH(iÈ*n,hiÈ*I(+hH(i¨,n,hi¨,I(+hH(iØ,n,hiØ,I(+hH(iè,o,hH,i-’H(’i0c)(H(i*’I(4)33iè1i1H,i-’iÈ*8)Bi(I(+hH(ido,hH,i-’H(’i-c)(H(i*’I(4)33iÈ6iè6H,i-’iF8)BiØ1i)b((41-H,i-’H(’i/c)(H(i*’I(4)3(3(-H,i-’H(’i1c)(H(i*’I(4)3(3(-H,i-’H(’i0c)(H(i*’I(4)3(3(3H,H/^*0H,H(^*<3i(I*4*3H,H,i¸)’^*TH,H,iø-’^*PH,H,iX’^*LH,H,i(’^*HH,i-8(I(H,i-8(I-i¥I*H,i,8(I.H(iErH-iErš5)H(i©*’I1H-i)’I0i(i;H.i,’J(i(H(i(rCJ(“J*H*i;sCI*i¨1I-H(I/+hH/,hH,i-’H-V)(i)œ’H,i+8(c)(H/i)“I/H-i*’I-H*i)’I*4)-H(i)œi¨1’I/+hH(H*o,hH,i-’H/V)(i)œ’i(c)(H/i*’I/H(i)’I(4)33i¤I*H,iø-’H,i¸)’H,i-’i;8)5+H0H1’I2i(I-+hH-H2p,hH,H,iP’8*J*i(p5-H*i7u,hH,i-’H-i)œ’H*c)(H-i)’I-4*3i(I/i+I.i+I(*h*h*hH*i8“6*(*)3H-m,hi£I*403H-i)œH,’W)-I/i*I(4)3i3I.i/I(3H2H,H(8(H.’J(H-’J.p,hi¢I*4.3H,i-’H-i)œ’I*+hH(,hH*H/c)(H*i*’I*H(i)“I(4)-H.I-4+3(3(33H,W)1m,hiŸI*4,3H,iø-’H,i¸)’H,i-’H18)J(,hi¡I*H(i(p5,H1H,V)ú-H,V)ø-’o5,3H,i(’H,iX’H,i-’H1i)œ’H08)J(,hi I*H(i(p5,H0H,V)šH,V)˜’o5,3H,H,iP’H,iH’8+I*4+3(3(3H,i$6i¬78+I*3H*H3šm5(3i)I-H*i(r5)3H)H,P*0^*(H+H,P*<^*(H*I-3H,i2’L(H-33Á)+(i¨03b+(,(-(.(/(0(1(2(3(5(7(9(;(?(C(G(K(S([(c(k({(‹(›(«(Ë(ë((*)(iø03O)()()()(*(*(*(*(+(+(+(+(,(,(,(,(-(-(-(-(i¨13M8(9(:(((0(/(1(.(2(-(3(,(4(+(5(*(6()(7(T7œ‰šœ‡Ž‰œš›*S7•œ‰Š”U”—Š‰”›S0›‘–U œ`;
+
+            WASMAudioDecoderCommon.getModule(WASMAudioDecoderCommon, puffString)
+              .then((wasm) => WebAssembly.instantiate(wasm, {}))
+              .then(({ exports }) => {
+                // required for minifiers that mangle the __heap_base property
+                const instanceExports = new Map(Object.entries(exports));
+
+                const puff = instanceExports.get("puff");
+                const memory = instanceExports.get("memory")["buffer"];
+                const dataArray = new uint8Array(memory);
+                const heapView = new DataView(memory);
+
+                let heapPos = instanceExports.get("__heap_base");
+
+                // source length
+                const sourceLength = source.length;
+                const sourceLengthPtr = heapPos;
+                heapPos += 4;
+                heapView.setInt32(sourceLengthPtr, sourceLength, true);
+
+                // source data
+                const sourcePtr = heapPos;
+                heapPos += sourceLength;
+                dataArray.set(source, sourcePtr);
+
+                // destination length
+                const destLengthPtr = heapPos;
+                heapPos += 4;
+                heapView.setInt32(
+                  destLengthPtr,
+                  dataArray.byteLength - heapPos,
+                  true,
+                );
+
+                // destination data fills in the rest of the heap
+                puff(heapPos, destLengthPtr, sourcePtr, sourceLengthPtr);
+
+                resolve(
+                  dataArray.slice(
+                    heapPos,
+                    heapPos + heapView.getInt32(destLengthPtr, true),
+                  ),
+                );
+              });
+          });
+        },
+      },
+    });
+  }
+
+  Object.defineProperty(this, "wasm", {
+    enumerable: true,
+    get: () => this._wasm,
+  });
+
+  this.getOutputChannels = (outputData, channelsDecoded, samplesDecoded) => {
+    let output = [],
+      i = 0;
+
+    while (i < channelsDecoded)
+      output.push(
+        outputData.slice(
+          i * samplesDecoded,
+          i++ * samplesDecoded + samplesDecoded,
+        ),
+      );
+
+    return output;
+  };
+
+  this.allocateTypedArray = (len, TypedArray, setPointer = true) => {
+    const ptr = this._wasm.malloc(TypedArray.BYTES_PER_ELEMENT * len);
+    if (setPointer) this._pointers.add(ptr);
+
+    return {
+      ptr: ptr,
+      len: len,
+      buf: new TypedArray(this._wasm.HEAP, ptr, len),
+    };
+  };
+
+  this.free = () => {
+    this._pointers.forEach((ptr) => {
+      this._wasm.free(ptr);
+    });
+    this._pointers.clear();
+  };
+
+  this.codeToString = (ptr) => {
+    const characters = [],
+      heap = new Uint8Array(this._wasm.HEAP);
+    for (let character = heap[ptr]; character !== 0; character = heap[++ptr])
+      characters.push(character);
+
+    return String.fromCharCode.apply(null, characters);
+  };
+
+  this.addError = (
+    errors,
+    message,
+    frameLength,
+    frameNumber,
+    inputBytes,
+    outputSamples,
+  ) => {
+    errors.push({
+      message: message,
+      frameLength: frameLength,
+      frameNumber: frameNumber,
+      inputBytes: inputBytes,
+      outputSamples: outputSamples,
+    });
+  };
+
+  this.instantiate = (_EmscriptenWASM, _module) => {
+    if (_module) WASMAudioDecoderCommon.setModule(_EmscriptenWASM, _module);
+    this._wasm = new _EmscriptenWASM(WASMAudioDecoderCommon).instantiate();
+    this._pointers = new Set();
+
+    return this._wasm.ready.then(() => this);
+  };
+}

package/node_modules/@wasm-audio-decoders/common/src/WASMAudioDecoderWorker.js

@@ -0,0 +1,129 @@
+import NodeWorker from "@eshaz/web-worker";
+import WASMAudioDecoderCommon from "./WASMAudioDecoderCommon.js";
+
+const getWorker = () => globalThis.Worker || NodeWorker;
+
+export default class WASMAudioDecoderWorker extends getWorker() {
+  constructor(options, name, Decoder, EmscriptenWASM) {
+    if (!WASMAudioDecoderCommon.modules) new WASMAudioDecoderCommon();
+
+    let source = WASMAudioDecoderCommon.modules.get(Decoder);
+
+    if (!source) {
+      let type = "text/javascript",
+        isNode,
+        webworkerSourceCode =
+          "'use strict';" +
+          // dependencies need to be manually resolved when stringifying this function
+          `(${((_Decoder, _WASMAudioDecoderCommon, _EmscriptenWASM) => {
+            // We're in a Web Worker
+
+            // setup Promise that will be resolved once the WebAssembly Module is received
+            let decoder,
+              moduleResolve,
+              modulePromise = new Promise((resolve) => {
+                moduleResolve = resolve;
+              });
+
+            self.onmessage = ({ data: { id, command, data } }) => {
+              let messagePromise = modulePromise,
+                messagePayload = { id },
+                transferList;
+
+              if (command === "init") {
+                Object.defineProperties(_Decoder, {
+                  WASMAudioDecoderCommon: { value: _WASMAudioDecoderCommon },
+                  EmscriptenWASM: { value: _EmscriptenWASM },
+                  module: { value: data.module },
+                  isWebWorker: { value: true },
+                });
+
+                decoder = new _Decoder(data.options);
+                moduleResolve();
+              } else if (command === "free") {
+                decoder.free();
+              } else if (command === "ready") {
+                messagePromise = messagePromise.then(() => decoder.ready);
+              } else if (command === "reset") {
+                messagePromise = messagePromise.then(() => decoder.reset());
+              } else {
+                // "decode":
+                // "decodeFrame":
+                // "decodeFrames":
+                Object.assign(
+                  messagePayload,
+                  decoder[command](
+                    // detach buffers
+                    Array.isArray(data)
+                      ? data.map((data) => new Uint8Array(data))
+                      : new Uint8Array(data),
+                  ),
+                );
+                // The "transferList" parameter transfers ownership of channel data to main thread,
+                // which avoids copying memory.
+                transferList = messagePayload.channelData
+                  ? messagePayload.channelData.map((channel) => channel.buffer)
+                  : [];
+              }
+
+              messagePromise.then(() =>
+                self.postMessage(messagePayload, transferList),
+              );
+            };
+          }).toString()})(${Decoder}, ${WASMAudioDecoderCommon}, ${EmscriptenWASM})`;
+
+      try {
+        isNode = typeof process.versions.node !== "undefined";
+      } catch {}
+
+      source = isNode
+        ? `data:${type};base64,${Buffer.from(webworkerSourceCode).toString(
+            "base64",
+          )}`
+        : URL.createObjectURL(new Blob([webworkerSourceCode], { type }));
+
+      WASMAudioDecoderCommon.modules.set(Decoder, source);
+    }
+
+    super(source, { name });
+
+    this._id = Number.MIN_SAFE_INTEGER;
+    this._enqueuedOperations = new Map();
+
+    this.onmessage = ({ data }) => {
+      const { id, ...rest } = data;
+      this._enqueuedOperations.get(id)(rest);
+      this._enqueuedOperations.delete(id);
+    };
+
+    new EmscriptenWASM(WASMAudioDecoderCommon).getModule().then((module) => {
+      this.postToDecoder("init", { module, options });
+    });
+  }
+
+  async postToDecoder(command, data) {
+    return new Promise((resolve) => {
+      this.postMessage({
+        command,
+        id: this._id,
+        data,
+      });
+
+      this._enqueuedOperations.set(this._id++, resolve);
+    });
+  }
+
+  get ready() {
+    return this.postToDecoder("ready");
+  }
+
+  async free() {
+    await this.postToDecoder("free").finally(() => {
+      this.terminate();
+    });
+  }
+
+  async reset() {
+    await this.postToDecoder("reset");
+  }
+}

package/node_modules/@wasm-audio-decoders/common/src/puff/README

@@ -0,0 +1,67 @@
+This copy of puff has been altered from the original to be inlined into this library.
+
+See the original code for puff here: https://github.com/madler/zlib/tree/master/contrib/puff
+
+Puff -- A Simple Inflate
+3 Mar 2003
+Mark Adler
+madler@alumni.caltech.edu
+
+What this is --
+
+puff.c provides the routine puff() to decompress the deflate data format.  It
+does so more slowly than zlib, but the code is about one-fifth the size of the
+inflate code in zlib, and written to be very easy to read.
+
+Why I wrote this --
+
+puff.c was written to document the deflate format unambiguously, by virtue of
+being working C code.  It is meant to supplement RFC 1951, which formally
+describes the deflate format.  I have received many questions on details of the
+deflate format, and I hope that reading this code will answer those questions.
+puff.c is heavily commented with details of the deflate format, especially
+those little nooks and cranies of the format that might not be obvious from a
+specification.
+
+puff.c may also be useful in applications where code size or memory usage is a
+very limited resource, and speed is not as important.
+
+How to use it --
+
+Well, most likely you should just be reading puff.c and using zlib for actual
+applications, but if you must ...
+
+Include puff.h in your code, which provides this prototype:
+
+int puff(unsigned char *dest,           /* pointer to destination pointer */
+         unsigned long *destlen,        /* amount of output space */
+         unsigned char *source,         /* pointer to source data pointer */
+         unsigned long *sourcelen);     /* amount of input available */
+
+Then you can call puff() to decompress a deflate stream that is in memory in
+its entirety at source, to a sufficiently sized block of memory for the
+decompressed data at dest.  puff() is the only external symbol in puff.c  The
+only C library functions that puff.c needs are setjmp() and longjmp(), which
+are used to simplify error checking in the code to improve readabilty.  puff.c
+does no memory allocation, and uses less than 2K bytes off of the stack.
+
+If destlen is not enough space for the uncompressed data, then inflate will
+return an error without writing more than destlen bytes.  Note that this means
+that in order to decompress the deflate data successfully, you need to know
+the size of the uncompressed data ahead of time.
+
+If needed, puff() can determine the size of the uncompressed data with no
+output space.  This is done by passing dest equal to (unsigned char *)0.  Then
+the initial value of *destlen is ignored and *destlen is set to the length of
+the uncompressed data.  So if the size of the uncompressed data is not known,
+then two passes of puff() can be used--first to determine the size, and second
+to do the actual inflation after allocating the appropriate memory.  Not
+pretty, but it works.  (This is one of the reasons you should be using zlib.)
+
+The deflate format is self-terminating.  If the deflate stream does not end
+in *sourcelen bytes, puff() will return an error without reading at or past
+endsource.
+
+On return, *sourcelen is updated to the amount of input data consumed, and
+*destlen is updated to the size of the uncompressed data.  See the comments
+in puff.c for the possible return codes for puff().

package/node_modules/@wasm-audio-decoders/common/src/puff/build_puff.js

@@ -0,0 +1,31 @@
+import fs from "fs";
+import { dynamicEncode } from "simple-yenc";
+
+const puffWasmPath = "src/common/src/puff/Puff.wasm";
+const wasmCommonPath = "src/common/src/WASMAudioDecoderCommon.js";
+
+const puffWasm = fs.readFileSync(puffWasmPath);
+
+const puffEncoded = dynamicEncode(puffWasm, "`");
+
+const wasmCommon = fs.readFileSync(wasmCommonPath).toString();
+
+const puffString = wasmCommon.match(/const puffString = String.raw`.*`;/s)[0];
+
+const wasmStartIdx = wasmCommon.indexOf(puffString);
+const wasmEndIdx = wasmStartIdx + puffString.length;
+
+// Concatenate the strings as buffers to preserve extended ascii
+const wasmCommonWithPuff = Buffer.concat(
+  [
+    wasmCommon.substring(0, wasmStartIdx),
+    "const puffString = String.raw`",
+    puffEncoded,
+    "`;",
+    wasmCommon.substring(wasmEndIdx),
+  ].map((string) => Buffer.from(string, { encoding: "binary" })),
+);
+
+fs.writeFileSync(wasmCommonPath, wasmCommonWithPuff, { encoding: "binary" });
+
+console.log(puffWasm.length);