@cloudpss/ubjson 0.5.10 → 0.5.12

package/tests/encode.js

@@ -3,104 +3,156 @@
  */
 
 import { encode, decode } from '../dist/index.js';
+import { getEncoder } from '../dist/encoder.js';
 import { toArray } from './.utils.js';
 
+// @ts-expect-error Access private property
+const poolInit = getEncoder().pool;
+
 test('encode function', () => {
     expect(() =>
         encode(function () {
             //noop
         }),
     ).toThrow();
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 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);
 });
 
 test('encode symbol', () => {
     expect(() => encode(Symbol('sym'))).toThrow();
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode undefined', () => {
     expect(toArray(encode(undefined))).toEqual(toArray('N'));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode null', () => {
     expect(toArray(encode(null))).toEqual(toArray('Z'));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode true', () => {
     expect(toArray(encode(true))).toEqual(toArray('T'));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode false', () => {
     expect(toArray(encode(false))).toEqual(toArray('F'));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode int8', () => {
     expect(toArray(encode(-1))).toEqual(toArray('i', 255));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode uint8', () => {
     expect(toArray(encode(200))).toEqual(toArray('U', 200));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode int16', () => {
     expect(toArray(encode(0x1234))).toEqual(toArray('I', 0x12, 0x34));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode int32', () => {
     expect(toArray(encode(0x1234_5678))).toEqual(toArray('l', 0x12, 0x34, 0x56, 0x78));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode float32', () => {
     expect(toArray(encode(1.003_906_25))).toEqual(toArray('d', 0x3f, 0x80, 0x80, 0x00));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode float32 (too large integer)', () => {
     expect(toArray(encode(2_147_483_648))).toEqual(toArray('d', 0x4f, 0x00, 0x00, 0x00));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode float64', () => {
     expect(toArray(encode(100_000.003_906_25))).toEqual(toArray('D', 0x40, 0xf8, 0x6a, 0x00, 0x10, 0x00, 0x00, 0x00));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode char', () => {
     expect(toArray(encode('a'))).toEqual(toArray('C', 'a'));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode char 127', () => {
     expect(toArray(encode('\u007F'))).toEqual(toArray('C', '\u007F'));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode char 257', () => {
     expect(toArray(encode('\u0123'))).toEqual(toArray('S', 'i', 2, 196, 163));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode char emoji', () => {
     expect(toArray(encode('💖'))).toEqual(toArray('S', 'i', 4, 240, 159, 146, 150));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode string', () => {
     expect(toArray(encode('ubjson'))).toEqual(toArray('S', 'i', 6, ...'ubjson'));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode string (len = 60)', () => {
     // 不生成 u8
     const str = 'ubjson'.repeat(10);
     expect(toArray(encode(str))).toEqual(toArray('S', 'i', str.length, ...str));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode string (len = 120)', () => {
     // 不生成 u8
     const str = 'ubjson'.repeat(20);
     expect(toArray(encode(str))).toEqual(toArray('S', 'i', str.length, ...str));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode string (len = 180)', () => {
     // 不生成 u8
     const str = 'ubjson'.repeat(30);
     expect(toArray(encode(str))).toEqual(toArray('S', 'I', 0, str.length, ...str));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode string (no encodeInto)', () => {
@@ -111,44 +163,64 @@ test('encode string (no encodeInto)', () => {
     expect(toArray(encode('ubjson'))).toEqual(toArray('S', 'i', 6, ...'ubjson'));
 
     TextEncoder.prototype.encodeInto = encodeInto;
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode array', () => {
     expect(toArray(encode([1, 2, 3, -1]))).toEqual(toArray('[', 'U', 1, 'U', 2, 'U', 3, 'i', 255, ']'));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode array (empty)', () => {
     expect(toArray(encode([]))).toEqual(toArray('[', ']'));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode array (undefined)', () => {
     expect(toArray(encode([undefined]))).toEqual(toArray('[', 'Z', ']'));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode array (function)', () => {
     expect(toArray(encode([() => 1]))).toEqual(toArray('[', 'Z', ']'));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode array (spares)', () => {
     const array = Array.from({ length: 3 });
     array[1] = true;
     expect(toArray(encode(array))).toEqual(toArray('[', 'Z', 'T', 'Z', ']'));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode array (mixed)', () => {
     expect(toArray(encode([1, 'a', true]))).toEqual(toArray('[', 'U', 1, 'C', 'a', 'T', ']'));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode array (int8)', () => {
     expect(toArray(encode([-1, 2, 3]))).toEqual(toArray('[', 'i', 255, 'U', 2, 'U', 3, ']'));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode array (int16)', () => {
     expect(toArray(encode([255, -1]))).toEqual(toArray('[', 'U', 0xff, 'i', 0xff, ']'));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode array (only null values)', () => {
     expect(toArray(encode([null, null, null]))).toEqual(toArray('[', 'Z', 'Z', 'Z', ']'));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode N-D array', () => {
@@ -163,6 +235,8 @@ test('encode N-D array', () => {
         [1, 2, 3],
         [4, 5, 6],
     ]);
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode array of objects', () => {
@@ -177,6 +251,8 @@ test('encode array of objects', () => {
         { a: 1, b: 2, c: 3 },
         { d: 4, e: 5, f: 6 },
     ]);
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode array of objects of arrays', () => {
@@ -191,36 +267,50 @@ test('encode array of objects of arrays', () => {
         { a: [1, 2], b: [3, 4] },
         { c: [5, 6], d: [7, 8] },
     ]);
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode array (int8 typed array)', () => {
     expect(toArray(encode(Int8Array.from([18, -2])))).toEqual(toArray('[', '$', 'i', '#', 'i', 2, 0x12, 0xfe));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode array (uint8 typed array)', () => {
     expect(toArray(encode(Uint8Array.from([18, 254])))).toEqual(toArray('[', '$', 'U', '#', 'i', 2, 0x12, 0xfe));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode array (buffer array)', () => {
     expect(toArray(encode(Buffer.from([18, -2])))).toEqual(toArray('[', '$', 'U', '#', 'i', 2, 0x12, 0xfe));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode array (int16 typed array)', () => {
     expect(toArray(encode(Int16Array.from([4660, -292])))).toEqual(
         toArray('[', '$', 'I', '#', 'i', 2, 0x12, 0x34, 0xfe, 0xdc),
     );
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode array (int32 typed array)', () => {
     expect(toArray(encode(Int32Array.from([305_419_896, -19_088_744])))).toEqual(
         toArray('[', '$', 'l', '#', 'i', 2, 0x12, 0x34, 0x56, 0x78, 0xfe, 0xdc, 0xba, 0x98),
     );
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode array (float32 typed array)', () => {
     expect(toArray(encode(Float32Array.from([0.25, 0.125])))).toEqual(
         toArray('[', '$', 'd', '#', 'i', 2, 0x3e, 0x80, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00),
     );
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode array (float64 typed array)', () => {
@@ -250,52 +340,99 @@ test('encode array (float64 typed array)', () => {
             0x00,
         ),
     );
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode array (uint8clamped typed array)', () => {
     expect(() => encode(new Uint8ClampedArray())).toThrow();
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode array (uint16 typed array)', () => {
     expect(() => encode(new Uint16Array())).toThrow();
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode array (uint32 typed array)', () => {
     expect(() => encode(new Uint32Array())).toThrow();
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode array (uint64 typed array)', () => {
     expect(() => encode(new BigUint64Array())).toThrow();
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 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);
 });
 
 test('encode object', () => {
     expect(toArray(encode({ a: 1, b: 2, c: 3 }))).toEqual(
         toArray('{', 'i', 1, 'a', 'U', 1, 'i', 1, 'b', 'U', 2, 'i', 1, 'c', 'U', 3, '}'),
     );
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode object (empty)', () => {
     expect(toArray(encode({}))).toEqual(toArray('{', '}'));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode object (empty key)', () => {
     expect(toArray(encode({ '': '' }))).toEqual(toArray('{', 'i', 0, 'S', 'i', 0, '}'));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode object (mixed)', () => {
     expect(toArray(encode({ a: 1, b: 'a', c: true }))).toEqual(
         toArray('{', 'i', 1, 'a', 'U', 1, 'i', 1, 'b', 'C', 'a', 'i', 1, 'c', 'T', '}'),
     );
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode object (only null values)', () => {
     expect(toArray(encode({ a: null, b: null, c: null }))).toEqual(
         toArray('{', 'i', 1, 'a', 'Z', 'i', 1, 'b', 'Z', 'i', 1, 'c', 'Z', '}'),
     );
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode object (skip prototype)', () => {
@@ -306,58 +443,80 @@ test('encode object (skip prototype)', () => {
     expect(toArray(encode(obj))).toEqual(
         toArray('{', 'i', 1, 'a', 'U', 1, 'i', 1, 'b', 'C', 'a', 'i', 1, 'c', 'T', '}'),
     );
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode object (skip symbol)', () => {
     const obj = { [Symbol()]: true, a: 1 };
     expect(toArray(encode(obj))).toEqual(toArray('{', 'i', 1, 'a', 'U', 1, '}'));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode object (skip non-enumerable)', () => {
     const obj = {};
     Object.defineProperty(obj, 'a', { value: 1, configurable: true, writable: true });
     expect(toArray(encode(obj))).toEqual(toArray('{', '}'));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode object (include getter)', () => {
     const obj = {};
     Object.defineProperty(obj, 'a', { get: () => 1, enumerable: true });
     expect(toArray(encode(obj))).toEqual(toArray('{', 'i', 1, 'a', 'U', 1, '}'));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode object (skip undefined)', () => {
     const obj = { a: undefined };
     expect(toArray(encode(obj))).toEqual(toArray('{', '}'));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode object (skip function)', () => {
     const obj = { a: 1, b: () => 1 };
     expect(toArray(encode(obj))).toEqual(toArray('{', 'i', 1, 'a', 'U', 1, '}'));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode object (include null)', () => {
     const obj = { a: null };
     expect(toArray(encode(obj))).toEqual(toArray('{', 'i', 1, 'a', 'Z', '}'));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode huge typed array (16K)', () => {
     const obj = new Uint8Array(16 * 1024);
     expect(toArray(encode(obj).slice(0, 8))).toEqual(toArray('[', '$', 'U', '#', 'I', 0x40, 0x00, 0));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode huge typed array (~128M)', () => {
     const obj = new Uint8Array(128 * 1024 * 1024 - 10);
     expect(toArray(encode(obj).slice(0, 10))).toEqual(toArray('[', '$', 'U', '#', 'l', 0x7, 0xff, 0xff, 0xf6, 0));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode huge typed array (128M) [error]', () => {
     const obj = new Uint8Array(128 * 1024 * 1024);
     expect(() => encode(obj)).toThrow(/Buffer has exceed max size/);
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode huge typed array (3G) [error]', () => {
     const obj = new Uint8Array(3 * 1024 * 1024 * 1024);
     expect(() => encode(obj)).toThrow(/Buffer has exceed max size/);
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode huge data (~128M)', () => {
@@ -367,6 +526,8 @@ test('encode huge data (~128M)', () => {
     expect(toArray(encode(obj).slice(0, 12))).toEqual(
         toArray('[', '[', '$', 'U', '#', 'l', 0x7, 0xff, 0xff, 0xec, 0x12, 0x34),
     );
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode huge data (128M - 9)', () => {
@@ -379,11 +540,15 @@ test('encode huge data (128M - 9)', () => {
     expect(toArray(encoded.slice(0, 12))).toEqual(
         toArray('[', '[', '$', 'U', '#', 'l', 0x7, 0xff, 0xff, 0xf7, 0x12, 0x34),
     );
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode huge data (128M - 8) [error]', () => {
     const obj = [new Uint8Array(128 * 1024 * 1024 - 8)];
     expect(() => encode(obj)).toThrow(/Buffer has exceed max size/);
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode huge data (256M)', () => {
@@ -401,6 +566,8 @@ test('encode huge data (256M)', () => {
         toArray('[', '$', 'U', '#', 'l', 0x7, 0xff, 0xff, 0xf7, 0x56, 0x78),
     );
     expect(toArray(encoded.slice(-1))).toEqual(toArray(']'));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode custom toJSON', () => {
@@ -408,9 +575,13 @@ test('encode custom toJSON', () => {
         toJSON: () => ({ a: 1 }),
     };
     expect(toArray(encode(obj))).toEqual(toArray('{', 'i', 1, 'a', 'U', 1, '}'));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });
 
 test('encode Date', () => {
     const obj = new Date(0);
     expect(toArray(encode(obj))).toEqual(toArray('S', 'i', 24, ...'1970-01-01T00:00:00.000Z'));
+    // @ts-expect-error Access private property
+    expect(getEncoder().pool).toBe(poolInit);
 });

package/tests/huge-string.js

@@ -1,4 +1,5 @@
 import { encode } from '../dist/index.js';
+import { resetEncoder } from '../dist/encoder.js';
 import { toArray } from './.utils.js';
 
 const STR_BYTE_LENGTH = 128 * 1024 * 1024 - 20;
@@ -74,10 +75,12 @@ describe(`encode huge string`, () => {
             buffer = global.Buffer;
             // @ts-expect-error remove buffer
             delete global.Buffer;
+            resetEncoder();
         });
 
         afterAll(() => {
             global.Buffer = buffer;
+            resetEncoder();
         });
 
         it(`~128M [1]`, () => {

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 () => {
@@ -500,3 +502,18 @@ test('decode partial stream [error]', async () => {
     expect(onData).nthCalledWith(1, true);
     expect(onData).nthCalledWith(2, false);
 });
+
+test('decode in parallel', async () => {
+    const buf = toBuffer('{', 'i', 1, 'a', 'U', 1, 'i', 1, 'b', 'S', 'i', 3, ...'str', '}');
+    const result = await Promise.all([decode(buf), decode(buf)]);
+    expect(result).toEqual([
+        {
+            a: 1,
+            b: 'str',
+        },
+        {
+            a: 1,
+            b: 'str',
+        },
+    ]);
+});