@cloudpss/ubjson 0.4.15 → 0.4.17

package/src/common/string-encoder.ts

@@ -1,3 +1,58 @@
+// https://github.com/ehmicky/string-byte-length/blob/main/src/char_code.js
+
+// Last ASCII character (1 byte)
+const LAST_ASCII_CODEPOINT = 0x7f;
+// Last 2-bytes character
+const LAST_TWO_BYTES_CODEPOINT = 0x7ff;
+// Others are 3 bytes characters
+// However, U+d800 to U+dbff:
+//  - Followed by U+dc00 to U+dfff -> 4 bytes together (astral character)
+//  - Otherwise -> 3 bytes (like above)
+const FIRST_HIGH_SURROGATE = 0xd800;
+const LAST_HIGH_SURROGATE = 0xdbff;
+const FIRST_LOW_SURROGATE = 0xdc00;
+const LAST_LOW_SURROGATE = 0xdfff;
+/** 计算使用的空间 */
+function getCharCodeByteLength(string: string): number {
+    const charLength = string.length;
+    let byteLength = charLength;
+
+    for (let charIndex = 0; charIndex < charLength; charIndex += 1) {
+        const codepoint = string.charCodeAt(charIndex);
+
+        if (codepoint <= LAST_ASCII_CODEPOINT) {
+            continue;
+        }
+
+        if (codepoint <= LAST_TWO_BYTES_CODEPOINT) {
+            byteLength += 1;
+            continue;
+        }
+
+        byteLength += 2;
+
+        if (codepoint < FIRST_HIGH_SURROGATE || codepoint > LAST_HIGH_SURROGATE) {
+            continue;
+        }
+
+        // When out-of-bound, this returns NaN, which is `false` with the
+        // next condition
+        const nextCodepoint = string.charCodeAt(charIndex + 1);
+
+        // High surrogates should be followed by low surrogates.
+        // However, JavaScript strings allow invalid surrogates, which are counted
+        // as a normal 3-byte character. This should not happen often in real code
+        // though.
+        if (nextCodepoint < FIRST_LOW_SURROGATE || nextCodepoint > LAST_LOW_SURROGATE) {
+            continue;
+        }
+
+        charIndex += 1;
+    }
+
+    return byteLength;
+}
+
 /** 字符串编码器 */
 export class StringEncoder extends TextEncoder {
     private readonly cache = new Map<string, Uint8Array>();
@@ -31,4 +86,12 @@ export class StringEncoder extends TextEncoder {
         }
         return buf;
     }
+
+    /** 计算使用的空间 */
+    byteLength(value: string): number {
+        if (typeof Buffer == 'function' && typeof Buffer.byteLength == 'function') {
+            return Buffer.byteLength(value, 'utf8');
+        }
+        return getCharCodeByteLength(value);
+    }
 }

package/src/decoder.ts

@@ -1,3 +1 @@
-import { Decoder } from './common/decoder.js';
-
-export { Decoder };
+export { Decoder } from './common/decoder.js';

package/src/encoder.ts

