@cloudpss/ubjson 0.5.36 → 0.5.38

package/tests/.utils.js

@@ -1,7 +1,11 @@
-import { resetEnv as resetDecoderEnv } from '../dist/common/string-decoder.js';
-import { resetEnv as resetEncoderEnv } from '../dist/common/string-encoder.js';
+import { resetEnv as resetDecoderEnv } from '../dist/helper/string-decoder.js';
+import { resetEnv as resetEncoderEnv } from '../dist/helper/string-encoder.js';
 import { resetEncoder } from '../dist/encoder.js';
+import '../dist/helper/constants.js';
 
+/**
+ * 重设所有环境
+ */
 export function resetEnv() {
     resetDecoderEnv();
     resetEncoderEnv();
@@ -10,7 +14,6 @@ export function resetEnv() {
 
 /**
  * 输入转为数字数组以便比较
- *
  * @param {[ArrayBuffer] | [Uint8Array] | (number | string)[]} args 输入
  * @returns {number[]} 数字数组
  */
@@ -26,7 +29,6 @@ export function toArray(...args) {
 
 /**
  * 将数字或字符串转换为 Uint8Array
- *
  * @param  {...string | number} args 数字或 char 的数组
  * @returns {Uint8Array} Uint8Array
  */

package/tests/decode.js

@@ -202,24 +202,6 @@ 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(

package/tests/e2e/no-encode-into.js

@@ -4,7 +4,7 @@ import { encode, decode } from '../../dist/index.js';
 
 describe('no encodeInto', () => {
     // eslint-disable-next-line @typescript-eslint/unbound-method
-    const encodeInto = TextEncoder.prototype.encodeInto;
+    const { encodeInto } = TextEncoder.prototype;
     beforeAll(() => {
         // @ts-expect-error 移除 encodeInto 以测试兼容性
         TextEncoder.prototype.encodeInto = undefined;

package/tests/encode.js

@@ -157,7 +157,7 @@ test('encode string (len = 180)', () => {
 
 test('encode string (no encodeInto)', () => {
     // eslint-disable-next-line @typescript-eslint/unbound-method
-    const encodeInto = TextEncoder.prototype.encodeInto;
+    const { encodeInto } = TextEncoder.prototype;
     // @ts-expect-error 移除 encodeInto 以测试兼容性
     TextEncoder.prototype.encodeInto = undefined;
     expect(toArray(encode('ubjson'))).toEqual(toArray('S', 'i', 6, ...'ubjson'));

package/tests/huge-string.js

@@ -8,6 +8,7 @@ const STR_BYTE_LENGTH = 128 * 1024 * 1024 - 20;
  * 构造测试字符串
  * @param {string} char 使用的字符
  * @param {number} byteLength 需要的长度
+ * @returns {[Uint8Array, string]}
  */
 function makeString(char, byteLength) {
     const encoded = new TextEncoder().encode(char);

package/tests/rxjs/decode.js

@@ -5,11 +5,12 @@ import { jest } from '@jest/globals';
 import { firstValueFrom, of, Subject } from 'rxjs';
 import { decode as decodePipe } from '../../dist/rxjs/index.js';
 import { toBuffer } from '../.utils.js';
-import { UnexpectedEof } from '../../dist/utils.js';
+import { UnexpectedEofError as UnexpectedEof } from '../../dist/helper/errors.js';
 
 /**
  * 包装为 promise
  * @param {Uint8Array} data ubjson 数据
+ * @returns {Promise<unknown>}
  */
 async function decode(data) {
     const readable = of(data);
@@ -21,7 +22,7 @@ async function decode(data) {
  * @param {import("rxjs").Observable<Uint8Array>} observable ubjson 数据流
  * @param {(data: unknown) => void} onData 数据回调
  */
-function decodeStream(observable, onData) {
+async function decodeStream(observable, onData) {
     return /** @type {Promise<void>} */ (
         new Promise((resolve, reject) => {
             observable.pipe(decodePipe()).subscribe({
@@ -34,7 +35,7 @@ function decodeStream(observable, onData) {
 }
 
 test('decode unsupported type', async () => {
-    await expect(() => decode(toBuffer('!'))).rejects.toThrow();
+    await expect(async () => decode(toBuffer('!'))).rejects.toThrow();
 });
 
 test('decode undefined', async () => {
@@ -91,7 +92,7 @@ test('decode float64', async () => {
 });
 
 test('decode high-precision number [error]', async () => {
-    await expect(() => decode(toBuffer('H', 'i', 3, '1', '.', '1'))).rejects.toThrow();
+    await expect(async () => decode(toBuffer('H', 'i', 3, '1', '.', '1'))).rejects.toThrow();
 });
 
 test('decode char', async () => {
@@ -107,11 +108,11 @@ test('decode empty string', async () => {
 });
 
 test('decode string (bad size) [error]', async () => {
-    await expect(() => decode(toBuffer('S', 'i', 0xff, 'x'))).rejects.toThrow(/Invalid length/);
+    await expect(async () => decode(toBuffer('S', 'i', 0xff, 'x'))).rejects.toThrow(/Invalid length/);
 });
 
 test('decode string (unexpected eof) [error]', async () => {
-    await expect(() => decode(toBuffer('S', 'i', 2, 'x'))).rejects.toThrow(UnexpectedEof);
+    await expect(async () => decode(toBuffer('S', 'i', 2, 'x'))).rejects.toThrow(UnexpectedEof);
 });
 
 test('decode ascii string', async () => {
@@ -143,9 +144,9 @@ test('decode huge string', async () => {
 
 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/,
-    );
+    await expect(async () =>
+        decode(toBuffer('S', 'L', 0x77, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 'x')),
+    ).rejects.toThrow(/Invalid length/);
 });
 
 test('decode array', async () => {
@@ -309,19 +310,19 @@ test('decode array of objects of arrays (optimized)', async () => {
 });
 
 test('decode array (strongly typed, unexpected eof, optimized)', async () => {
-    await expect(() => decode(toBuffer('[', '$', 'i', '#', 'i', 3, 1, 2))).rejects.toThrow(UnexpectedEof);
+    await expect(async () => decode(toBuffer('[', '$', 'i', '#', 'i', 3, 1, 2))).rejects.toThrow(UnexpectedEof);
 });
 
 test('decode array (strongly typed, invalid length value, optimized)', async () => {
-    await expect(() => decode(toBuffer('[', '$', 'i', '#', 'i', -1))).rejects.toThrow();
+    await expect(async () => decode(toBuffer('[', '$', 'i', '#', 'i', -1))).rejects.toThrow();
 });
 
 test('decode array (strongly typed, invalid length type, optimized)', async () => {
-    await expect(() => decode(toBuffer('[', '$', 'i', '#', 'C', '0'))).rejects.toThrow();
+    await expect(async () => decode(toBuffer('[', '$', 'i', '#', 'C', '0'))).rejects.toThrow();
 });
 
 test('decode array (strongly typed, malformed, optimized)', async () => {
-    await expect(() => decode(toBuffer('[', '$', 'i', 1, 2, 3, ']'))).rejects.toThrow();
+    await expect(async () => decode(toBuffer('[', '$', 'i', 1, 2, 3, ']'))).rejects.toThrow();
 });
 
 test('decode array (only null values, optimized)', async () => {

package/tests/rxjs/encode.js

@@ -9,8 +9,9 @@ import { toArray } from '../.utils.js';
 /**
  * 包装为 promise
  * @param {unknown} value 要编码的值
+ * @returns {Promise<Buffer>}
  */
-function encodeAsync(value) {
+async function encodeAsync(value) {
     return firstValueFrom(
         of(value).pipe(
             encode(),
@@ -21,7 +22,7 @@ function encodeAsync(value) {
 }
 
 test('encode function', async () => {
-    await expect(() =>
+    await expect(async () =>
         encodeAsync(function () {
             // noop
         }),
@@ -37,7 +38,7 @@ test('encode bigint', async () => {
 });
 
 test('encode symbol', async () => {
-    await expect(() => encodeAsync(Symbol('sym'))).rejects.toThrow();
+    await expect(async () => encodeAsync(Symbol('sym'))).rejects.toThrow();
 });
 
 test('encode undefined', async () => {
@@ -113,7 +114,7 @@ test('encode huge string', async () => {
 
 test('encode string (no encodeInto)', async () => {
     // eslint-disable-next-line @typescript-eslint/unbound-method
-    const encodeInto = TextEncoder.prototype.encodeInto;
+    const { encodeInto } = TextEncoder.prototype;
     // @ts-expect-error 移除 encodeInto 以测试兼容性
     TextEncoder.prototype.encodeInto = undefined;
     expect(toArray(await encodeAsync('ubjson'))).toEqual(toArray('S', 'i', 6, 'u', 'b', 'j', 's', 'o', 'n'));
@@ -257,19 +258,19 @@ test('encode array (float64 typed array)', async () => {
 });
 
 test('encode array (uint8clamped typed array)', async () => {
-    await expect(() => encodeAsync(new Uint8ClampedArray())).rejects.toThrow();
+    await expect(async () => encodeAsync(new Uint8ClampedArray())).rejects.toThrow();
 });
 
 test('encode array (uint16 typed array)', async () => {
-    await expect(() => encodeAsync(new Uint16Array())).rejects.toThrow();
+    await expect(async () => encodeAsync(new Uint16Array())).rejects.toThrow();
 });
 
 test('encode array (uint32 typed array)', async () => {
-    await expect(() => encodeAsync(new Uint32Array())).rejects.toThrow();
+    await expect(async () => encodeAsync(new Uint32Array())).rejects.toThrow();
 });
 
 test('encode array (uint64 typed array)', async () => {
-    await expect(() => encodeAsync(new BigUint64Array())).rejects.toThrow();
+    await expect(async () => encodeAsync(new BigUint64Array())).rejects.toThrow();
 });
 
 test('encode array (int64 typed array)', async () => {
@@ -303,10 +304,10 @@ test('encode object (only null values)', async () => {
 });
 
 test('encode object (skip prototype)', async () => {
-    const obj = Object.create({ a: 2, x: 'xx' });
-    obj.a = 1;
-    obj.b = 'a';
-    obj.c = true;
+    const obj = /** @type {Record<string, unknown>} */ (Object.create({ a: 2, x: 'xx' }));
+    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', '}'),
     );

package/tests/stream/decode.js

@@ -5,11 +5,12 @@ import { jest } from '@jest/globals';
 import { Readable } from 'node:stream';
 import { decoder as decodeStream, decode as decodeAsync } from '../../dist/stream/index.js';
 import { toBuffer } from '../.utils.js';
-import { UnexpectedEof } from '../../dist/utils.js';
+import { UnexpectedEofError as UnexpectedEof } from '../../dist/helper/errors.js';
 
 /**
  * 包装为 promise
  * @param {Uint8Array} data ubjson 数据
+ * @returns {Promise<unknown>}
  */
 async function decode(data) {
     const readable = Readable.from([data], { objectMode: false });
@@ -19,8 +20,9 @@ async function decode(data) {
 /**
  * 包装为 promise
  * @param {import("stream").Transform} stream ubjson 流
+ * @returns {Promise<void>}
  */
-function eos(stream) {
+async function eos(stream) {
     return new Promise((resolve, reject) => {
         stream.on('error', reject);
         stream.on('end', resolve);
@@ -28,7 +30,7 @@ function eos(stream) {
 }
 
 test('decode unsupported type', async () => {
-    await expect(() => decode(toBuffer('!'))).rejects.toThrow();
+    await expect(async () => decode(toBuffer('!'))).rejects.toThrow();
 });
 
 test('decode undefined', async () => {
@@ -86,7 +88,7 @@ test('decode float64', async () => {
 });
 
 test('decode high-precision number [error]', async () => {
-    await expect(() => decode(toBuffer('H', 'i', 3, '1', '.', '1'))).rejects.toThrow();
+    await expect(async () => decode(toBuffer('H', 'i', 3, '1', '.', '1'))).rejects.toThrow();
 });
 
 test('decode char', async () => {
@@ -102,11 +104,11 @@ test('decode empty string', async () => {
 });
 
 test('decode string (bad size) [error]', async () => {
-    await expect(() => decode(toBuffer('S', 'i', 0xff, 'x'))).rejects.toThrow(/Invalid length/);
+    await expect(async () => decode(toBuffer('S', 'i', 0xff, 'x'))).rejects.toThrow(/Invalid length/);
 });
 
 test('decode string (unexpected eof) [error]', async () => {
-    await expect(() => decode(toBuffer('S', 'i', 2, 'x'))).rejects.toThrow(UnexpectedEof);
+    await expect(async () => decode(toBuffer('S', 'i', 2, 'x'))).rejects.toThrow(UnexpectedEof);
 });
 
 test('decode ascii string', async () => {
@@ -129,9 +131,9 @@ test('decode huge string', async () => {
 
 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/,
-    );
+    await expect(async () =>
+        decode(toBuffer('S', 'L', 0x77, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 'x')),
+    ).rejects.toThrow(/Invalid length/);
 });
 
 test('decode array', async () => {
@@ -295,19 +297,19 @@ test('decode array of objects of arrays (optimized)', async () => {
 });
 
 test('decode array (strongly typed, unexpected eof, optimized)', async () => {
-    await expect(() => decode(toBuffer('[', '$', 'i', '#', 'i', 3, 1, 2))).rejects.toThrow();
+    await expect(async () => decode(toBuffer('[', '$', 'i', '#', 'i', 3, 1, 2))).rejects.toThrow();
 });
 
 test('decode array (strongly typed, invalid length value, optimized)', async () => {
-    await expect(() => decode(toBuffer('[', '$', 'i', '#', 'i', -1))).rejects.toThrow();
+    await expect(async () => decode(toBuffer('[', '$', 'i', '#', 'i', -1))).rejects.toThrow();
 });
 
 test('decode array (strongly typed, invalid length type, optimized)', async () => {
-    await expect(() => decode(toBuffer('[', '$', 'i', '#', 'C', '0'))).rejects.toThrow();
+    await expect(async () => decode(toBuffer('[', '$', 'i', '#', 'C', '0'))).rejects.toThrow();
 });
 
 test('decode array (strongly typed, malformed, optimized)', async () => {
-    await expect(() => decode(toBuffer('[', '$', 'i', 1, 2, 3, ']'))).rejects.toThrow();
+    await expect(async () => decode(toBuffer('[', '$', 'i', 1, 2, 3, ']'))).rejects.toThrow();
 });
 
 test('decode array (only null values, optimized)', async () => {

package/tests/stream/encode.js

@@ -9,13 +9,14 @@ import { toArray } from '../.utils.js';
 /**
  * 包装为 promise
  * @param {unknown} value 值
+ * @returns {Promise<Buffer>} 返回值
  */
-function encodeAsync(value) {
+async function encodeAsync(value) {
     return buffer(encode(value));
 }
 
 test('encode function', async () => {
-    await expect(() =>
+    await expect(async () =>
         encodeAsync(function () {
             // noop
         }),
@@ -31,7 +32,7 @@ test('encode bigint', async () => {
 });
 
 test('encode symbol', async () => {
-    await expect(() => encodeAsync(Symbol('sym'))).rejects.toThrow();
+    await expect(async () => encodeAsync(Symbol('sym'))).rejects.toThrow();
 });
 
 test('encode undefined', async () => {
@@ -107,7 +108,7 @@ test('encode huge string', async () => {
 
 test('encode string (no encodeInto)', async () => {
     // eslint-disable-next-line @typescript-eslint/unbound-method
-    const encodeInto = TextEncoder.prototype.encodeInto;
+    const { encodeInto } = TextEncoder.prototype;
     // @ts-expect-error 移除 encodeInto 以测试兼容性
     TextEncoder.prototype.encodeInto = undefined;
     expect(toArray(await encodeAsync('ubjson'))).toEqual(toArray('S', 'i', 6, 'u', 'b', 'j', 's', 'o', 'n'));
@@ -251,19 +252,19 @@ test('encode array (float64 typed array)', async () => {
 });
 
 test('encode array (uint8clamped typed array)', async () => {
-    await expect(() => encodeAsync(new Uint8ClampedArray())).rejects.toThrow();
+    await expect(async () => encodeAsync(new Uint8ClampedArray())).rejects.toThrow();
 });
 
 test('encode array (uint16 typed array)', async () => {
-    await expect(() => encodeAsync(new Uint16Array())).rejects.toThrow();
+    await expect(async () => encodeAsync(new Uint16Array())).rejects.toThrow();
 });
 
 test('encode array (uint32 typed array)', async () => {
-    await expect(() => encodeAsync(new Uint32Array())).rejects.toThrow();
+    await expect(async () => encodeAsync(new Uint32Array())).rejects.toThrow();
 });
 
 test('encode array (uint64 typed array)', async () => {
-    await expect(() => encodeAsync(new BigUint64Array())).rejects.toThrow();
+    await expect(async () => encodeAsync(new BigUint64Array())).rejects.toThrow();
 });
 
 test('encode array (int64 typed array)', async () => {

package/tests/stream/many.js

@@ -14,7 +14,8 @@ function iterableToAsyncIterable(iterable) {
         [Symbol.asyncIterator]: () => {
             const iterator = iterable[Symbol.iterator]();
             return {
-                next: () => Promise.resolve(iterator.next()),
+                // eslint-disable-next-line unicorn/no-useless-promise-resolve-reject
+                next: async () => Promise.resolve(iterator.next()),
             };
         },
     };

package/tests/string-encoding.js

@@ -1,14 +1,12 @@
 import { Encoder } from '../dist/encoder.js';
-import { decode, decodeKey, jsDecode } from '../dist/common/string-decoder.js';
-import '../dist/common/constants.js';
+import { decode, decodeKey, jsDecode } from '../dist/helper/string-decoder.js';
 
 /**
  * 测试编码
+ * @param {Pick<TextEncoder, 'encode'>} encoder encoder
+ * @param {Pick<TextDecoder, 'decode'>} decoder decoder
  */
-function testEncoding(
-    /** @type {Pick<TextEncoder, 'encode'>} */ encoder,
-    /** @type {Pick<TextDecoder, 'decode'>} */ decoder,
-) {
+function testEncoding(encoder, decoder) {
     expect(decoder.decode(encoder.encode(''))).toEqual('');
     expect(decoder.decode(encoder.encode('a'))).toEqual('a');
     expect(decoder.decode(encoder.encode('p4'))).toEqual('p4');

package/benchmark-small.js

@@ -1,81 +0,0 @@
-import { load } from '@cloudpss/yaml';
-import { encode, decode } from './dist/index.js';
-import { encode as encodeAsync } from './dist/stream/index.js';
-import { encode as oldEncode, decode as oldDecode } from 'ref-impl';
-import { encode as oldEncodeAsync } from 'ref-impl/stream';
-import lodash from 'lodash';
-
-const LOOP = 100000;
-const WARM_UP = 10000;
-
-const t = (/** @type {number} */ time) => (time * 1_000_000).toFixed(2).padStart(6) + 'ns';
-
-/* eslint-disable no-console */
-const obj = decode(
-    encode(
-        load(`
-verb: create
-type: plot
-key: plot-0
-version: 1
-data: {title: 三台电机转速wr, traces: [{name: '#wr1:0', type: scatter, x: !!js/Float64Array +anx0k1iUD8AqvHSTWJgP/B+arx0k2g/8Knx0k1icD9oFK5H4Xp0P+B+arx0k3g/WOkmMQisfD/sqfHSTWKAPzzfT42XboI/jBSuR+F6hD8=, 'y': !!js/Float64Array AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8=}, {name: '#wr2:0', type: scatter, x: !!js/Float64Array +anx0k1iUD8AqvHSTWJgP/B+arx0k2g/8Knx0k1icD9oFK5H4Xp0P+B+arx0k3g/WOkmMQisfD/sqfHSTWKAPzzfT42XboI/jBSuR+F6hD8=, 'y': !!js/Float64Array AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8=}, {name: '#wr3:0', type: scatter, x: !!js/Float64Array +anx0k1iUD8AqvHSTWJgP/B+arx0k2g/8Knx0k1icD9oFK5H4Xp0P+B+arx0k3g/WOkmMQisfD/sqfHSTWKAPzzfT42XboI/jBSuR+F6hD8=, 'y': !!js/Float64Array AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8=}]}
-`),
-    ),
-);
-
-const impl = [
-    ['REF', oldEncode, oldDecode, oldEncodeAsync],
-    ['CURRENT', encode, decode, encodeAsync],
-];
-
-async function run() {
-    let encodeTime = {};
-    let encodeAsyncTime = {};
-    let decodeTime = {};
-    let obj2 = {};
-    for (const [name] of impl) {
-        encodeTime[name] = 0;
-        encodeAsyncTime[name] = 0;
-        decodeTime[name] = 0;
-    }
-    for (let i = 0; i < WARM_UP; i++) {
-        for (const [, encode, decode, encodeAsync] of impl) {
-            const encoded = encode(obj);
-            for await (const _piece of encodeAsync(obj)) {
-                continue;
-            }
-            decode(encoded);
-        }
-    }
-    for (let i = 0; i < LOOP; i++) {
-        for (const [name, encode, decode, encodeAsync] of impl) {
-            let start = performance.now();
-            const encoded = encode(obj);
-            encodeTime[name] += performance.now() - start;
-
-            start = performance.now();
-            for await (const _piece of encodeAsync(obj)) {
-                continue;
-            }
-            encodeAsyncTime[name] += performance.now() - start;
-
-            start = performance.now();
-            obj2[name] = decode(encoded);
-            decodeTime[name] += performance.now() - start;
-        }
-    }
-    for (const [name] of impl) {
-        console.assert(lodash.isEqual(obj, obj2[name]));
-    }
-    for (const [name] of impl) {
-        console.log(
-            `${name}\tencode: ${t(encodeTime[name] / LOOP)}\tencode stream: ${t(
-                encodeAsyncTime[name] / LOOP,
-            )}\tdecode: ${t(decodeTime[name] / LOOP)}`,
-        );
-    }
-}
-
-await run();
-
-console.log('');

package/benchmark-string-decode.js

@@ -1,41 +0,0 @@
-import { nativeDecode, decode, jsDecode } from './dist/common/string-decoder.js';
-
-const LOOP = 500000;
-
-const t = (/** @type {number} */ time) => time.toFixed(10) + 'ms';
-
-/** 测试数据 */
-function createTestData(/** @type {number} */ size) {
-    return new Uint8Array(size).fill(50);
-}
-
-/* eslint-disable no-console */
-
-console.log(`      Size\tTextDecoder      MyStringDecoder  my/sys%\tJsDecoder        js/sys%`);
-for (let index = 10; index < 1000; index = Math.trunc(index * 1.2)) {
-    const data = createTestData(index);
-
-    let decodeTimeSystem = 0;
-    let decodeTimeOptimal = 0;
-    let decodeTimeJs = 0;
-    for (let i = 0; i < LOOP; i++) {
-        let start = performance.now();
-        nativeDecode(data);
-        decodeTimeSystem += performance.now() - start;
-
-        start = performance.now();
-        decode(data, 0, data.byteLength);
-        decodeTimeOptimal += performance.now() - start;
-
-        start = performance.now();
-        jsDecode(data, 0, data.byteLength);
-        decodeTimeJs += performance.now() - start;
-    }
-    const ratioOptimal = decodeTimeOptimal / decodeTimeSystem;
-    const ratioJs = decodeTimeJs / decodeTimeSystem;
-    console.log(
-        `Data: ${data.byteLength} \t${t(decodeTimeSystem / LOOP)}   ${t(decodeTimeOptimal / LOOP)}   ${(
-            ratioOptimal * 100
-        ).toFixed(3)}%\t${t(decodeTimeJs / LOOP)}   ${(ratioJs * 100).toFixed(3)}%`,
-    );
-}

package/benchmark-string-encode.js

@@ -1,32 +0,0 @@
-import { jsEncodeInto, nativeEncodeInto } from './dist/common/string-encoder.js';
-
-const LOOP = 500000;
-
-const t = (/** @type {number} */ time) => time.toFixed(10) + 'ms';
-
-/** 测试数据 */
-function createTestData(/** @type {number} */ size) {
-    return ['a'.repeat(size), 'Ӓ'.repeat(size / 2), '水'.repeat(size / 3), 'aӒ水'.repeat(size / 6)];
-}
-
-/* eslint-disable no-console */
-
-console.log(`      Size\tnativeEncodeInto \tjsEncodeInto \tmy/sys%`);
-for (let index = 10; index < 1000; index = Math.trunc(index * 1.2)) {
-    const data1 = createTestData(index)[0];
-    const buf = new Uint8Array(index + 10);
-
-    let encodeSystem = 0;
-    let encodeJs = 0;
-    for (let i = 0; i < LOOP; i++) {
-        let start = performance.now();
-        nativeEncodeInto(data1, buf, 1);
-        encodeSystem += performance.now() - start;
-
-        start = performance.now();
-        jsEncodeInto(data1, buf, 1);
-        encodeJs += performance.now() - start;
-    }
-    const ratioJs = encodeJs / encodeSystem;
-    console.log(`Data: ${index} \t${t(encodeSystem / LOOP)}   ${t(encodeJs / LOOP)}   ${(ratioJs * 100).toFixed(3)}%`);
-}

package/benchmark-string-size-caculation.js

@@ -1,50 +0,0 @@
-import prettyBytes from 'pretty-bytes';
-import { jsStringByteLength, nodeStringByteLength } from './dist/common/string-encoder.js';
-
-const LOOP = 100;
-
-const t = (/** @type {number} */ time) => time.toFixed(6) + 'ms';
-const pb = (/** @type {number} */ size) => prettyBytes(size, { binary: true });
-
-/** 测试数据 */
-function createTestData(/** @type {number} */ size) {
-    return ['a'.repeat(size), 'Ӓ'.repeat(size / 2), '水'.repeat(size / 3), 'aӒ水'.repeat(size / 6)];
-}
-
-/* eslint-disable no-console */
-
-console.log(`Size            \tTime1   \tTime2   \tTime3   \tTimeMixed`);
-
-for (const i of [8, 16, 32, 64, 256, 1024, 8192, 16384, 32768, 65536, 131072, 262144, 524288, 1048576]) {
-    const [data1, data2, data3, dataMixed] = createTestData(i);
-    for (const withBuffer of [true, false]) {
-        const encode = withBuffer ? nodeStringByteLength : jsStringByteLength;
-        let size;
-        let time1 = 0,
-            time2 = 0,
-            time3 = 0,
-            timeMixed = 0;
-        for (let i = 0; i < LOOP; i++) {
-            let start = performance.now();
-            size = encode(data1);
-            time1 += performance.now() - start;
-
-            start = performance.now();
-            size = encode(data2);
-            time2 += performance.now() - start;
-
-            start = performance.now();
-            size = encode(data3);
-            time3 += performance.now() - start;
-
-            start = performance.now();
-            size = encode(dataMixed);
-            timeMixed += performance.now() - start;
-        }
-        console.log(
-            `[${withBuffer ? 'w/ ' : 'w/o'} buffer] ${pb(size)}\t${t(time1 / LOOP)} \t${t(time2 / LOOP)} \t${t(
-                time3 / LOOP,
-            )} \t${t(timeMixed / LOOP)}`,
-        );
-    }
-}