@cloudpss/ubjson 0.5.11 → 0.5.13

package/src/common/decoder.ts

@@ -4,15 +4,29 @@ import { decode, decodeKey } from './string-decoder.js';
 
 const fromEntries = Object.fromEntries;
 
+/** decoder options */
+export interface DecoderOptions {
+    /** 对 {@link Uint8Array} 使用 subarray */
+    noAllocBuffer?: boolean;
+}
+
 /** decoder */
-export class Decoder {
+export class DecoderBase {
     protected readonly view: DataView;
     protected readonly data: Uint8Array;
     /** 当前读指针位置 */
     protected offset = 0;
-    constructor(data: BinaryData) {
+
+    /** 选项 */
+    protected readonly noAllocBuffer;
+    constructor(data: BinaryData, options?: DecoderOptions) {
         this.data = toUint8Array(data);
         this.view = new DataView(this.data.buffer, this.data.byteOffset, this.data.byteLength);
+        if (options) {
+            this.noAllocBuffer = !!options.noAllocBuffer;
+        } else {
+            this.noAllocBuffer = false;
+        }
     }
 
     /** EOF */
@@ -76,9 +90,7 @@ export class Decoder {
                 object.length = count;
                 for (let i = 0; i < count; i++) {
                     const key = this.readKey();
-                    const t = type ?? this.readMarker();
-                    if (t === undefined) this.eof();
-                    const value = this.readData(t);
+                    const value = this.readData(type ?? this.readMarker());
                     object[i] = [key, value];
                 }
                 return fromEntries(object);
@@ -99,13 +111,9 @@ export class Decoder {
                 switch (type) {
                     case constants.UINT8:
                         try {
-                            const buf = new Uint8Array(
-                                this.data.buffer,
-                                this.data.byteOffset + this.offset,
-                                count,
-                            ).slice();
+                            const buf = new Uint8Array(this.data.buffer, this.data.byteOffset + this.offset, count);
                             this.offset += count;
-                            return buf;
+                            return this.noAllocBuffer ? buf : buf.slice();
                         } catch {
                             return this.eof();
                         }
@@ -154,8 +162,7 @@ export class Decoder {
                         for (let i = 0; i < count; i++) {
                             result[i] = this.readInt64Data();
                         }
-                        throw new Error('Unsupported type int64');
-                        //return result;
+                        return result;
                     }
                     case constants.NULL:
                         return Array.from({ length: count }).fill(null);
@@ -193,8 +200,13 @@ export class Decoder {
                 return true;
             case constants.FALSE:
                 return false;
-            case constants.INT64:
-                return this.readInt64Data();
+            case constants.INT64: {
+                const n = this.readInt64Data();
+                if (n < Number.MIN_SAFE_INTEGER || n > Number.MAX_SAFE_INTEGER) {
+                    return n;
+                }
+                return Number(n);
+            }
             case constants.HIGH_PRECISION_NUMBER: {
                 const length = this.readIntLength();
                 try {
@@ -227,9 +239,14 @@ export class Decoder {
             case constants.INT32:
                 length = this.readInt32Data();
                 break;
-            case constants.INT64:
-                length = this.readInt64Data();
+            case constants.INT64: {
+                const l = this.readInt64Data();
+                if (l < 0 || l > Number.MAX_SAFE_INTEGER) {
+                    throw new Error('Invalid length');
+                }
+                length = Number(l);
                 break;
+            }
             default:
                 throw new Error(`Unexpected marker '${String.fromCharCode(marker)}'(${marker}) for int length`);
         }
@@ -284,15 +301,14 @@ export class Decoder {
         }
     }
     /** readInt64Data */
-    private readInt64Data(): never {
+    private readInt64Data(): bigint {
         try {
-            const _result = this.view.getBigInt64(this.offset);
+            const result = this.view.getBigInt64(this.offset);
             this.offset += 8;
-            // return result;
+            return result;
         } catch {
             this.eof();
         }
-        throw new Error('Unsupported type int64');
     }
     /** readFloat32Data */
     private readFloat32Data(): number {

package/src/common/encoder.ts

@@ -96,9 +96,9 @@ export abstract class EncoderBase {
                     this.ensureCapacity(1);
                     this.buffer[this.length++] = constants.ARRAY_END;
                 } else if (!ArrayBuffer.isView(value)) {
-                    const toJSON = typeof (value as Record<string, unknown>)['toJSON'] == 'function';
-                    if (toJSON) {
-                        this.write((value as { toJSON: () => unknown }).toJSON());
+                    const { toJSON } = value as Record<string, unknown>;
+                    if (typeof toJSON == 'function') {
+                        this.write(toJSON.call(value));
                         return;
                     }
                     this.ensureCapacity(1);
@@ -130,8 +130,9 @@ export abstract class EncoderBase {
                         return;
                     }
 
-                    const arrayLength = (value as Int16Array | Int32Array | Float32Array | Float64Array).length;
-                    const elementSize = (value as Int16Array | Int32Array | Float32Array | Float64Array)
+                    const arrayLength = (value as Int16Array | Int32Array | BigInt64Array | Float32Array | Float64Array)
+                        .length;
+                    const elementSize = (value as Int16Array | Int32Array | BigInt64Array | Float32Array | Float64Array)
                         .BYTES_PER_ELEMENT;
                     if (value instanceof Int16Array) {
                         this.buffer[this.length++] = constants.INT16;
@@ -165,6 +166,14 @@ export abstract class EncoderBase {
                             this.view.setFloat64(this.length, value[i]);
                             this.length += elementSize;
                         }
+                    } else if (value instanceof BigInt64Array) {
+                        this.buffer[this.length++] = constants.INT64;
+                        this.buffer[this.length++] = constants.COUNT_MARKER;
+                        this.setLength(arrayLength);
+                        for (let i = 0; i < arrayLength; i++) {
+                            this.view.setBigInt64(this.length, value[i]);
+                            this.length += elementSize;
+                        }
                     } else {
                         throw new TypeError(`Unsupported typed array type ${Object.prototype.toString.call(value)}`);
                     }
@@ -175,6 +184,21 @@ export abstract class EncoderBase {
                 this.ensureCapacity(1);
                 this.buffer[this.length++] = value ? constants.TRUE : constants.FALSE;
                 return;
+            case 'bigint':
+                // int32 range
+                if (value >= -2_147_483_648n && value <= 2_147_483_647n) {
+                    this.write(Number(value));
+                }
+                // int64 range
+                else if (value >= -9_223_372_036_854_775_808n && value <= 9_223_372_036_854_775_807n) {
+                    this.ensureCapacity(9);
+                    this.buffer[this.length++] = constants.INT64;
+                    this.view.setBigInt64(this.length, value);
+                    this.length += 8;
+                } else {
+                    throw new RangeError(`BigInt value out of range: ${value}`);
+                }
+                return;
             default:
                 throw new Error(`Unsupported type ${Object.prototype.toString.call(value)}`);
         }

package/src/decoder.ts

@@ -1 +1,10 @@
-export { Decoder } from './common/decoder.js';
+import { DecoderBase } from './common/decoder.js';
+export type { DecoderOptions } from './common/decoder.js';
+
+/** 解码 UBJSON */
+export class Decoder extends DecoderBase {
+    /** 读取完毕 */
+    get ended(): boolean {
+        return this.offset >= this.data.byteLength;
+    }
+}

package/src/encoder.ts

@@ -45,11 +45,10 @@ export class Encoder extends EncoderBase {
         this.length = 0;
     }
 
-    /** 获取写入结果 */
-    encode(value: unknown): Uint8Array {
-        this.allocUnsafe(BLOCK_SIZE);
-        this.writeValue(value);
+    /** 获取结果 */
+    private getResult(): Uint8Array {
         if (this.flushedBuffers.length === 0) {
+            // 缓冲区为空，复制当前 buffer
             return this.buffer.slice(0, this.length);
         }
 
@@ -65,6 +64,37 @@ export class Encoder extends EncoderBase {
         result.set(this.buffer.subarray(0, this.length), offset);
         return result;
     }
+
+    /** 抛弃结果 */
+    private cleanResult(): void {
+        this.flushedBuffers.splice(0);
+    }
+
+    /** 获取写入结果 */
+    encode(value: unknown): Uint8Array {
+        try {
+            this.allocUnsafe(BLOCK_SIZE);
+            this.writeValue(value);
+            return this.getResult();
+        } catch (e) {
+            this.cleanResult();
+            throw e;
+        }
+    }
+
+    /** 获取写入结果 */
+    encodeMany(value: Iterable<unknown>): Uint8Array {
+        try {
+            this.allocUnsafe(BLOCK_SIZE);
+            for (const v of value) {
+                this.writeValue(v);
+            }
+            return this.getResult();
+        } catch (e) {
+            this.cleanResult();
+            throw e;
+        }
+    }
 }
 
 let _ENCODER: Encoder | undefined;

package/src/index.ts

@@ -1,14 +1,29 @@
 import { getEncoder } from './encoder.js';
-import { Decoder } from './decoder.js';
+import { Decoder, type DecoderOptions } from './decoder.js';
 export { UnexpectedEof } from './utils.js';
 
+export type { DecoderOptions };
+
 /** 编码为 UBJSON */
 export function encode(value: unknown): Uint8Array {
     return getEncoder().encode(value);
 }
 
+/** 编码为 UBJSON */
+export function encodeMany(value: Iterable<unknown>): Uint8Array {
+    return getEncoder().encodeMany(value);
+}
+
 /** 解码 UBJSON */
-export function decode(value: BinaryData): unknown {
-    const decoder = new Decoder(value);
+export function decode(value: BinaryData, options?: DecoderOptions): unknown {
+    const decoder = new Decoder(value, options);
     return decoder.decode();
 }
+
+/** 解码 UBJSON */
+export function* decodeMany(value: BinaryData, options?: DecoderOptions): Iterable<unknown> {
+    const decoder = new Decoder(value, options);
+    while (!decoder.ended) {
+        yield decoder.decode();
+    }
+}

package/src/stream/index.ts

@@ -14,6 +14,22 @@ export function encode(value: unknown): Readable {
     encoder.end();
     return encoder;
 }
+/** 编码为 UBJSON */
+export function encodeMany(value: AsyncIterable<unknown>): Readable {
+    const encoder = new StreamEncoder();
+    void (async () => {
+        try {
+            for await (const v of value) {
+                if (v == null) encoder.write(undefined);
+                else encoder.write(v);
+            }
+            encoder.end();
+        } catch (ex) {
+            encoder.destroy(ex as Error);
+        }
+    })();
+    return encoder;
+}
 
 /** 编码为 UBJSON */
 export function encoder(): Transform {
@@ -31,6 +47,12 @@ export function decode(stream: NodeJS.ReadableStream): Promise<unknown> {
     });
 }
 
+/** 解码 UBJSON */
+export function decodeMany(stream: NodeJS.ReadableStream): AsyncIterable<unknown> {
+    const decoder = new StreamDecoder();
+    return stream.pipe(decoder);
+}
+
 /** 解码 UBJSON */
 export function decoder(): Transform {
     return new StreamDecoder();

package/src/stream-helper/decoder.ts

@@ -1,10 +1,10 @@
-import { Decoder } from '../common/decoder.js';
+import { DecoderBase } from '../common/decoder.js';
 
 /** 未结束的流 */
 export const kEof = Symbol('EOF');
 
 /** 流式解码 UBJSON */
-export class StreamDecoderHelper extends Decoder {
+export class StreamDecoderHelper extends DecoderBase {
     constructor(data: Uint8Array) {
         super(data);
     }

package/tests/decode.js

@@ -54,8 +54,9 @@ test('decode int32', () => {
     expect(decode(toBuffer('l', 0x12, 0x34, 0x56, 0x78))).toBe(0x1234_5678);
 });
 
-test('decode int64 [error]', () => {
-    expect(() => decode(toBuffer('L', 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0))).toThrow();
+test('decode int64', () => {
+    expect(decode(toBuffer('L', 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0))).toBe(0x1234_5678_9abc_def0n);
+    expect(decode(toBuffer('L', 0x00, 0x04, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0))).toBe(0x04_5678_9abc_def0);
 });
 
 test('decode float32', () => {
@@ -156,9 +157,10 @@ test('decode huge string', () => {
     expect(decode(toBuffer('S', 'l', 0x00, 0x00, 0x00, 6, 'u', 'b', 'j', 's', 'o', 'n'))).toBe('ubjson');
 });
 
-test('decode huge string [error]', () => {
-    expect(() => decode(toBuffer('S', 'L', 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 'x'))).toThrow(
-        /Unsupported type int64/,
+test('decode huge string [int64 length]', () => {
+    expect(decode(toBuffer('S', 'L', 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 'x'))).toBe('x');
+    expect(() => decode(toBuffer('S', 'L', 0x77, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 'x'))).toThrow(
+        /Invalid length/,
     );
 });
 
@@ -200,6 +202,24 @@ test('decode N-D array (strongly typed, optimized)', () => {
     ).toEqual([new Int8Array([1, 2, 3]), new Int8Array([4, 5, 6])]);
 });
 
+test('decode N-D array (strongly typed, optimized, no alloc buffer)', () => {
+    const buf = toBuffer('[', '$', '[', '#', 'i', 2, '$', 'i', '#', 'i', 3, 1, 2, 3, '$', 'U', '#', 'U', 3, 4, 5, 6);
+
+    const decoded1 = /** @type {[Int8Array, Uint8Array]} */ (decode(buf));
+    const decoded2 = /** @type {[Int8Array, Uint8Array]} */ (decode(buf, { noAllocBuffer: true }));
+    // @ts-expect-error Falsy value
+    const decoded3 = /** @type {[Int8Array, Uint8Array]} */ (decode(buf, { noAllocBuffer: 0 }));
+    expect(decoded1).toEqual([new Int8Array([1, 2, 3]), new Uint8Array([4, 5, 6])]);
+    expect(decoded2).toEqual([new Int8Array([1, 2, 3]), new Uint8Array([4, 5, 6])]);
+    expect(decoded3).toEqual([new Int8Array([1, 2, 3]), new Uint8Array([4, 5, 6])]);
+    expect(decoded1[0].buffer).not.toBe(buf.buffer);
+    expect(decoded1[1].buffer).not.toBe(buf.buffer);
+    expect(decoded2[0].buffer).not.toBe(buf.buffer);
+    expect(decoded2[1].buffer).toBe(buf.buffer);
+    expect(decoded3[0].buffer).not.toBe(buf.buffer);
+    expect(decoded3[1].buffer).not.toBe(buf.buffer);
+});
+
 test('decode array of objects (optimized)', () => {
     expect(
         decode(
@@ -389,13 +409,13 @@ test('decode array (int32, strongly typed, optimized) [use typed array]', () =>
 });
 
 test('decode array (int64, strongly typed, optimized) [use typed array]', () => {
-    expect(() =>
-        decode(toBuffer('[', '$', 'L', '#', 'i', 1, 0x12, 0x34, 0x56, 0x78, 0xfe, 0xdc, 0xba, 0x98)),
-    ).toThrow();
+    expect(decode(toBuffer('[', '$', 'L', '#', 'i', 1, 0x12, 0x34, 0x56, 0x78, 0xfe, 0xdc, 0xba, 0x98))).toEqual(
+        new BigInt64Array([0x1234_5678_fedc_ba98n]),
+    );
 });
 
 test('decode array (int64, strongly typed, optimized, empty) [use typed array]', () => {
-    expect(() => decode(toBuffer('[', '$', 'L', '#', 'i', 0))).toThrow();
+    expect(decode(toBuffer('[', '$', 'L', '#', 'i', 0))).toEqual(new BigInt64Array([]));
 });
 
 test('decode array (float32, strongly typed, optimized) [use typed array]', () => {
@@ -492,3 +512,13 @@ test('decode object (empty key, optimized)', () => {
         b: null,
     });
 });
+
+test('decode (eof at marker)', () => {
+    expect(() => decode(toBuffer('i'))).toThrow(UnexpectedEof);
+    expect(() => decode(toBuffer('{'))).toThrow(UnexpectedEof);
+    expect(() => decode(toBuffer('{', 'i', 1, 'a'))).toThrow(UnexpectedEof);
+});
+
+test('decode (eof at key)', () => {
+    expect(() => decode(toBuffer('{', 'i', 2, 'a'))).toThrow(UnexpectedEof);
+});

package/tests/encode.js

@@ -20,7 +20,11 @@ test('encode function', () => {
 });
 
 test('encode bigint', () => {
-    expect(() => encode(1n)).toThrow();
+    expect(toArray(encode(1n))).toEqual(toArray(encode(1)));
+    expect(toArray(encode(0x1234_5678_90ab_cdefn))).toEqual(
+        toArray('L', 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef),
+    );
+    expect(() => encode(0x8234_5678_90ab_cdefn)).toThrow(/BigInt value out of range:/);
     // @ts-expect-error Access private property
     expect(getEncoder().pool).toBe(poolInit);
 });
@@ -365,7 +369,32 @@ test('encode array (uint64 typed array)', () => {
 });
 
 test('encode array (int64 typed array)', () => {
-    expect(() => encode(new BigInt64Array())).toThrow();
+    expect(toArray(encode(new BigInt64Array([1n, 0x1234_5678_1234_5678n])))).toEqual(
+        toArray(
+            '[',
+            '$',
+            'L',
+            '#',
+            'i',
+            2,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x01,
+            0x12,
+            0x34,
+            0x56,
+            0x78,
+            0x12,
+            0x34,
+            0x56,
+            0x78,
+        ),
+    );
     // @ts-expect-error Access private property
     expect(getEncoder().pool).toBe(poolInit);
 });

package/tests/many.js

@@ -0,0 +1,44 @@
+import { encodeMany, decodeMany } from '../dist/index.js';
+
+test('encode/decode many', () => {
+    const data = [
+        {
+            a: 1,
+            b: 2,
+            c: 3,
+            d: 4,
+            e: 5,
+        },
+        1,
+        null,
+        'x',
+        true,
+        [1, 2, 3],
+        Uint8Array.of(3, 3, 1),
+    ];
+    const encoded = encodeMany(data);
+    const decoded = [...decodeMany(encoded)];
+    expect(decoded).toEqual(data);
+});
+
+test('encode/decode many with error', () => {
+    expect(() =>
+        encodeMany(
+            (function* () {
+                yield 1;
+                throw new Error('xx');
+            })(),
+        ),
+    ).toThrow('xx');
+});
+
+test('encode/decode many with invalid value', () => {
+    expect(() => encodeMany([1, () => 1])).toThrow();
+});
+
+test('encode/decode many with undefined', () => {
+    const data = [1, null, undefined, [undefined]];
+    const encoded = encodeMany(data);
+    const decoded = [...decodeMany(encoded)];
+    expect(decoded).toEqual([1, null, [null]]);
+});

package/tests/rxjs/decode.js

@@ -77,8 +77,9 @@ test('decode int32', async () => {
     expect(await decode(toBuffer('l', 0x12, 0x34, 0x56, 0x78))).toBe(0x1234_5678);
 });
 
-test('decode int64 [error]', async () => {
-    await expect(() => decode(toBuffer('L', 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0))).rejects.toThrow();
+test('decode int64', async () => {
+    expect(await decode(toBuffer('L', 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0))).toBe(0x1234_5678_9abc_def0n);
+    expect(await decode(toBuffer('L', 0x00, 0x00, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0))).toBe(0x5678_9abc_def0);
 });
 
 test('decode float32', async () => {
@@ -140,9 +141,10 @@ test('decode huge string', async () => {
     expect(await decode(toBuffer('S', 'l', 0x00, 0x00, 0x00, 6, 'u', 'b', 'j', 's', 'o', 'n'))).toBe('ubjson');
 });
 
-test('decode huge string [error]', async () => {
-    await expect(() => decode(toBuffer('S', 'L', 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 'x'))).rejects.toThrow(
-        /Unsupported type int64/,
+test('decode huge string [int64 length]', async () => {
+    expect(await decode(toBuffer('S', 'L', 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 'x'))).toBe('x');
+    await expect(() => decode(toBuffer('S', 'L', 0x77, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 'x'))).rejects.toThrow(
+        /Invalid length/,
     );
 });
 
@@ -359,9 +361,9 @@ test('decode array (int32, strongly typed, optimized) [use typed array]', async
 });
 
 test('decode array (int64, strongly typed, optimized) [use typed array]', async () => {
-    await expect(() =>
-        decode(toBuffer('[', '$', 'L', '#', 'i', 1, 0x12, 0x34, 0x56, 0x78, 0xfe, 0xdc, 0xba, 0x98)),
-    ).rejects.toThrow();
+    expect(await decode(toBuffer('[', '$', 'L', '#', 'i', 1, 0x12, 0x34, 0x56, 0x78, 0xfe, 0xdc, 0xba, 0x98))).toEqual(
+        new BigInt64Array([0x1234_5678_fedc_ba98n]),
+    );
 });
 
 test('decode array (float32, strongly typed, optimized) [use typed array]', async () => {

package/tests/rxjs/encode.js

@@ -28,7 +28,11 @@ test('encode function', async () => {
 });
 
 test('encode bigint', async () => {
-    await expect(() => encodeAsync(1n)).rejects.toThrow();
+    expect(toArray(await encodeAsync(1n))).toEqual(toArray('U', 1));
+    expect(toArray(await encodeAsync(0x1876_9876_1234_1234n))).toEqual(
+        toArray('L', 0x18, 0x76, 0x98, 0x76, 0x12, 0x34, 0x12, 0x34),
+    );
+    await expect(encodeAsync(0x8234_5678_90ab_cdefn)).rejects.toThrow(/BigInt value out of range:/);
 });
 
 test('encode symbol', async () => {
@@ -268,7 +272,7 @@ test('encode array (uint64 typed array)', async () => {
 });
 
 test('encode array (int64 typed array)', async () => {
-    await expect(() => encodeAsync(new BigInt64Array())).rejects.toThrow();
+    expect(toArray(await encodeAsync(new BigInt64Array()))).toEqual(toArray('[', '$', 'L', '#', 'i', 0));
 });
 
 test('encode object', async () => {

package/tests/stream/decode.js

@@ -72,8 +72,9 @@ test('decode int32', async () => {
     expect(await decode(toBuffer('l', 0x12, 0x34, 0x56, 0x78))).toBe(0x1234_5678);
 });
 
-test('decode int64 [error]', async () => {
-    await expect(() => decode(toBuffer('L', 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0))).rejects.toThrow();
+test('decode int64', async () => {
+    expect(await decode(toBuffer('L', 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0))).toBe(0x1234_5678_9abc_def0n);
+    expect(await decode(toBuffer('L', 0x00, 0x04, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0))).toBe(0x04_5678_9abc_def0);
 });
 
 test('decode float32', async () => {
@@ -126,9 +127,10 @@ test('decode huge string', async () => {
     expect(await decode(toBuffer('S', 'l', 0x00, 0x00, 0x00, 6, 'u', 'b', 'j', 's', 'o', 'n'))).toBe('ubjson');
 });
 
-test('decode huge string [error]', async () => {
-    await expect(() => decode(toBuffer('S', 'L', 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 'x'))).rejects.toThrow(
-        /Unsupported type int64/,
+test('decode huge string [int64 length]', async () => {
+    expect(await decode(toBuffer('S', 'L', 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 'x'))).toBe('x');
+    await expect(() => decode(toBuffer('S', 'L', 0x77, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 'x'))).rejects.toThrow(
+        /Invalid length/,
     );
 });
 
@@ -345,9 +347,9 @@ test('decode array (int32, strongly typed, optimized) [use typed array]', async
 });
 
 test('decode array (int64, strongly typed, optimized) [use typed array]', async () => {
-    await expect(() =>
-        decode(toBuffer('[', '$', 'L', '#', 'i', 1, 0x12, 0x34, 0x56, 0x78, 0xfe, 0xdc, 0xba, 0x98)),
-    ).rejects.toThrow();
+    expect(await decode(toBuffer('[', '$', 'L', '#', 'i', 1, 0x12, 0x34, 0x56, 0x78, 0xfe, 0xdc, 0xba, 0x98))).toEqual(
+        new BigInt64Array([0x1234_5678_fedc_ba98n]),
+    );
 });
 
 test('decode array (float32, strongly typed, optimized) [use typed array]', async () => {

package/tests/stream/encode.js

@@ -23,7 +23,11 @@ test('encode function', async () => {
 });
 
 test('encode bigint', async () => {
-    await expect(() => encodeAsync(1n)).rejects.toThrow();
+    expect(toArray(await encodeAsync(1n))).toEqual(toArray('U', 1));
+    expect(toArray(await encodeAsync(0x1234_5678_8765_4321n))).toEqual(
+        toArray('L', 0x12, 0x34, 0x56, 0x78, 0x87, 0x65, 0x43, 0x21),
+    );
+    await expect(encodeAsync(0x8234_5678_90ab_cdefn)).rejects.toThrow(/BigInt value out of range:/);
 });
 
 test('encode symbol', async () => {
@@ -263,7 +267,7 @@ test('encode array (uint64 typed array)', async () => {
 });
 
 test('encode array (int64 typed array)', async () => {
-    await expect(() => encodeAsync(new BigInt64Array())).rejects.toThrow();
+    expect(toArray(await encodeAsync(new BigInt64Array()))).toEqual(toArray('[', '$', 'L', '#', 'i', 0));
 });
 
 test('encode object', async () => {