@@ -38,7 +38,7 @@ export class Encoder extends EncoderBase {
             // 为根 typed array 优化，减少不必要的分配
             if (this.value.byteLength < 128) this.ensureCapacity(6 + this.value.byteLength);
             else if (this.value.byteLength < 32768) this.ensureCapacity(7 + this.value.byteLength);
-            else if (this.value.byteLength < 2147483648) this.ensureCapacity(9 + this.value.byteLength);
+            else if (this.value.byteLength < 2_147_483_648) this.ensureCapacity(9 + this.value.byteLength);
             else this.ensureCapacity(13 + this.value.byteLength);
             this.writeTypedArray(this.value);
             // 取消注释后运行测试
@@ -60,9 +60,7 @@ export class Encoder extends EncoderBase {
         }
 
         // 合并缓冲区
-        const result = new Uint8Array(
-            this.length + this.flushedBuffers.reduce((sum, buffer) => sum + buffer.byteLength, 0),
-        );
+        const result = new Uint8Array(this.length + this.flushedBuffers.reduce((sum, buffer) => sum + buffer.byteLength, 0));
         let offset = 0;
         for (const buffer of this.flushedBuffers) {
             result.set(buffer, offset);

package/src/stream-helper/decoder.ts

@@ -1,6 +1,4 @@
-import { Decoder, UnexpectedEof } from '../common/decoder.js';
-
-export { UnexpectedEof };
+import { Decoder } from '../common/decoder.js';
 
 /** 流式解码 UBJSON */
 export class StreamDecoderHelper extends Decoder {
@@ -13,3 +11,5 @@ export class StreamDecoderHelper extends Decoder {
         return this.offset;
     }
 }
+
+export { UnexpectedEof } from '../common/decoder.js';

package/src/utils.ts

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

package/tests/decode.js

@@ -51,7 +51,7 @@ test('decode int16', () => {
 });
 
 test('decode int32', () => {
-    expect(decode(toBuffer('l', 0x12, 0x34, 0x56, 0x78))).toBe(0x12345678);
+    expect(decode(toBuffer('l', 0x12, 0x34, 0x56, 0x78))).toBe(0x1234_5678);
 });
 
 test('decode int64 [error]', () => {
@@ -59,11 +59,11 @@ test('decode int64 [error]', () => {
 });
 
 test('decode float32', () => {
-    expect(decode(toBuffer('d', 0x3f, 0x80, 0x80, 0x00))).toBe(1.00390625);
+    expect(decode(toBuffer('d', 0x3f, 0x80, 0x80, 0x00))).toBe(1.003_906_25);
 });
 
 test('decode float64', () => {
-    expect(decode(toBuffer('D', 0x40, 0xf8, 0x6a, 0x00, 0x10, 0x00, 0x00, 0x00))).toBe(100000.00390625);
+    expect(decode(toBuffer('D', 0x40, 0xf8, 0x6a, 0x00, 0x10, 0x00, 0x00, 0x00))).toBe(100_000.003_906_25);
 });
 
 test('decode high-precision number [error]', () => {
@@ -109,9 +109,7 @@ test('decode huge string', () => {
 });
 
 test('decode huge string [error]', () => {
-    expect(() => decode(toBuffer('S', 'L', 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 'x'))).toThrow(
-        /Unsupported type int64/,
-    );
+    expect(() => decode(toBuffer('S', 'L', 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 'x'))).toThrow(/Unsupported type int64/);
 });
 
 test('decode array', () => {
@@ -147,9 +145,10 @@ test('decode array (strongly typed, empty, optimized)', () => {
 });
 
 test('decode N-D array (strongly typed, optimized)', () => {
-    expect(
-        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(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)', () => {
@@ -321,13 +320,11 @@ test('decode array (int16, strongly typed, optimized) [use typed array]', () =>
 test('decode array (int32, strongly typed, optimized) [use typed array]', () => {
     const actual = 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]', () => {
-    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))).toThrow();
 });
 
 test('decode array (float32, strongly typed, optimized) [use typed array]', () => {
@@ -337,32 +334,7 @@ test('decode array (float32, strongly typed, optimized) [use typed array]', () =
 });
 
 test('decode array (float64, strongly typed, optimized) [use typed array]', () => {
-    const actual = decode(
-        toBuffer(
-            '[',
-            '$',
-            'D',
-            '#',
-            'i',
-            2,
-            0x3f,
-            0xd0,
-            0x00,
-            0x00,
-            0x00,
-            0x00,
-            0x00,
-            0x00,
-            0x3f,
-            0xc0,
-            0x00,
-            0x00,
-            0x00,
-            0x00,
-            0x00,
-            0x00,
-        ),
-    );
+    const actual = decode(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]));
 });
@@ -376,11 +348,7 @@ test('decode object', () => {
 });
 
 test('decode object (with no-op)', () => {
-    expect(
-        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(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)', () => {

package/tests/e2e.js

@@ -19,14 +19,14 @@ test('encode/decode complex object', () => {
                 id: 1,
                 name: 'test',
                 content: null,
-                timestamp: 1532432408.008,
+                timestamp: 1_532_432_408.008,
                 published: false,
             },
             {
                 id: 2,
                 name: 'lorem',
                 content: 'Lorem ipsum...',
-                timestamp: 1532432416.346,
+                timestamp: 1_532_432_416.346,
                 published: true,
             },
         ],
@@ -34,12 +34,12 @@ test('encode/decode complex object', () => {
             traces: [
                 {
                     name: 'test',
-                    x: new Float64Array([1, 2, 3, -Infinity, Infinity, NaN, Number.MAX_VALUE, Number.MIN_VALUE]),
+                    x: new Float64Array([1, 2, 3, Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY, Number.NaN, Number.MAX_VALUE, Number.MIN_VALUE]),
                     y: new Int8Array([0, 4, 5, 6, -128, -1, 127]),
                 },
                 {
                     name: 'test2',
-                    x: new Float32Array([1, 2, 3, -Infinity, Infinity, NaN, Number.MAX_VALUE, Number.MIN_VALUE]),
+                    x: new Float32Array([1, 2, 3, Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY, Number.NaN, Number.MAX_VALUE, Number.MIN_VALUE]),
                     y: new Int16Array([4, 5, 6, -32768, 32767]),
                 },
                 {
@@ -52,7 +52,7 @@ test('encode/decode complex object', () => {
         description1: 'medium text'.repeat(100),
         description2: 'medium text'.repeat(1000),
         document1: 'long text'.repeat(10000),
-        document2: 'long text'.repeat(100000),
+        document2: 'long text'.repeat(100_000),
     };
     const encoded = encode(expected);
     const actual = decode(Buffer.from(encoded));
@@ -78,7 +78,7 @@ test('encode/decode model', () => {
                 pins: {
                     input: {
                         position: {
-                            x: 0.9999999,
+                            x: 0.999_999_9,
                             y: 0.5,
                         },
                     },
@@ -90,7 +90,7 @@ test('encode/decode model', () => {
                     },
                     electrical: {
                         position: {
-                            x: 0.9999999,
+                            x: 0.999_999_9,
                             y: 0.5,
                         },
                     },
@@ -102,7 +102,7 @@ test('encode/decode model', () => {
                         refPath: {
                             d: 'm90000 0h-60000a10000 10000 0 0 0 0 20000h60000zm0 10000h20000',
                             h: 20000,
-                            w: 110000,
+                            w: 110_000,
                         },
                         fillOpacity: 'var(--fill-opacity)',
                         strokeWidth: 'var(--stroke-width)',
@@ -114,7 +114,7 @@ test('encode/decode model', () => {
                         refPath: {
                             d: 'm90000 0h-60000a10000 10000 0 0 0 0 20000h60000zm0 10000h20000',
                             h: 20000,
-                            w: 110000,
+                            w: 110_000,
                         },
                         fillOpacity: 'var(--fill-opacity)',
                         strokeWidth: 'var(--stroke-width)',
@@ -126,7 +126,7 @@ test('encode/decode model', () => {
                         refPath: {
                             d: 'm20000 10000m-5000 -5000l5000 5000l-5000 5000',
                             h: 20000,
-                            w: 110000,
+                            w: 110_000,
                         },
                         fillOpacity: 'var(--fill-opacity)',
                         strokeWidth: 'var(--stroke-width)',
@@ -138,7 +138,7 @@ test('encode/decode model', () => {
                         refPath: {
                             d: 'm20000 0h60000a10000 10000 0 0 1 0 20000h-60000zm0 10000h-20000',
                             h: 20000,
-                            w: 110000,
+                            w: 110_000,
                         },
                         fillOpacity: 'var(--fill-opacity)',
                         strokeWidth: 'var(--stroke-width)',
@@ -150,7 +150,7 @@ test('encode/decode model', () => {
                         refPath: {
                             d: 'm110000 10000m-5000 -5000l5000 5000l-5000 5000',
                             h: 20000,
-                            w: 110000,
+                            w: 110_000,
                         },
                         fillOpacity: 'var(--fill-opacity)',
                         strokeWidth: 'var(--stroke-width)',
@@ -219,8 +219,7 @@ test('encode/decode model', () => {
                             name: 'Pin Key',
                             type: 'choice',
                             value: '',
-                            choices:
-                                '=mapper(p,index,array) = {key: p.key, name: p.key, description: p.description};\n$$.revision.pins.map(mapper)',
+                            choices: '=mapper(p,index,array) = {key: p.key, name: p.key, description: p.description};\n$$.revision.pins.map(mapper)',
                             condition: 'true',
                             description: '绑定端口',
                         },
@@ -298,14 +297,14 @@ test('encode/decode complex object (no encodeInto)', () => {
                 id: 1,
                 name: 'test',
                 content: null,
-                timestamp: 1532432408.008,
+                timestamp: 1_532_432_408.008,
                 published: false,
             },
             {
                 id: 2,
                 name: 'lorem',
                 content: 'Lorem ipsum...',
-                timestamp: 1532432416.346,
+                timestamp: 1_532_432_416.346,
                 published: true,
             },
         ],
@@ -313,12 +312,12 @@ test('encode/decode complex object (no encodeInto)', () => {
             traces: [
                 {
                     name: 'test',
-                    x: new Float64Array([1, 2, 3, -Infinity, Infinity, NaN, Number.MAX_VALUE, Number.MIN_VALUE]),
+                    x: new Float64Array([1, 2, 3, Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY, Number.NaN, Number.MAX_VALUE, Number.MIN_VALUE]),
                     y: new Int8Array([0, 4, 5, 6, -128, -1, 127]),
                 },
                 {
                     name: 'test2',
-                    x: new Float32Array([1, 2, 3, -Infinity, Infinity, NaN, Number.MAX_VALUE, Number.MIN_VALUE]),
+                    x: new Float32Array([1, 2, 3, Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY, Number.NaN, Number.MAX_VALUE, Number.MIN_VALUE]),
                     y: new Int16Array([4, 5, 6, -32768, 32767]),
                 },
                 {
@@ -331,7 +330,7 @@ test('encode/decode complex object (no encodeInto)', () => {
         description1: 'medium text'.repeat(100),
         description2: 'medium text'.repeat(1000),
         document1: 'long text'.repeat(10000),
-        document2: 'long text'.repeat(100000),
+        document2: 'long text'.repeat(100_000),
     };
     const encoded = encode(expected);
     const actual = decode(encoded);
@@ -340,10 +339,10 @@ test('encode/decode complex object (no encodeInto)', () => {
 });
 
 test('encode/decode large array', () => {
-    const array = new Array(100000);
+    const array = Array.from({ length: 100_000 });
     array[12345] = 'item';
 
-    const expected = Array.from({ length: 100000 }).fill(null);
+    const expected = Array.from({ length: 100_000 }).fill(null);
     expected[12345] = 'item';
 
     expect(decode(encode(array))).toEqual(expected);

package/tests/encode.js

@@ -50,19 +50,19 @@ test('encode int16', () => {
 });
 
 test('encode int32', () => {
-    expect(toArray(encode(0x12345678))).toEqual(toArray('l', 0x12, 0x34, 0x56, 0x78));
+    expect(toArray(encode(0x1234_5678))).toEqual(toArray('l', 0x12, 0x34, 0x56, 0x78));
 });
 
 test('encode float32', () => {
-    expect(toArray(encode(1.00390625))).toEqual(toArray('d', 0x3f, 0x80, 0x80, 0x00));
+    expect(toArray(encode(1.003_906_25))).toEqual(toArray('d', 0x3f, 0x80, 0x80, 0x00));
 });
 
 test('encode float32 (too large integer)', () => {
-    expect(toArray(encode(2147483648))).toEqual(toArray('d', 0x4f, 0x00, 0x00, 0x00));
+    expect(toArray(encode(2_147_483_648))).toEqual(toArray('d', 0x4f, 0x00, 0x00, 0x00));
 });
 
 test('encode float64', () => {
-    expect(toArray(encode(100000.00390625))).toEqual(toArray('D', 0x40, 0xf8, 0x6a, 0x00, 0x10, 0x00, 0x00, 0x00));
+    expect(toArray(encode(100_000.003_906_25))).toEqual(toArray('D', 0x40, 0xf8, 0x6a, 0x00, 0x10, 0x00, 0x00, 0x00));
 });
 
 test('encode char', () => {
@@ -70,7 +70,7 @@ test('encode char', () => {
 });
 
 test('encode char 128', () => {
-    expect(toArray(encode('\xcc'))).toEqual(toArray('C', '\xcc'));
+    expect(toArray(encode('\u00CC'))).toEqual(toArray('C', '\u00CC'));
 });
 
 test('encode char 257', () => {
@@ -109,7 +109,7 @@ test('encode array (undefined)', () => {
 });
 
 test('encode array (spares)', () => {
-    const array = new Array(3);
+    const array = Array.from({ length: 3 });
     array[1] = true;
     expect(toArray(encode(array))).toEqual(toArray('[', 'Z', 'T', 'Z', ']'));
 });
@@ -185,49 +185,22 @@ test('encode array (buffer array)', () => {
 });
 
 test('encode array (int16 typed array)', () => {
-    expect(toArray(encode(Int16Array.from([4660, -292])))).toEqual(
-        toArray('[', '$', 'I', '#', 'i', 2, 0x12, 0x34, 0xfe, 0xdc),
-    );
+    expect(toArray(encode(Int16Array.from([4660, -292])))).toEqual(toArray('[', '$', 'I', '#', 'i', 2, 0x12, 0x34, 0xfe, 0xdc));
 });
 
 test('encode array (int32 typed array)', () => {
-    expect(toArray(encode(Int32Array.from([305419896, -19088744])))).toEqual(
+    expect(toArray(encode(Int32Array.from([305_419_896, -19_088_744])))).toEqual(
         toArray('[', '$', 'l', '#', 'i', 2, 0x12, 0x34, 0x56, 0x78, 0xfe, 0xdc, 0xba, 0x98),
     );
 });
 
 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),
-    );
+    expect(toArray(encode(Float32Array.from([0.25, 0.125])))).toEqual(toArray('[', '$', 'd', '#', 'i', 2, 0x3e, 0x80, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00));
 });
 
 test('encode array (float64 typed array)', () => {
     expect(toArray(encode(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),
     );
 });
 
@@ -252,9 +225,7 @@ test('encode array (int64 typed array)', () => {
 });
 
 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, '}'),
-    );
+    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, '}'));
 });
 
 test('encode object (empty)', () => {
@@ -266,15 +237,11 @@ test('encode object (empty key)', () => {
 });
 
 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', '}'),
-    );
+    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', '}'));
 });
 
 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', '}'),
-    );
+    expect(toArray(encode({ 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)', () => {
@@ -282,9 +249,7 @@ test('encode object (skip prototype)', () => {
     obj.a = 1;
     obj.b = 'a';
     obj.c = true;
-    expect(toArray(encode(obj))).toEqual(
-        toArray('{', 'i', 1, 'a', 'U', 1, 'i', 1, 'b', 'C', 'a', 'i', 1, 'c', 'T', '}'),
-    );
+    expect(toArray(encode(obj))).toEqual(toArray('{', 'i', 1, 'a', 'U', 1, 'i', 1, 'b', 'C', 'a', 'i', 1, 'c', 'T', '}'));
 });
 
 test('encode object (skip symbol)', () => {
@@ -347,19 +312,32 @@ test('encode huge data (~128M)', () => {
     const obj = [new Uint8Array(128 * 1024 * 1024 - 20)];
     obj[0][0] = 0x12;
     obj[0][1] = 0x34;
-    expect(toArray(encode(obj).slice(0, 12))).toEqual(
-        toArray('[', '[', '$', 'U', '#', 'l', 0x7, 0xff, 0xff, 0xec, 0x12, 0x34),
-    );
+    expect(toArray(encode(obj).slice(0, 12))).toEqual(toArray('[', '[', '$', 'U', '#', 'l', 0x7, 0xff, 0xff, 0xec, 0x12, 0x34));
 });
 
 test('encode huge data (128M)', () => {
     const obj = [new Uint8Array(128 * 1024 * 1024)];
     obj[0][0] = 0x12;
     obj[0][1] = 0x34;
-    expect(toArray(encode(obj).slice(0, 12))).toEqual(toArray('[', '[', '$', 'U', '#', 'l', 0x8, 0, 0, 0, 0x12, 0x34));
+    const encoded = encode(obj);
+    expect(encoded.length).toBe(128 * 1024 * 1024 + 9 + 2);
+    expect(toArray(encoded.slice(0, 12))).toEqual(toArray('[', '[', '$', 'U', '#', 'l', 0x8, 0, 0, 0, 0x12, 0x34));
 });
 
 test('encode huge data (128M + 1) [error]', () => {
     const obj = [new Uint8Array(128 * 1024 * 1024 + 1)];
     expect(() => encode(obj)).toThrow(/Buffer has exceed max size/);
 });
+
+test('encode huge data (256M)', () => {
+    const obj = [new Uint8Array(128 * 1024 * 1024), new Uint8Array(128 * 1024 * 1024)];
+    obj[0][0] = 0x12;
+    obj[0][1] = 0x34;
+    obj[1][0] = 0x56;
+    obj[1][1] = 0x78;
+    const encoded = encode(obj);
+    expect(encoded.length).toBe(128 * 1024 * 1024 * 2 + 9 * 2 + 2);
+    expect(toArray(encoded.slice(0, 12))).toEqual(toArray('[', '[', '$', 'U', '#', 'l', 0x8, 0, 0, 0, 0x12, 0x34));
+    expect(toArray(encoded.slice(128 * 1024 * 1024 + 10, 128 * 1024 * 1024 + 10 + 11))).toEqual(toArray('[', '$', 'U', '#', 'l', 0x8, 0, 0, 0, 0x56, 0x78));
+    expect(toArray(encoded.slice(-1))).toEqual(toArray(']'));
+});