@cloudpss/ubjson 0.5.53 → 0.6.0-alpha.1

package/src/base/encoder.ts

@@ -24,7 +24,7 @@ export abstract class EncoderBase {
     /** 当前写指针位置 */
     protected length = 0;
     /** 数据 */
-    protected data!: Uint8Array;
+    protected data!: Uint8Array<ArrayBuffer>;
     /** buffer 的 DataView */
     protected view!: DataView;
     /**
@@ -43,12 +43,15 @@ export abstract class EncoderBase {
     }
     /** 写入一个对象 */
     private write(value: unknown): void {
+        // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
         switch (typeof value) {
             case 'string':
+                // eslint-disable-next-line unicorn/prefer-code-point
                 if (value.length === 1 && value.charCodeAt(0) < 0x80) {
                     // 1 byte ascii char
                     this.ensureCapacity(2);
                     this.data[this.length++] = constants.CHAR;
+                    // eslint-disable-next-line unicorn/prefer-code-point
                     this.data[this.length++] = value.charCodeAt(0);
                 } else {
                     this.ensureCapacity(2);

package/src/encoder.ts

@@ -6,7 +6,7 @@ const MAX_SIZE = 1024 * 1024 * 128; //128 MiB
 
 /** 编码至 ubjson */
 export class Encoder extends EncoderBase {
-    private readonly flushedBuffers: Uint8Array[] = [];
+    private readonly flushedBuffers: Array<Uint8Array<ArrayBuffer>> = [];
     /** 通过内存池减少分配 */
     private readonly pool = new Uint8Array(BLOCK_SIZE);
     /** 缓存当前容量，避免对象访问耗时 */
@@ -55,7 +55,7 @@ export class Encoder extends EncoderBase {
     }
 
     /** 获取结果 */
-    private getResult(): Uint8Array {
+    private getResult(): Uint8Array<ArrayBuffer> {
         if (this.flushedBuffers.length === 0) {
             // 缓冲区为空，复制当前 buffer
             return this.data.slice(0, this.length);
@@ -82,7 +82,7 @@ export class Encoder extends EncoderBase {
     }
 
     /** 获取写入结果 */
-    encode(value: unknown): Uint8Array {
+    encode(value: unknown): Uint8Array<ArrayBuffer> {
         try {
             this.allocUnsafe(BLOCK_SIZE);
             this.writeValue(value);
@@ -94,7 +94,7 @@ export class Encoder extends EncoderBase {
     }
 
     /** 获取写入结果 */
-    encodeMany(value: Iterable<unknown>): Uint8Array {
+    encodeMany(value: Iterable<unknown>): Uint8Array<ArrayBuffer> {
         try {
             this.allocUnsafe(BLOCK_SIZE);
             for (const v of value) {

package/src/helper/decode-ae.ts

@@ -17,7 +17,7 @@ export interface DecodeCursorAe {
     /** 当前数据块 */
     readonly view: DataView;
     /** 当前数据块 */
-    readonly data: Uint8Array;
+    readonly data: Uint8Array<ArrayBuffer>;
     /** 当前数据大小 */
     readonly size: number;
     /** 当前读指针位置 */

package/src/helper/decode.ts

@@ -11,7 +11,7 @@ export interface DecodeCursor {
     /** 数据 */
     readonly view: DataView;
     /** 数据 */
-    readonly data: Uint8Array;
+    readonly data: Uint8Array<ArrayBuffer>;
     /** 当前读指针位置 */
     offset: number;
     /** 读取到末尾时调用 */

package/src/helper/encode.ts

@@ -6,7 +6,7 @@ export interface EncodeCursor {
     /** 数据 */
     readonly view: DataView;
     /** 数据 */
-    readonly data: Uint8Array;
+    readonly data: Uint8Array<ArrayBuffer>;
     /** 当前写指针位置 */
     length: number;
     /** 确保 buffer 还有 capacity 的空闲空间 */

package/src/helper/string-encoder.ts

@@ -1,3 +1,4 @@
+/* eslint-disable unicorn/prefer-code-point */
 // https://github.com/ehmicky/string-byte-length/blob/main/src/char_code.js
 
 // Last ASCII character (1 byte)
@@ -127,11 +128,11 @@ export function myEncodeInto(v: string, buf: Uint8Array, offset: number): number
  * Encode string into utf-8.
  * Provided `buf` MUST have enough space.
  */
-export let encodeInto: (v: string, buf: Uint8Array, offset: number) => number;
+export let encodeInto: <T extends ArrayBufferLike>(v: string, buf: Uint8Array<T>, offset: number) => number;
 /**
  * Encode string into utf-8.
  */
-export let encode: (v: string) => Uint8Array;
+export let encode: (v: string) => Uint8Array<ArrayBuffer>;
 
 /** 重设环境 */
 export function resetEnv(): void {

package/src/helper/utils.ts

@@ -1,5 +1,5 @@
 /** 支持的数据转为 Uint8Array */
-export function toUint8Array(data: BufferSource): Uint8Array {
+export function toUint8Array(data: BufferSource): Uint8Array<ArrayBuffer> {
     if (data == null || typeof data != 'object' || typeof data.byteLength != 'number') {
         throw new TypeError('Invalid data');
     }

package/src/index.ts

@@ -6,12 +6,12 @@ export { UnexpectedEofError as UnexpectedEof } from './helper/errors.js';
 export type { EncodeOptions, DecodeOptions };
 
 /** 编码为 UBJSON */
-export function encode(value: unknown, options?: EncodeOptions): Uint8Array {
+export function encode(value: unknown, options?: EncodeOptions): Uint8Array<ArrayBuffer> {
     return getEncoder(options).encode(value);
 }
 
 /** 编码为 UBJSON */
-export function encodeMany(value: Iterable<unknown>, options?: EncodeOptions): Uint8Array {
+export function encodeMany(value: Iterable<unknown>, options?: EncodeOptions): Uint8Array<ArrayBuffer> {
     return getEncoder(options).encodeMany(value);
 }
 

package/src/rxjs/encoder.ts

@@ -3,10 +3,10 @@ import { StreamEncoderHelper } from '../stream-helper/encoder.js';
 import type { EncodeOptions } from '../options.js';
 
 /** 流式编码 UBJSON */
-export function encode(options?: EncodeOptions): OperatorFunction<unknown, Uint8Array> {
+export function encode(options?: EncodeOptions): OperatorFunction<unknown, Uint8Array<ArrayBuffer>> {
     return (observable) => {
-        return new Observable<Uint8Array>((subscriber) => {
-            const helper = new StreamEncoderHelper(options, (chunk: Uint8Array): void => subscriber.next(chunk));
+        return new Observable<Uint8Array<ArrayBuffer>>((subscriber) => {
+            const helper = new StreamEncoderHelper(options, (chunk) => subscriber.next(chunk));
             const sub = observable.subscribe({
                 next(value) {
                     try {

package/src/stream/encoder.ts

@@ -2,23 +2,23 @@ import { StreamEncoderHelper } from '../stream-helper/encoder.js';
 import type { EncodeOptions } from '../options.js';
 
 /** 流式编码 UBJSON */
-export class EncodeTransformer implements Transformer<unknown, Uint8Array> {
+export class EncodeTransformer implements Transformer<unknown, Uint8Array<ArrayBuffer>> {
     constructor(options?: EncodeOptions) {
         this.helper = new StreamEncoderHelper(options, (binary) => {
             this.controller.enqueue(binary);
         });
     }
     private readonly helper;
-    private controller!: TransformStreamDefaultController<Uint8Array>;
+    private controller!: TransformStreamDefaultController<Uint8Array<ArrayBuffer>>;
 
     /** @inheritdoc */
-    transform(obj: unknown, controller: TransformStreamDefaultController<Uint8Array>): void {
+    transform(obj: unknown, controller: TransformStreamDefaultController<Uint8Array<ArrayBuffer>>): void {
         this.controller = controller;
         this.helper.encode(obj);
     }
 
     /** @inheritdoc */
-    flush(controller: TransformStreamDefaultController<Uint8Array>): void {
+    flush(controller: TransformStreamDefaultController<Uint8Array<ArrayBuffer>>): void {
         this.controller = controller;
         this.helper.destroy();
         controller.terminate();

package/src/stream/index.ts

@@ -7,7 +7,7 @@ export { UnexpectedEofError as UnexpectedEof } from '../helper/errors.js';
 export type { EncodeOptions, DecodeOptions };
 
 /** 编码为 UBJSON */
-export function encode(value: unknown, options?: EncodeOptions): ReadableStream<Uint8Array> {
+export function encode(value: unknown, options?: EncodeOptions): ReadableStream<Uint8Array<ArrayBuffer>> {
     if (value == null) {
         return new ReadableStream({
             type: 'bytes',
@@ -27,7 +27,10 @@ export function encode(value: unknown, options?: EncodeOptions): ReadableStream<
 }
 
 /** 编码为 UBJSON */
-export function encodeMany(value: AsyncIterable<unknown>, options?: EncodeOptions): ReadableStream<Uint8Array> {
+export function encodeMany(
+    value: AsyncIterable<unknown>,
+    options?: EncodeOptions,
+): ReadableStream<Uint8Array<ArrayBuffer>> {
     return new ReadableStream<unknown>({
         async start(controller) {
             for await (const v of value) {
@@ -40,12 +43,12 @@ export function encodeMany(value: AsyncIterable<unknown>, options?: EncodeOption
 }
 
 /** 编码为 UBJSON */
-export function encoder(options?: EncodeOptions): TransformStream<unknown, Uint8Array> {
+export function encoder(options?: EncodeOptions): TransformStream<unknown, Uint8Array<ArrayBuffer>> {
     return new TransformStream(new EncodeTransformer(options));
 }
 
 /** 解码 UBJSON */
-export async function decode(stream: ReadableStream<Uint8Array>, options?: DecodeOptions): Promise<unknown> {
+export async function decode(stream: ReadableStream<BufferSource>, options?: DecodeOptions): Promise<unknown> {
     const s = stream.pipeThrough(decoder(options));
     const r = s.getReader();
     const result = await r.read();
@@ -54,7 +57,10 @@ export async function decode(stream: ReadableStream<Uint8Array>, options?: Decod
 }
 
 /** 解码 UBJSON */
-export async function* decodeMany(stream: ReadableStream<Uint8Array>, options?: DecodeOptions): AsyncIterable<unknown> {
+export async function* decodeMany(
+    stream: ReadableStream<BufferSource>,
+    options?: DecodeOptions,
+): AsyncIterable<unknown> {
     const s = stream.pipeThrough(decoder(options));
     const r = s.getReader();
     for (;;) {
@@ -65,6 +71,6 @@ export async function* decodeMany(stream: ReadableStream<Uint8Array>, options?:
 }
 
 /** 解码 UBJSON */
-export function decoder(options?: DecodeOptions): TransformStream<Uint8Array, unknown> {
+export function decoder(options?: DecodeOptions): TransformStream<BufferSource, unknown> {
     return new TransformStream(new DecodeTransformer(options));
 }

package/src/stream-helper/encoder.ts

@@ -8,10 +8,10 @@ const BLOCK_SIZE = 1024 * 64; // 64 KiB
 const MAX_SIZE = 1024 * 1024 * 32; // 32 MiB
 
 /** 保存一个内存池以减少重复分配 */
-let POOL: Uint8Array | null = null;
+let POOL: Uint8Array<ArrayBuffer> | null = null;
 
 /** 获取内存池 */
-function alloc(size: number): Uint8Array {
+function alloc(size: number): Uint8Array<ArrayBuffer> {
     if (POOL == null || size !== BLOCK_SIZE) {
         return new Uint8Array(size);
     }
@@ -21,7 +21,7 @@ function alloc(size: number): Uint8Array {
 }
 
 /** 归还内存池 */
-function free(buf: Uint8Array): boolean {
+function free(buf: Uint8Array<ArrayBuffer>): boolean {
     if (POOL == null && buf.byteLength === BLOCK_SIZE) {
         POOL = buf;
         return true;
@@ -33,7 +33,7 @@ function free(buf: Uint8Array): boolean {
 export class StreamEncoderHelper extends EncoderBase {
     constructor(
         options: EncodeOptions | null | undefined,
-        protected readonly onChunk: (chunk: Uint8Array) => void,
+        protected readonly onChunk: (chunk: Uint8Array<ArrayBuffer>) => void,
     ) {
         super();
         this.sortObjectKeys = options?.sortObjectKeys ?? false;
@@ -45,9 +45,9 @@ export class StreamEncoderHelper extends EncoderBase {
      */
     destroy(): void {
         free(this.data);
-        const self = this as unknown as { view: DataView | null; buffer: Uint8Array | null };
+        const self = this as unknown as { view: DataView | null; data: Uint8Array<ArrayBuffer> | null };
         self.view = null;
-        self.buffer = null;
+        self.data = null;
     }
     /**
      * 确保 buffer 还有 capacity 的空闲空间
@@ -95,6 +95,7 @@ export class StreamEncoderHelper extends EncoderBase {
         for (let i = 0; i < strLen; i += BLOCK_SIZE) {
             let end = i + BLOCK_SIZE;
             // avoid split surrogate pair
+            // eslint-disable-next-line unicorn/prefer-code-point
             const endAtSurrogate = end < strLen && (value.charCodeAt(end) & 0xfc00) === 0xdc00;
             if (endAtSurrogate) {
                 end--;
@@ -107,7 +108,7 @@ export class StreamEncoderHelper extends EncoderBase {
         }
     }
     /** @inheritdoc */
-    protected override writeLargeTypedArrayData(type: TypedArrayType, value: ArrayBufferView): void {
+    protected override writeLargeTypedArrayData(type: TypedArrayType, value: ArrayBufferView<ArrayBuffer>): void {
         this.ensureCapacity(-1);
         const { byteLength } = value;
         if (type === constants.UINT8 || type === constants.INT8) {

package/tests/{decode.js → decode.ts}

@@ -3,7 +3,7 @@
  */
 
 import { decode, UnexpectedEof } from '../dist/index.js';
-import { toBuffer } from './.utils.js';
+import { toBuffer } from './.utils.ts';
 
 test('decode unsupported type', () => {
     expect(() => decode(toBuffer('!'))).toThrow();
@@ -507,17 +507,18 @@ test('decode (eof at key)', () => {
 
 describe('proto poisoning attack', () => {
     it('should remove __proto__ key', () => {
-        const obj = /** @type {Record<string, unknown>} */ (
-            decode(toBuffer('{', 'i', 9, '__proto__', '{', 'i', 1, 'a', 'S', 'i', 3, 'abc', '}', '}'))
+        const obj = /** @type {Record<string, unknown>} */ decode(
+            toBuffer('{', 'i', 9, '__proto__', '{', 'i', 1, 'a', 'S', 'i', 3, 'abc', '}', '}'),
         );
         expect(Object.hasOwn(obj, '__proto__')).toBe(false);
         expect(obj['__proto__']).toBe(Object.prototype);
     });
     it('should allow __proto__ key', () => {
-        const obj = /** @type {Record<string, unknown>} */ (
-            decode(toBuffer('{', 'i', 9, '__proto__', '{', 'i', 1, 'a', 'S', 'i', 3, 'abc', '}', '}'), {
+        const obj = /** @type {Record<string, unknown>} */ decode(
+            toBuffer('{', 'i', 9, '__proto__', '{', 'i', 1, 'a', 'S', 'i', 3, 'abc', '}', '}'),
+            {
                 protoAction: 'allow',
-            })
+            },
         );
         expect(Object.hasOwn(obj, '__proto__')).toBe(true);
         expect(obj['__proto__']).toEqual({ a: 'abc' });
@@ -533,17 +534,18 @@ describe('proto poisoning attack', () => {
 
 describe('constructor poisoning attack', () => {
     it('should remove constructor key', () => {
-        const obj = /** @type {Record<string, unknown>} */ (
-            decode(toBuffer('{', 'i', 11, 'constructor', '{', 'i', 1, 'a', 'S', 'i', 3, 'abc', '}', '}'), {
+        const obj = /** @type {Record<string, unknown>} */ decode(
+            toBuffer('{', 'i', 11, 'constructor', '{', 'i', 1, 'a', 'S', 'i', 3, 'abc', '}', '}'),
+            {
                 constructorAction: 'remove',
-            })
+            },
         );
         expect(Object.hasOwn(obj, 'constructor')).toBe(false);
         expect(obj.constructor).toBe(Object);
     });
     it('should allow constructor key', () => {
-        const obj = /** @type {Record<string, unknown>} */ (
-            decode(toBuffer('{', 'i', 11, 'constructor', '{', 'i', 1, 'a', 'S', 'i', 3, 'abc', '}', '}'))
+        const obj = /** @type {Record<string, unknown>} */ decode(
+            toBuffer('{', 'i', 11, 'constructor', '{', 'i', 1, 'a', 'S', 'i', 3, 'abc', '}', '}'),
         );
         expect(Object.hasOwn(obj, 'constructor')).toBe(true);
         expect(obj.constructor).toEqual({ a: 'abc' });

package/tests/e2e/{.data.js → .data.ts}

@@ -1,7 +1,5 @@
-/** @type {Record<string, unknown>} */
-export const INPUTS = {};
-/** @type {Record<string, unknown>} */
-export const EXPECTED = {};
+export const INPUTS: Record<string, unknown> = {};
+export const EXPECTED: Record<string, unknown> = {};
 
 INPUTS['number 0'] = 0;
 INPUTS['number 1'] = 1;

package/tests/e2e/{no-buffer-text.js → no-buffer-text.ts}

@@ -1,5 +1,5 @@
-import { resetEnv } from '../.utils.js';
-import { INPUTS, EXPECTED } from './.data.js';
+import { resetEnv } from '../.utils.ts';
+import { INPUTS, EXPECTED } from './.data.ts';
 import { encode, decode } from '../../dist/index.js';
 
 describe('no Buffer and no textencoder/decoder', () => {

package/tests/e2e/{no-buffer.js → no-buffer.ts}

@@ -1,5 +1,5 @@
-import { resetEnv } from '../.utils.js';
-import { INPUTS, EXPECTED } from './.data.js';
+import { resetEnv } from '../.utils.ts';
+import { INPUTS, EXPECTED } from './.data.ts';
 import { encode, decode } from '../../dist/index.js';
 
 describe('no Buffer', () => {

package/tests/e2e/{no-encode-into.js → no-encode-into.ts}

@@ -1,5 +1,5 @@
-import { resetEnv } from '../.utils.js';
-import { INPUTS, EXPECTED } from './.data.js';
+import { resetEnv } from '../.utils.ts';
+import { INPUTS, EXPECTED } from './.data.ts';
 import { encode, decode } from '../../dist/index.js';
 
 describe('no encodeInto', () => {

package/tests/e2e/{no-textencoder-decoder.js → no-textencoder-decoder.ts}

@@ -1,5 +1,5 @@
-import { resetEnv } from '../.utils.js';
-import { INPUTS, EXPECTED } from './.data.js';
+import { resetEnv } from '../.utils.ts';
+import { INPUTS, EXPECTED } from './.data.ts';
 import { encode, decode } from '../../dist/index.js';
 
 describe('no textencoder/decoder', () => {

package/tests/e2e/{normal.js → normal.ts}

@@ -1,4 +1,4 @@
-import { EXPECTED, INPUTS } from './.data.js';
+import { EXPECTED, INPUTS } from './.data.ts';
 import { encode, decode } from '../../dist/index.js';
 
 it.each(Object.keys(INPUTS))('%s', (name) => {

package/tests/e2e/{stream.js → stream.ts}

@@ -1,6 +1,6 @@
 import { Readable } from 'node:stream';
 import { encode as encodeStream, decode as decodeStream } from '../../dist/stream/index.js';
-import { EXPECTED, INPUTS } from './.data.js';
+import { EXPECTED, INPUTS } from './.data.ts';
 
 describe('stream', () => {
     it.each(Object.keys(INPUTS))('%s', async (name) => {
@@ -8,14 +8,14 @@ describe('stream', () => {
         const expected = EXPECTED[name] ?? input;
         if (expected instanceof Error) {
             await expect(async () => {
-                const encoded = await Readable.fromWeb(/** @type {any} */ (encodeStream(input))).toArray();
+                const encoded = await Readable.fromWeb(/** @type {any} */ encodeStream(input)).toArray();
                 const decoded = await decodeStream(
-                    /** @type {ReadableStream<Uint8Array>} */ (Readable.toWeb(Readable.from(encoded))),
+                    /** @type {ReadableStream<Uint8Array>} */ Readable.toWeb(Readable.from(encoded)),
                 );
                 expect(decoded).toEqual(expected);
             }).rejects.toThrow(expected);
         } else {
-            const encoded = await Readable.fromWeb(/** @type {any} */ (encodeStream(input))).toArray();
+            const encoded = await Readable.fromWeb(/** @type {any} */ encodeStream(input)).toArray();
             const data = encoded.flatMap((/** @type {Buffer} */ chunk) => {
                 if (chunk.length < 2) return [chunk];
                 // split to random chunks
@@ -29,7 +29,7 @@ describe('stream', () => {
                 return chunks;
             });
             const decoded = await decodeStream(
-                /** @type {ReadableStream<Uint8Array>} */ (Readable.toWeb(Readable.from(data))),
+                /** @type {ReadableStream<Uint8Array>} */ Readable.toWeb(Readable.from(data)),
             );
             expect(decoded).toEqual(expected);
         }

package/tests/{encode.js → encode.ts}

@@ -4,7 +4,7 @@
 
 import { encode, decode } from '../dist/index.js';
 import { getEncoder } from '../dist/encoder.js';
-import { toArray } from './.utils.js';
+import { toArray } from './.utils.ts';
 
 // @ts-expect-error Access private property
 const poolInit = getEncoder().pool;

package/tests/{huge-string.js → huge-string.ts}

@@ -1,6 +1,6 @@
 import { Buffer } from 'node:buffer';
 import { encode } from '../dist/index.js';
-import { toArray, resetEnv } from './.utils.js';
+import { toArray, resetEnv } from './.utils.ts';
 
 const STR_BYTE_LENGTH = 128 * 1024 * 1024 - 20;
 

package/tests/rxjs/{decode.js → decode.ts}

@@ -4,7 +4,7 @@
 import { jest } from '@jest/globals';
 import { firstValueFrom, of, Subject } from 'rxjs';
 import { decode as decodePipe } from '../../dist/rxjs/index.js';
-import { toBuffer } from '../.utils.js';
+import { toBuffer } from '../.utils.ts';
 import { UnexpectedEofError as UnexpectedEof } from '../../dist/helper/errors.js';
 
 /**
@@ -23,15 +23,13 @@ async function decode(data) {
  * @param {(data: unknown) => void} onData 数据回调
  */
 async function decodeStream(observable, onData) {
-    return /** @type {Promise<void>} */ (
-        new Promise((resolve, reject) => {
-            observable.pipe(decodePipe()).subscribe({
-                next: onData,
-                error: reject,
-                complete: resolve,
-            });
-        })
-    );
+    return /** @type {Promise<void>} */ new Promise((resolve, reject) => {
+        observable.pipe(decodePipe()).subscribe({
+            next: onData,
+            error: reject,
+            complete: resolve,
+        });
+    });
 }
 
 test('decode unsupported type', async () => {

package/tests/rxjs/{encode.js → encode.ts}

@@ -4,7 +4,7 @@
 import { firstValueFrom, of, map, reduce, Subject, toArray as rxjsToArray } from 'rxjs';
 import { encode } from '../../dist/rxjs/index.js';
 import { decode, encode as encodeRef } from '../../dist/index.js';
-import { toArray } from '../.utils.js';
+import { toArray } from '../.utils.ts';
 
 /**
  * 包装为 promise
@@ -304,7 +304,7 @@ test('encode object (only null values)', async () => {
 });
 
 test('encode object (skip prototype)', async () => {
-    const obj = /** @type {Record<string, unknown>} */ (Object.create({ a: 2, x: 'xx' }));
+    const obj = /** @type {Record<string, unknown>} */ Object.create({ a: 2, x: 'xx' });
     obj['a'] = 1;
     obj['b'] = 'a';
     obj['c'] = true;

package/tests/stream/{decode.js → decode.ts}

@@ -4,7 +4,7 @@
 import { jest } from '@jest/globals';
 import { Readable, Transform } from 'node:stream';
 import { decoder as decodeStream, decode as decodeAsync } from '../../dist/stream/index.js';
-import { toBuffer } from '../.utils.js';
+import { toBuffer } from '../.utils.ts';
 import { UnexpectedEofError as UnexpectedEof } from '../../dist/helper/errors.js';
 
 /**
@@ -14,7 +14,7 @@ import { UnexpectedEofError as UnexpectedEof } from '../../dist/helper/errors.js
  */
 async function decode(data) {
     const readable = Readable.from([data], { objectMode: false });
-    return decodeAsync(/** @type {ReadableStream<Uint8Array>} */ (Readable.toWeb(readable)));
+    return decodeAsync(/** @type {ReadableStream<Uint8Array>} */ Readable.toWeb(readable));
 }
 
 /**
@@ -456,7 +456,7 @@ test('decode object (empty key, optimized)', async () => {
 });
 
 test('decode stream', async () => {
-    const stream = Transform.fromWeb(/** @type {any} */ (decodeStream()), { objectMode: true });
+    const stream = Transform.fromWeb(/** @type {any} */ decodeStream(), { objectMode: true });
     // while decoding streaming, N will be regarded as a no-op, rather than an undefined value
     const onData = jest.fn();
     stream.on('data', onData);
@@ -499,7 +499,7 @@ test('decode bad stream [error]', async () => {
 });
 
 test('decode partial stream [error]', async () => {
-    const stream = Transform.fromWeb(/** @type {any} */ (decodeStream()), { objectMode: true });
+    const stream = Transform.fromWeb(/** @type {any} */ decodeStream(), { objectMode: true });
     // while decoding streaming, N will be regarded as a no-op, rather than an undefined value
     const onData = jest.fn();
     stream.on('data', onData);

package/tests/stream/{encode.js → encode.ts}

@@ -4,7 +4,7 @@
 import { buffer } from 'node:stream/consumers';
 import { encode, encoder } from '../../dist/stream/index.js';
 import { decode, encode as encodeRef } from '../../dist/index.js';
-import { toArray } from '../.utils.js';
+import { toArray } from '../.utils.ts';
 import { Transform } from 'node:stream';
 
 /**
@@ -364,7 +364,7 @@ test('encode huge data (~128M)', async () => {
 });
 
 test('encode stream', async () => {
-    const stream = Transform.fromWeb(/** @type {any} */ (encoder()), { objectMode: true });
+    const stream = Transform.fromWeb(/** @type {any} */ encoder(), { objectMode: true });
     stream.write(undefined);
     stream.write(true);
     stream.write(false);