@cloudpss/ubjson 0.4.14 → 0.4.16

package/tests/huge-string.js

@@ -0,0 +1,122 @@
+import { encode } from '../dist/index.js';
+import { toArray } from './.utils.js';
+
+const STR_BYTE_LENGTH = 128 * 1024 * 1024 - 20;
+
+/**
+ * 构造测试字符串
+ * @param {string} char 使用的字符
+ * @param {number} byteLength 需要的长度
+ */
+function makeString(char, byteLength) {
+    const encoded = new TextEncoder().encode(char);
+    return [encoded, char.repeat(byteLength / encoded.byteLength)];
+}
+
+const [str1Data, str1] = makeString('a', STR_BYTE_LENGTH);
+// \u04d2 = Ӓ, 2 bytes in utf-8
+const [str2Data, str2] = makeString('Ӓ', STR_BYTE_LENGTH);
+// \u6c34 = 水, 3 bytes in utf-8
+const [str3Data, str3] = makeString('水', STR_BYTE_LENGTH);
+// \u1f600 = 😀, 4 bytes in utf-8 (0xF0 0x9F 0x98 0x80)
+const [str4Data, str4] = makeString('😀', STR_BYTE_LENGTH);
+// bad surrogate pair
+const [strXData, strX] = makeString('😀'[0], STR_BYTE_LENGTH);
+
+const strErr = 'a'.repeat(128 * 1024 * 1024);
+
+const ENCODED_PREFIX_LENGTH = 6;
+
+describe(`encode huge string`, () => {
+    describe(`with node buffer`, () => {
+        it(`~128M [1]`, () => {
+            const encoded = encode(str1);
+            expect(encoded.length).toBe(STR_BYTE_LENGTH + ENCODED_PREFIX_LENGTH);
+            expect(toArray(encoded.slice(0, ENCODED_PREFIX_LENGTH + str1Data.length * 2))).toEqual(
+                toArray('S', 'l', 0x7, 0xff, 0xff, 0xec, ...str1Data, ...str1Data),
+            );
+        });
+        it(`~128M [2]`, () => {
+            const encoded = encode(str2);
+            expect(encoded.length).toBe(STR_BYTE_LENGTH + ENCODED_PREFIX_LENGTH);
+            expect(toArray(encoded.slice(0, ENCODED_PREFIX_LENGTH + str2Data.length * 2))).toEqual(
+                toArray('S', 'l', 0x7, 0xff, 0xff, 0xec, ...str2Data, ...str2Data),
+            );
+        });
+        it(`~128M [3]`, () => {
+            const encoded = encode(str3);
+            expect(encoded.length).toBe(STR_BYTE_LENGTH + ENCODED_PREFIX_LENGTH);
+            expect(toArray(encoded.slice(0, ENCODED_PREFIX_LENGTH + str3Data.length * 2))).toEqual(
+                toArray('S', 'l', 0x7, 0xff, 0xff, 0xec, ...str3Data, ...str3Data),
+            );
+        });
+        it(`~128M [4]`, () => {
+            const encoded = encode(str4);
+            expect(encoded.length).toBe(STR_BYTE_LENGTH + ENCODED_PREFIX_LENGTH);
+            expect(toArray(encoded.slice(0, ENCODED_PREFIX_LENGTH + str4Data.length * 2))).toEqual(
+                toArray('S', 'l', 0x7, 0xff, 0xff, 0xec, ...str4Data, ...str4Data),
+            );
+        });
+        it(`~128M [bad surrogate pair]`, () => {
+            const encoded = encode(strX);
+            expect(encoded.length).toBe(STR_BYTE_LENGTH + ENCODED_PREFIX_LENGTH);
+            expect(toArray(encoded.slice(0, ENCODED_PREFIX_LENGTH + strXData.length * 2))).toEqual(
+                toArray('S', 'l', 0x7, 0xff, 0xff, 0xec, ...strXData, ...strXData),
+            );
+        });
+        it(`128M [error]`, () => {
+            expect(() => encode(strErr)).toThrow(/Buffer has exceed max size/);
+        });
+    });
+    describe(`without node buffer`, () => {
+        let buffer = Buffer;
+        beforeAll(() => {
+            buffer = global.Buffer;
+            // @ts-expect-error remove buffer
+            global.Buffer = undefined;
+        });
+
+        afterAll(() => {
+            global.Buffer = buffer;
+        });
+
+        it(`~128M [1]`, () => {
+            const encoded = encode(str1);
+            expect(encoded.length).toBe(STR_BYTE_LENGTH + ENCODED_PREFIX_LENGTH);
+            expect(toArray(encoded.slice(0, ENCODED_PREFIX_LENGTH + str1Data.length * 2))).toEqual(
+                toArray('S', 'l', 0x7, 0xff, 0xff, 0xec, ...str1Data, ...str1Data),
+            );
+        });
+        it(`~128M [2]`, () => {
+            const encoded = encode(str2);
+            expect(encoded.length).toBe(STR_BYTE_LENGTH + ENCODED_PREFIX_LENGTH);
+            expect(toArray(encoded.slice(0, ENCODED_PREFIX_LENGTH + str2Data.length * 2))).toEqual(
+                toArray('S', 'l', 0x7, 0xff, 0xff, 0xec, ...str2Data, ...str2Data),
+            );
+        });
+        it(`~128M [3]`, () => {
+            const encoded = encode(str3);
+            expect(encoded.length).toBe(STR_BYTE_LENGTH + ENCODED_PREFIX_LENGTH);
+            expect(toArray(encoded.slice(0, ENCODED_PREFIX_LENGTH + str3Data.length * 2))).toEqual(
+                toArray('S', 'l', 0x7, 0xff, 0xff, 0xec, ...str3Data, ...str3Data),
+            );
+        });
+        it(`~128M [4]`, () => {
+            const encoded = encode(str4);
+            expect(encoded.length).toBe(STR_BYTE_LENGTH + ENCODED_PREFIX_LENGTH);
+            expect(toArray(encoded.slice(0, ENCODED_PREFIX_LENGTH + str4Data.length * 2))).toEqual(
+                toArray('S', 'l', 0x7, 0xff, 0xff, 0xec, ...str4Data, ...str4Data),
+            );
+        });
+        it(`~128M [bad surrogate pair]`, () => {
+            const encoded = encode(strX);
+            expect(encoded.length).toBe(STR_BYTE_LENGTH + ENCODED_PREFIX_LENGTH);
+            expect(toArray(encoded.slice(0, ENCODED_PREFIX_LENGTH + strXData.length * 2))).toEqual(
+                toArray('S', 'l', 0x7, 0xff, 0xff, 0xec, ...strXData, ...strXData),
+            );
+        });
+        it(`128M [error]`, () => {
+            expect(() => encode(strErr)).toThrow(/Buffer has exceed max size/);
+        });
+    });
+});

package/tests/rxjs/decode.js

@@ -8,7 +8,6 @@ import { toBuffer } from '../.utils.js';
 
 /**
  * 包装为 promise
- *
  * @param {Uint8Array} data ubjson 数据
  */
 async function decode(data) {
@@ -18,7 +17,6 @@ async function decode(data) {
 
 /**
  * 包装为 promise
- *
  * @param {import("rxjs").Observable<Uint8Array>} observable ubjson 数据流
  * @param {(data: unknown) => void} onData 数据回调
  */
@@ -75,7 +73,7 @@ test('decode int16', async () => {
 });
 
 test('decode int32', async () => {
-    expect(await decode(toBuffer('l', 0x12, 0x34, 0x56, 0x78))).toBe(0x12345678);
+    expect(await decode(toBuffer('l', 0x12, 0x34, 0x56, 0x78))).toBe(0x1234_5678);
 });
 
 test('decode int64 [error]', async () => {
@@ -83,11 +81,11 @@ test('decode int64 [error]', async () => {
 });
 
 test('decode float32', async () => {
-    expect(await decode(toBuffer('d', 0x3f, 0x80, 0x80, 0x00))).toBe(1.00390625);
+    expect(await decode(toBuffer('d', 0x3f, 0x80, 0x80, 0x00))).toBe(1.003_906_25);
 });
 
 test('decode float64', async () => {
-    expect(await decode(toBuffer('D', 0x40, 0xf8, 0x6a, 0x00, 0x10, 0x00, 0x00, 0x00))).toBe(100000.00390625);
+    expect(await decode(toBuffer('D', 0x40, 0xf8, 0x6a, 0x00, 0x10, 0x00, 0x00, 0x00))).toBe(100_000.003_906_25);
 });
 
 test('decode high-precision number [error]', async () => {
@@ -130,7 +128,7 @@ test('decode ascii string 32kiB [huge]', async () => {
 });
 
 test('decode ascii string 64MB [huge]', async () => {
-    const size = 0x03d09000;
+    const size = 0x03d0_9000;
     const header = toBuffer('S', 'l', 0x03, 0xd0, 0x90, 0x00);
     const payload = new Uint8Array(size + header.byteLength).fill('a'.charCodeAt(0));
     payload.set(header);
@@ -142,9 +140,7 @@ test('decode huge string', async () => {
 });
 
 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/,
-    );
+    await expect(() => decode(toBuffer('S', 'L', 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 'x'))).rejects.toThrow(/Unsupported type int64/);
 });
 
 test('decode array', async () => {
@@ -180,11 +176,10 @@ test('decode array (strongly typed, empty, optimized)', async () => {
 });
 
 test('decode N-D array (strongly typed, optimized)', async () => {
-    expect(
-        await decode(
-            toBuffer('[', '$', '[', '#', 'i', 2, '$', 'i', '#', 'i', 3, 1, 2, 3, '$', 'i', '#', 'i', 3, 4, 5, 6),
-        ),
-    ).toEqual([new Int8Array([1, 2, 3]), new Int8Array([4, 5, 6])]);
+    expect(await decode(toBuffer('[', '$', '[', '#', 'i', 2, '$', 'i', '#', 'i', 3, 1, 2, 3, '$', 'i', '#', 'i', 3, 4, 5, 6))).toEqual([
+        new Int8Array([1, 2, 3]),
+        new Int8Array([4, 5, 6]),
+    ]);
 });
 
 test('decode array of objects (optimized)', async () => {
@@ -356,13 +351,11 @@ test('decode array (int16, strongly typed, optimized) [use typed array]', async
 test('decode array (int32, strongly typed, optimized) [use typed array]', async () => {
     const actual = await decode(toBuffer('[', '$', 'l', '#', 'i', 2, 0x12, 0x34, 0x56, 0x78, 0xfe, 0xdc, 0xba, 0x98));
     expect(actual).toBeInstanceOf(Int32Array);
-    expect(actual).toEqual(Int32Array.from([305419896, -19088744]));
+    expect(actual).toEqual(Int32Array.from([305_419_896, -19_088_744]));
 });
 
 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();
+    await expect(() => decode(toBuffer('[', '$', 'L', '#', 'i', 1, 0x12, 0x34, 0x56, 0x78, 0xfe, 0xdc, 0xba, 0x98))).rejects.toThrow();
 });
 
 test('decode array (float32, strongly typed, optimized) [use typed array]', async () => {
@@ -373,30 +366,7 @@ test('decode array (float32, strongly typed, optimized) [use typed array]', asyn
 
 test('decode array (float64, strongly typed, optimized) [use typed array]', async () => {
     const actual = await decode(
-        toBuffer(
-            '[',
-            '$',
-            'D',
-            '#',
-            'i',
-            2,
-            0x3f,
-            0xd0,
-            0x00,
-            0x00,
-            0x00,
-            0x00,
-            0x00,
-            0x00,
-            0x3f,
-            0xc0,
-            0x00,
-            0x00,
-            0x00,
-            0x00,
-            0x00,
-            0x00,
-        ),
+        toBuffer('[', '$', 'D', '#', 'i', 2, 0x3f, 0xd0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00),
     );
     expect(actual).toBeInstanceOf(Float64Array);
     expect(actual).toEqual(Float64Array.from([0.25, 0.125]));
@@ -411,11 +381,11 @@ test('decode object', async () => {
 });
 
 test('decode object (with no-op)', async () => {
-    expect(
-        await decode(
-            toBuffer('N', '{', 'N', 'i', 1, 'a', 'i', 1, 'i', 1, 'b', 'N', 'i', 2, 'i', 1, 'c', 'i', 3, 'N', '}', 'N'),
-        ),
-    ).toEqual({ a: 1, b: 2, c: 3 });
+    expect(await decode(toBuffer('N', '{', 'N', 'i', 1, 'a', 'i', 1, 'i', 1, 'b', 'N', 'i', 2, 'i', 1, 'c', 'i', 3, 'N', '}', 'N'))).toEqual({
+        a: 1,
+        b: 2,
+        c: 3,
+    });
 });
 
 test('decode array (empty, optimized)', async () => {
@@ -423,9 +393,7 @@ test('decode array (empty, optimized)', async () => {
 });
 
 test('decode object (mixed, optimized)', async () => {
-    expect(
-        await decode(toBuffer('{', '#', 'i', 3, 'i', 1, 'a', 'i', 1, 'i', 1, 'b', 'C', 'a', 'i', 1, 'c', 'T')),
-    ).toEqual({
+    expect(await decode(toBuffer('{', '#', 'i', 3, 'i', 1, 'a', 'i', 1, 'i', 1, 'b', 'C', 'a', 'i', 1, 'c', 'T'))).toEqual({
         a: 1,
         b: 'a',
         c: true,

package/tests/rxjs/encode.js

@@ -8,7 +8,6 @@ import { toArray } from '../.utils.js';
 
 /**
  * 包装为 promise
- *
  * @param {unknown} value 要编码的值
  */
 function encodeAsync(value) {
@@ -65,21 +64,19 @@ test('encode int16', async () => {
 });
 
 test('encode int32', async () => {
-    expect(toArray(await encodeAsync(0x12345678))).toEqual(toArray('l', 0x12, 0x34, 0x56, 0x78));
+    expect(toArray(await encodeAsync(0x1234_5678))).toEqual(toArray('l', 0x12, 0x34, 0x56, 0x78));
 });
 
 test('encode float32', async () => {
-    expect(toArray(await encodeAsync(1.00390625))).toEqual(toArray('d', 0x3f, 0x80, 0x80, 0x00));
+    expect(toArray(await encodeAsync(1.003_906_25))).toEqual(toArray('d', 0x3f, 0x80, 0x80, 0x00));
 });
 
 test('encode float32 (too large integer)', async () => {
-    expect(toArray(await encodeAsync(2147483648))).toEqual(toArray('d', 0x4f, 0x00, 0x00, 0x00));
+    expect(toArray(await encodeAsync(2_147_483_648))).toEqual(toArray('d', 0x4f, 0x00, 0x00, 0x00));
 });
 
 test('encode float64', async () => {
-    expect(toArray(await encodeAsync(100000.00390625))).toEqual(
-        toArray('D', 0x40, 0xf8, 0x6a, 0x00, 0x10, 0x00, 0x00, 0x00),
-    );
+    expect(toArray(await encodeAsync(100_000.003_906_25))).toEqual(toArray('D', 0x40, 0xf8, 0x6a, 0x00, 0x10, 0x00, 0x00, 0x00));
 });
 
 test('encode char', async () => {
@@ -87,7 +84,7 @@ test('encode char', async () => {
 });
 
 test('encode char 128', async () => {
-    expect(toArray(await encodeAsync('\xcc'))).toEqual(toArray('C', '\xcc'));
+    expect(toArray(await encodeAsync('\u00CC'))).toEqual(toArray('C', '\u00CC'));
 });
 
 test('encode char 257', async () => {
@@ -131,7 +128,7 @@ test('encode array (undefined)', async () => {
 });
 
 test('encode array (spares)', async () => {
-    const array = new Array(3);
+    const array = Array.from({ length: 3 });
     array[1] = true;
     expect(toArray(await encodeAsync(array))).toEqual(toArray('[', 'Z', 'T', 'Z', ']'));
 });
@@ -195,25 +192,19 @@ test('encode array of objects of arrays', async () => {
 });
 
 test('encode array (int8 typed array)', async () => {
-    expect(toArray(await encodeAsync(Int8Array.from([18, -2])))).toEqual(
-        toArray('[', '$', 'i', '#', 'i', 2, 0x12, 0xfe),
-    );
+    expect(toArray(await encodeAsync(Int8Array.from([18, -2])))).toEqual(toArray('[', '$', 'i', '#', 'i', 2, 0x12, 0xfe));
 });
 
 test('encode array (uint8 typed array)', async () => {
-    expect(toArray(await encodeAsync(Uint8Array.from([18, 254])))).toEqual(
-        toArray('[', '$', 'U', '#', 'i', 2, 0x12, 0xfe),
-    );
+    expect(toArray(await encodeAsync(Uint8Array.from([18, 254])))).toEqual(toArray('[', '$', 'U', '#', 'i', 2, 0x12, 0xfe));
 });
 
 test('encode array (int16 typed array)', async () => {
-    expect(toArray(await encodeAsync(Int16Array.from([4660, -292])))).toEqual(
-        toArray('[', '$', 'I', '#', 'i', 2, 0x12, 0x34, 0xfe, 0xdc),
-    );
+    expect(toArray(await encodeAsync(Int16Array.from([4660, -292])))).toEqual(toArray('[', '$', 'I', '#', 'i', 2, 0x12, 0x34, 0xfe, 0xdc));
 });
 
 test('encode array (int32 typed array)', async () => {
-    expect(toArray(await encodeAsync(Int32Array.from([305419896, -19088744])))).toEqual(
+    expect(toArray(await encodeAsync(Int32Array.from([305_419_896, -19_088_744])))).toEqual(
         toArray('[', '$', 'l', '#', 'i', 2, 0x12, 0x34, 0x56, 0x78, 0xfe, 0xdc, 0xba, 0x98),
     );
 });
@@ -226,30 +217,7 @@ test('encode array (float32 typed array)', async () => {
 
 test('encode array (float64 typed array)', async () => {
     expect(toArray(await encodeAsync(Float64Array.from([0.25, 0.125])))).toEqual(
-        toArray(
-            '[',
-            '$',
-            'D',
-            '#',
-            'i',
-            2,
-            0x3f,
-            0xd0,
-            0x00,
-            0x00,
-            0x00,
-            0x00,
-            0x00,
-            0x00,
-            0x3f,
-            0xc0,
-            0x00,
-            0x00,
-            0x00,
-            0x00,
-            0x00,
-            0x00,
-        ),
+        toArray('[', '$', 'D', '#', 'i', 2, 0x3f, 0xd0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00),
     );
 });
 
@@ -274,9 +242,7 @@ test('encode array (int64 typed array)', async () => {
 });
 
 test('encode object', async () => {
-    expect(toArray(await encodeAsync({ a: 1, b: 2, c: 3 }))).toEqual(
-        toArray('{', 'i', 1, 'a', 'U', 1, 'i', 1, 'b', 'U', 2, 'i', 1, 'c', 'U', 3, '}'),
-    );
+    expect(toArray(await encodeAsync({ a: 1, b: 2, c: 3 }))).toEqual(toArray('{', 'i', 1, 'a', 'U', 1, 'i', 1, 'b', 'U', 2, 'i', 1, 'c', 'U', 3, '}'));
 });
 
 test('encode object (empty)', async () => {
@@ -288,15 +254,11 @@ test('encode object (empty key)', async () => {
 });
 
 test('encode object (mixed)', async () => {
-    expect(toArray(await encodeAsync({ a: 1, b: 'a', c: true }))).toEqual(
-        toArray('{', 'i', 1, 'a', 'U', 1, 'i', 1, 'b', 'C', 'a', 'i', 1, 'c', 'T', '}'),
-    );
+    expect(toArray(await encodeAsync({ a: 1, b: 'a', c: true }))).toEqual(toArray('{', 'i', 1, 'a', 'U', 1, 'i', 1, 'b', 'C', 'a', 'i', 1, 'c', 'T', '}'));
 });
 
 test('encode object (only null values)', async () => {
-    expect(toArray(await encodeAsync({ a: null, b: null, c: null }))).toEqual(
-        toArray('{', 'i', 1, 'a', 'Z', 'i', 1, 'b', 'Z', 'i', 1, 'c', 'Z', '}'),
-    );
+    expect(toArray(await encodeAsync({ a: null, b: null, c: null }))).toEqual(toArray('{', 'i', 1, 'a', 'Z', 'i', 1, 'b', 'Z', 'i', 1, 'c', 'Z', '}'));
 });
 
 test('encode object (skip prototype)', async () => {
@@ -304,9 +266,7 @@ test('encode object (skip prototype)', async () => {
     obj.a = 1;
     obj.b = 'a';
     obj.c = true;
-    expect(toArray(await encodeAsync(obj))).toEqual(
-        toArray('{', 'i', 1, 'a', 'U', 1, 'i', 1, 'b', 'C', 'a', 'i', 1, 'c', 'T', '}'),
-    );
+    expect(toArray(await encodeAsync(obj))).toEqual(toArray('{', 'i', 1, 'a', 'U', 1, 'i', 1, 'b', 'C', 'a', 'i', 1, 'c', 'T', '}'));
 });
 
 test('encode object (skip symbol)', async () => {
@@ -352,9 +312,7 @@ test('encode huge typed array (16K)', async () => {
 
 test('encode huge typed array (~128M)', async () => {
     const obj = new Uint8Array(128 * 1024 * 1024 - 10);
-    expect(toArray((await encodeAsync(obj)).slice(0, 10))).toEqual(
-        toArray('[', '$', 'U', '#', 'l', 0x7, 0xff, 0xff, 0xf6, 0),
-    );
+    expect(toArray((await encodeAsync(obj)).slice(0, 10))).toEqual(toArray('[', '$', 'U', '#', 'l', 0x7, 0xff, 0xff, 0xf6, 0));
 });
 
 test('encode huge typed array (256M + 1) [error]', async () => {
@@ -369,9 +327,7 @@ test('encode huge typed array (3G) [error]', async () => {
 
 test('encode huge data (~128M)', async () => {
     const obj = [new Uint8Array(128 * 1024 * 1024 - 20)];
-    expect(toArray((await encodeAsync(obj)).slice(0, 11))).toEqual(
-        toArray('[', '[', '$', 'U', '#', 'l', 0x7, 0xff, 0xff, 0xec, 0),
-    );
+    expect(toArray((await encodeAsync(obj)).slice(0, 11))).toEqual(toArray('[', '[', '$', 'U', '#', 'l', 0x7, 0xff, 0xff, 0xec, 0));
 });
 
 test('encode huge data (256M + 1) [error]', async () => {

package/tests/stream/decode.js

@@ -8,7 +8,6 @@ import { toBuffer } from '../.utils.js';
 
 /**
  * 包装为 promise
- *
  * @param {Uint8Array} data ubjson 数据
  */
 async function decode(data) {
@@ -18,7 +17,6 @@ async function decode(data) {
 
 /**
  * 包装为 promise
- *
  * @param {import("stream").Transform} stream ubjson 流
  */
 function eos(stream) {
@@ -70,7 +68,7 @@ test('decode int16', async () => {
 });
 
 test('decode int32', async () => {
-    expect(await decode(toBuffer('l', 0x12, 0x34, 0x56, 0x78))).toBe(0x12345678);
+    expect(await decode(toBuffer('l', 0x12, 0x34, 0x56, 0x78))).toBe(0x1234_5678);
 });
 
 test('decode int64 [error]', async () => {
@@ -78,11 +76,11 @@ test('decode int64 [error]', async () => {
 });
 
 test('decode float32', async () => {
-    expect(await decode(toBuffer('d', 0x3f, 0x80, 0x80, 0x00))).toBe(1.00390625);
+    expect(await decode(toBuffer('d', 0x3f, 0x80, 0x80, 0x00))).toBe(1.003_906_25);
 });
 
 test('decode float64', async () => {
-    expect(await decode(toBuffer('D', 0x40, 0xf8, 0x6a, 0x00, 0x10, 0x00, 0x00, 0x00))).toBe(100000.00390625);
+    expect(await decode(toBuffer('D', 0x40, 0xf8, 0x6a, 0x00, 0x10, 0x00, 0x00, 0x00))).toBe(100_000.003_906_25);
 });
 
 test('decode high-precision number [error]', async () => {
@@ -128,9 +126,7 @@ test('decode huge string', async () => {
 });
 
 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/,
-    );
+    await expect(() => decode(toBuffer('S', 'L', 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 'x'))).rejects.toThrow(/Unsupported type int64/);
 });
 
 test('decode array', async () => {
@@ -166,11 +162,10 @@ test('decode array (strongly typed, empty, optimized)', async () => {
 });
 
 test('decode N-D array (strongly typed, optimized)', async () => {
-    expect(
-        await decode(
-            toBuffer('[', '$', '[', '#', 'i', 2, '$', 'i', '#', 'i', 3, 1, 2, 3, '$', 'i', '#', 'i', 3, 4, 5, 6),
-        ),
-    ).toEqual([new Int8Array([1, 2, 3]), new Int8Array([4, 5, 6])]);
+    expect(await decode(toBuffer('[', '$', '[', '#', 'i', 2, '$', 'i', '#', 'i', 3, 1, 2, 3, '$', 'i', '#', 'i', 3, 4, 5, 6))).toEqual([
+        new Int8Array([1, 2, 3]),
+        new Int8Array([4, 5, 6]),
+    ]);
 });
 
 test('decode array of objects (optimized)', async () => {
@@ -342,13 +337,11 @@ test('decode array (int16, strongly typed, optimized) [use typed array]', async
 test('decode array (int32, strongly typed, optimized) [use typed array]', async () => {
     const actual = await decode(toBuffer('[', '$', 'l', '#', 'i', 2, 0x12, 0x34, 0x56, 0x78, 0xfe, 0xdc, 0xba, 0x98));
     expect(actual).toBeInstanceOf(Int32Array);
-    expect(actual).toEqual(Int32Array.from([305419896, -19088744]));
+    expect(actual).toEqual(Int32Array.from([305_419_896, -19_088_744]));
 });
 
 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();
+    await expect(() => decode(toBuffer('[', '$', 'L', '#', 'i', 1, 0x12, 0x34, 0x56, 0x78, 0xfe, 0xdc, 0xba, 0x98))).rejects.toThrow();
 });
 
 test('decode array (float32, strongly typed, optimized) [use typed array]', async () => {
@@ -359,30 +352,7 @@ test('decode array (float32, strongly typed, optimized) [use typed array]', asyn
 
 test('decode array (float64, strongly typed, optimized) [use typed array]', async () => {
     const actual = await decode(
-        toBuffer(
-            '[',
-            '$',
-            'D',
-            '#',
-            'i',
-            2,
-            0x3f,
-            0xd0,
-            0x00,
-            0x00,
-            0x00,
-            0x00,
-            0x00,
-            0x00,
-            0x3f,
-            0xc0,
-            0x00,
-            0x00,
-            0x00,
-            0x00,
-            0x00,
-            0x00,
-        ),
+        toBuffer('[', '$', 'D', '#', 'i', 2, 0x3f, 0xd0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00),
     );
     expect(actual).toBeInstanceOf(Float64Array);
     expect(actual).toEqual(Float64Array.from([0.25, 0.125]));
@@ -397,11 +367,11 @@ test('decode object', async () => {
 });
 
 test('decode object (with no-op)', async () => {
-    expect(
-        await decode(
-            toBuffer('N', '{', 'N', 'i', 1, 'a', 'i', 1, 'i', 1, 'b', 'N', 'i', 2, 'i', 1, 'c', 'i', 3, 'N', '}', 'N'),
-        ),
-    ).toEqual({ a: 1, b: 2, c: 3 });
+    expect(await decode(toBuffer('N', '{', 'N', 'i', 1, 'a', 'i', 1, 'i', 1, 'b', 'N', 'i', 2, 'i', 1, 'c', 'i', 3, 'N', '}', 'N'))).toEqual({
+        a: 1,
+        b: 2,
+        c: 3,
+    });
 });
 
 test('decode array (empty, optimized)', async () => {
@@ -409,9 +379,7 @@ test('decode array (empty, optimized)', async () => {
 });
 
 test('decode object (mixed, optimized)', async () => {
-    expect(
-        await decode(toBuffer('{', '#', 'i', 3, 'i', 1, 'a', 'i', 1, 'i', 1, 'b', 'C', 'a', 'i', 1, 'c', 'T')),
-    ).toEqual({
+    expect(await decode(toBuffer('{', '#', 'i', 3, 'i', 1, 'a', 'i', 1, 'i', 1, 'b', 'C', 'a', 'i', 1, 'c', 'T'))).toEqual({
         a: 1,
         b: 'a',
         c: true,