@cloudpss/ubjson 0.5.39 → 0.5.41

package/src/helper/decode.ts

@@ -1,9 +1,8 @@
 import { constants } from './constants.js';
 import { UnexpectedEofError, unsupportedType } from './errors.js';
-import { decode, decodeKey } from './string-decoder.js';
+import { decode } from './string-decoder.js';
 import { toUint8Array } from './utils.js';
-
-const { fromEntries } = Object;
+const { defineProperty } = Object;
 const { fromCharCode } = String;
 
 /** 数据包装 */
@@ -82,7 +81,7 @@ export function readLength(cursor: DecodeCursor): number {
             break;
         }
         default:
-            throw new Error(`Unexpected marker '${String.fromCharCode(marker)}'(${marker}) for int length`);
+            throw new Error(`Unexpected marker '${fromCharCode(marker)}'(${marker}) for int length`);
     }
     if (length < 0) {
         throw new Error('Invalid length');
@@ -161,6 +160,21 @@ export function read(cursor: DecodeCursor): unknown {
     return readData(cursor, marker);
 }
 
+/** 读取优化对象数据 */
+function readObjectOptimizedData(cursor: DecodeCursor, marker: OptimizedFormatMarkers): unknown {
+    const { count, type } = marker;
+    const object: Record<string, unknown> = {};
+    for (let i = 0; i < count; i++) {
+        const key = readKey(cursor);
+        const value = readData(cursor, type ?? readMarker(cursor));
+        if (key === '__proto__') {
+            defineProperty(object, key, { value, enumerable: true, configurable: true, writable: true });
+        }
+        object[key] = value;
+    }
+    return object;
+}
+
 /** 根据标签读取后续数据 */
 export function readData(cursor: DecodeCursor, marker: number): unknown {
     // 按照出现频率排序
@@ -178,32 +192,29 @@ export function readData(cursor: DecodeCursor, marker: number): unknown {
             const markers = readOptimizedFormatMarkers(cursor);
             if (markers == null) {
                 // 直到 '}'
-                const object: Array<[string, unknown]> = [];
+                const object: Record<string, unknown> = {};
                 while (readMarker(cursor) !== constants.OBJECT_END) {
                     cursor.offset--;
-                    object.push([readKey(cursor), read(cursor)]);
+                    const key = readKey(cursor);
+                    const value = read(cursor);
+                    if (key === '__proto__') {
+                        defineProperty(object, key, { value, enumerable: true, configurable: true, writable: true });
+                    }
+                    object[key] = value;
                 }
-                return fromEntries(object);
+                return object;
             }
-
-            const { count, type } = markers;
-            const object: Array<[string, unknown]> = [];
-            object.length = count;
-            for (let i = 0; i < count; i++) {
-                const key = readKey(cursor);
-                const value = readData(cursor, type ?? readMarker(cursor));
-                object[i] = [key, value];
-            }
-            return fromEntries(object);
+            return readObjectOptimizedData(cursor, markers);
         }
         case constants.ARRAY: {
             const markers = readOptimizedFormatMarkers(cursor);
             if (markers == null) {
                 const array = [];
-                // 直到 ']'
-                while (readMarker(cursor) !== constants.ARRAY_END) {
-                    cursor.offset--;
-                    array.push(read(cursor));
+                for (;;) {
+                    const marker = readMarker(cursor);
+                    // 直到 ']'
+                    if (marker === constants.ARRAY_END) break;
+                    array.push(readData(cursor, marker));
                 }
                 return array;
             }
@@ -336,11 +347,13 @@ export function readKey(cursor: DecodeCursor): string {
     cursor.offset = end;
     const { data } = cursor;
     if (end > data.length) cursor.eof();
-    return decodeKey(data, begin, end);
+    return decode(data, begin, end);
 }
 
+/** Optimized Format 数据 */
+export type OptimizedFormatMarkers = { type?: number; count: number };
 /** 读取 Optimized Format 数据 */
-export function readOptimizedFormatMarkers(cursor: DecodeCursor): { type?: number; count: number } | undefined {
+export function readOptimizedFormatMarkers(cursor: DecodeCursor): OptimizedFormatMarkers | undefined {
     let type;
     let count;
     switch (readMarker(cursor)) {

package/src/helper/encode.ts

@@ -35,12 +35,14 @@ export function writeMarker(cursor: EncodeCursor, marker: constants): void {
     cursor.data[cursor.length++] = marker;
 }
 
+export const I8_MASK = constants.INT8 << 8;
+export const U8_MASK = constants.UINT8 << 8;
 /** 写入长度 */
 export function writeLength(cursor: EncodeCursor, length: number): void {
     if (length < 0x80) {
         cursor.ensureCapacity(2);
-        cursor.data[cursor.length++] = constants.INT8;
-        cursor.data[cursor.length++] = length;
+        cursor.view.setUint16(cursor.length, I8_MASK | length);
+        cursor.length += 2;
     } else if (length < 0x8000) {
         cursor.ensureCapacity(3);
         cursor.data[cursor.length++] = constants.INT16;
@@ -61,29 +63,153 @@ export function writeLength(cursor: EncodeCursor, length: number): void {
     }
 }
 
+/** 写入数字 */
+export function writeNumber(cursor: EncodeCursor, value: number): void {
+    // eslint-disable-next-line unicorn/prefer-math-trunc
+    if (value >> 0 === value) {
+        if (value >= 0 && value <= 0xff) {
+            cursor.ensureCapacity(2);
+            const { length } = cursor;
+            cursor.view.setUint16(length, U8_MASK | value);
+            cursor.length = length + 2;
+        } else if (value < 0x80 && value >= -0x80) {
+            cursor.ensureCapacity(2);
+            const { length } = cursor;
+            cursor.view.setUint16(length, I8_MASK | (value & 0xff));
+            cursor.length = length + 2;
+        } else if (value < 0x8000 && value >= -0x8000) {
+            cursor.ensureCapacity(3);
+            const { length } = cursor;
+            cursor.data[length] = constants.INT16;
+            cursor.view.setInt16(length + 1, value);
+            cursor.length = length + 3;
+        } else {
+            // must be 32 bit
+            cursor.ensureCapacity(5);
+            const { length } = cursor;
+            cursor.data[length] = constants.INT32;
+            cursor.view.setInt32(length + 1, value);
+            cursor.length = length + 5;
+        }
+    } else if (Number.isNaN(value) || Math.fround(value) === value) {
+        // 如果不会损失精度，使用 32 位浮点
+        cursor.ensureCapacity(5);
+        const { length } = cursor;
+        cursor.data[length] = constants.FLOAT32;
+        cursor.view.setFloat32(length + 1, value);
+        cursor.length = length + 5;
+    } else {
+        cursor.ensureCapacity(9);
+        const { length } = cursor;
+        cursor.data[length] = constants.FLOAT64;
+        cursor.view.setFloat64(length + 1, value);
+        cursor.length = length + 9;
+    }
+    return;
+}
+
+/** TypedArray 类型 */
+export type TypedArrayType =
+    | constants.UINT8
+    | constants.INT8
+    | constants.INT16
+    | constants.INT32
+    | constants.INT64
+    | constants.FLOAT32
+    | constants.FLOAT64;
+const T_ARR_HEADER = (type: TypedArrayType): number =>
+    (constants.ARRAY << 24) | (constants.TYPE_MARKER << 16) | (type << 8) | constants.COUNT_MARKER;
+export const U8_ARR_HEADER = T_ARR_HEADER(constants.UINT8);
+export const I8_ARR_HEADER = T_ARR_HEADER(constants.INT8);
+export const I16_ARR_HEADER = T_ARR_HEADER(constants.INT16);
+export const I32_ARR_HEADER = T_ARR_HEADER(constants.INT32);
+export const I64_ARR_HEADER = T_ARR_HEADER(constants.INT64);
+export const F32_ARR_HEADER = T_ARR_HEADER(constants.FLOAT32);
+export const F64_ARR_HEADER = T_ARR_HEADER(constants.FLOAT64);
+
 /** 写入 TypedArray 前导，包括 marker 和长度 */
-export function writeTypedArrayHeader(cursor: EncodeCursor, value: ArrayBufferView): void {
+export function writeTypedArrayHeader(cursor: EncodeCursor, value: ArrayBufferView): TypedArrayType {
     // ARRAY(1) + TYPE_MARKER(1) + TYPE(1) + COUNT_MARKER(1) + COUNT(MIN2 MAX5) + DATA
     cursor.ensureCapacity(9);
-    cursor.data[cursor.length++] = constants.ARRAY;
-    cursor.data[cursor.length++] = constants.TYPE_MARKER;
+    let type: TypedArrayType;
+    const { length } = cursor;
     if (value instanceof Uint8Array) {
-        cursor.data[cursor.length++] = constants.UINT8;
+        cursor.view.setUint32(length, U8_ARR_HEADER);
+        type = constants.UINT8;
     } else if (value instanceof Float64Array) {
-        cursor.data[cursor.length++] = constants.FLOAT64;
+        cursor.view.setUint32(length, F64_ARR_HEADER);
+        type = constants.FLOAT64;
     } else if (value instanceof Int32Array) {
-        cursor.data[cursor.length++] = constants.INT32;
+        cursor.view.setUint32(length, I32_ARR_HEADER);
+        type = constants.INT32;
+    } else if (value instanceof BigInt64Array) {
+        cursor.view.setUint32(length, I64_ARR_HEADER);
+        type = constants.INT64;
+    } else if (value instanceof Float32Array) {
+        cursor.view.setUint32(length, F32_ARR_HEADER);
+        type = constants.FLOAT32;
     } else if (value instanceof Int8Array) {
-        cursor.data[cursor.length++] = constants.INT8;
+        cursor.view.setUint32(length, I8_ARR_HEADER);
+        type = constants.INT8;
     } else if (value instanceof Int16Array) {
-        cursor.data[cursor.length++] = constants.INT16;
-    } else if (value instanceof Float32Array) {
-        cursor.data[cursor.length++] = constants.FLOAT32;
-    } else if (value instanceof BigInt64Array) {
-        cursor.data[cursor.length++] = constants.INT64;
+        cursor.view.setUint32(length, I16_ARR_HEADER);
+        type = constants.INT16;
     } else {
         unsupportedView(value);
     }
-    cursor.data[cursor.length++] = constants.COUNT_MARKER;
+    cursor.length = length + 4;
     writeLength(cursor, value.length);
+    return type;
+}
+/** 写入 TypedArray */
+export function writeTypedArray(cursor: EncodeCursor, value: ArrayBufferView): void {
+    cursor.ensureCapacity(9 + value.byteLength);
+    const type = writeTypedArrayHeader(cursor, value);
+    writeTypedArrayData(cursor, type, value);
+}
+/** 写入 TypedArray 数据 */
+export function writeTypedArrayData(cursor: EncodeCursor, type: TypedArrayType, value: ArrayBufferView): void {
+    const { byteLength } = value;
+    cursor.ensureCapacity(byteLength);
+    let pointer = cursor.length;
+    cursor.length = pointer + byteLength;
+    if (type === constants.UINT8 || type === constants.INT8) {
+        // fast path for typed arrays with `BYTES_PER_ELEMENT` of 1
+        cursor.data.set(value as Uint8Array | Int8Array, pointer);
+        return;
+    }
+
+    const { view } = cursor;
+    if (type === constants.FLOAT64) {
+        const arrayLength = byteLength / 8;
+        for (let i = 0; i < arrayLength; i++) {
+            view.setFloat64(pointer, (value as Float64Array)[i]!);
+            pointer += 8;
+        }
+    } else if (type === constants.INT32) {
+        const arrayLength = byteLength / 4;
+        for (let i = 0; i < arrayLength; i++) {
+            view.setInt32(pointer, (value as Int32Array)[i]!);
+            pointer += 4;
+        }
+    } else if (type === constants.INT64) {
+        const arrayLength = byteLength / 8;
+        for (let i = 0; i < arrayLength; i++) {
+            view.setBigInt64(pointer, (value as BigInt64Array)[i]!);
+            pointer += 8;
+        }
+    } else if (type === constants.FLOAT32) {
+        const arrayLength = byteLength / 4;
+        for (let i = 0; i < arrayLength; i++) {
+            view.setFloat32(pointer, (value as Float32Array)[i]!);
+            pointer += 4;
+        }
+    } else {
+        (type) satisfies constants.INT16;
+        const arrayLength = byteLength / 2;
+        for (let i = 0; i < arrayLength; i++) {
+            view.setInt16(pointer, (value as Int16Array)[i]!);
+            pointer += 2;
+        }
+    }
 }

package/src/helper/string-decoder.ts

@@ -53,19 +53,19 @@ export function jsDecode(bytes: Uint8Array, begin: number, end: number): string
 }
 
 /** 解码 Ascii */
-function longStringInJS(buf: Uint8Array, begin: number, length: number): string | undefined {
-    const bytes = Array.from<number>({ length });
+export function longStringInJS(buf: Uint8Array, begin: number, length: number): string | undefined {
+    const bytes = [];
     for (let i = 0; i < length; i++) {
         const byte = buf[begin++]!;
-        if ((byte & 0x80) > 0) {
+        if (byte & 0x80) {
             return;
         }
-        bytes[i] = byte;
+        bytes.push(byte);
     }
     return fromCharCode(...bytes);
 }
 /** 解码 Ascii */
-function shortStringInJS(buf: Uint8Array, begin: number, length: number): string | undefined {
+export function shortStringInJS(buf: Uint8Array, begin: number, length: number): string | undefined {
     if (length < 4) {
         if (length < 2) {
             if (length === 0) return '';
@@ -198,8 +198,12 @@ export function decode(data: Uint8Array, begin: number, end: number): string {
         const result = shortStringInJS(data, begin, length);
         if (result != null) return result;
     }
-    // 只有小字符串有优化价值，见 benchmark-string.js
+    // 只有小字符串有优化价值
     if (length < TEXT_DECODER_THRESHOLD) {
+        // if (length < 32) {
+        //     const result = longStringInJS(data, begin, length);
+        //     if (result != null) return result;
+        // }
         // 为小字符串优化
         return jsDecode(data, begin, end);
     }
@@ -207,42 +211,9 @@ export function decode(data: Uint8Array, begin: number, end: number): string {
     return nativeDecode(data, begin, end);
 }
 
-const KEY_CACHE = Array.from<{ value: string; buffer: Uint8Array } | undefined>({ length: 4096 });
-
-/** 字符串解码，使用缓存 */
-export function decodeKey(data: Uint8Array, begin: number, end: number): string {
-    const length = end - begin;
-    const cacheKey =
-        ((length << 5) ^ (length > 1 ? data[begin]! & (data[begin + 1]! << 8) : length > 0 ? data[begin]! : 0)) & 0xfff;
-    let entry = KEY_CACHE[cacheKey];
-    if (entry != null && entry.buffer.byteLength === length) {
-        let i = 0;
-        for (; i < length; i++) {
-            if (entry.buffer[i] !== data[begin + i]) break;
-        }
-        if (i === length) return entry.value;
-    }
-
-    let str = length < 16 ? shortStringInJS(data, begin, length) : longStringInJS(data, begin, length);
-    if (str == null) {
-        // 只有小字符串有优化价值，见 benchmark-string.js
-        if (length < TEXT_DECODER_THRESHOLD) {
-            // 为小字符串优化
-            str = jsDecode(data, begin, end);
-        } else {
-            // 使用系统解码
-            str = nativeDecode(data, begin, end);
-        }
-    }
-    entry = { value: str, buffer: data.slice(begin, end) };
-    KEY_CACHE[cacheKey] = entry;
-    return str;
-}
-
 /** 重设环境 */
 export function resetEnv(): void {
     TEXT_DECODER = typeof TextDecoder == 'function' ? new TextDecoder('utf8', { ignoreBOM: true, fatal: false }) : null;
     TEXT_DECODER_THRESHOLD = TEXT_DECODER == null ? 0xffff_ffff : 16;
-    KEY_CACHE.fill(undefined);
 }
 resetEnv();

package/src/index.ts

@@ -1,15 +1,18 @@
 import { getEncoder } from './encoder.js';
 import { Decoder } from './decoder.js';
+import type { EncodeOptions } from './options.js';
+
 export { UnexpectedEofError as UnexpectedEof } from './helper/errors.js';
+export type { EncodeOptions };
 
 /** 编码为 UBJSON */
-export function encode(value: unknown): Uint8Array {
-    return getEncoder().encode(value);
+export function encode(value: unknown, options?: EncodeOptions): Uint8Array {
+    return getEncoder(options).encode(value);
 }
 
 /** 编码为 UBJSON */
-export function encodeMany(value: Iterable<unknown>): Uint8Array {
-    return getEncoder().encodeMany(value);
+export function encodeMany(value: Iterable<unknown>, options?: EncodeOptions): Uint8Array {
+    return getEncoder(options).encodeMany(value);
 }
 
 /** 解码 UBJSON */

package/src/options.ts

@@ -0,0 +1,5 @@
+/** 序列化选项 */
+export interface EncodeOptions {
+    /** 序列化对象时排序属性 */
+    sortObjectKeys?: boolean;
+}

package/src/rxjs/decoder.ts

@@ -1,69 +1,95 @@
 import { Observable, type OperatorFunction } from 'rxjs';
-import { StreamDecoderHelper, kEof, UnexpectedEof } from '../stream-helper/decoder.js';
+import { UnexpectedEof } from '../stream-helper/decoder.js';
 import { toUint8Array } from '../helper/utils.js';
+import { read } from '../helper/decode-ae.js';
 
-const DEFAULT_BUFFER_SIZE = 16 * 1024 * 1024; // 16 MiB
 const EMPTY_BUFFER = new Uint8Array(0);
+const EMPTY_VIEW = new DataView(EMPTY_BUFFER.buffer);
 
 /** 流式解码 UBJSON */
 export function decode(): OperatorFunction<BinaryData, unknown> {
     return (observable) => {
         return new Observable<unknown>((subscriber) => {
-            let chunkSize = DEFAULT_BUFFER_SIZE;
-            let buffer = new Uint8Array(chunkSize);
-            let begin = 0;
-            let end = 0;
+            const data = EMPTY_BUFFER;
+            const cursor = {
+                view: EMPTY_VIEW,
+                data,
+                capacity: 0,
+                size: 0,
+                offset: 0,
+            };
+            /** reader 返回的还需接收的字节数 */
+            let required = 1;
+            let reader = read(cursor);
             return observable.subscribe({
                 next(value) {
-                    const data = toUint8Array(value);
-                    if (buffer.length >= end + data.length) {
-                        buffer.set(data, end);
-                        end += data.length;
+                    const chunk = toUint8Array(value);
+                    const chunkSize = chunk.byteLength;
+                    if (cursor.capacity - cursor.size < chunkSize) {
+                        // 当前缓冲区不足，需要扩容
+                        const newSize = Math.max(
+                            // 不缩小缓冲区
+                            cursor.capacity,
+                            // 扩大缓冲区到足够容纳 2 倍当前数据
+                            chunkSize * 2 + cursor.size - cursor.offset,
+                        );
+                        if (newSize > cursor.capacity) {
+                            // 需要增大缓冲区
+                            const newData = new Uint8Array(newSize);
+                            newData.set(cursor.data.subarray(cursor.offset, cursor.size), 0);
+                            newData.set(chunk, cursor.size - cursor.offset);
+                            cursor.data = newData;
+                            cursor.view = new DataView(newData.buffer, newData.byteOffset, newData.byteLength);
+                            cursor.capacity = newSize;
+                        } else {
+                            // 无需增大缓冲区，直接移动数据
+                            cursor.data.copyWithin(0, cursor.offset, cursor.size);
+                            cursor.data.set(chunk, cursor.size - cursor.offset);
+                        }
+                        cursor.size = cursor.size - cursor.offset + chunkSize;
+                        cursor.offset = 0;
                     } else {
-                        chunkSize = Math.max(chunkSize, data.length * 2 + end - begin);
-                        const allocSize = Math.max(chunkSize, data.length + end - begin);
-                        const newBuffer =
-                            allocSize > buffer.byteLength
-                                ? new Uint8Array(Math.max(chunkSize, data.length + end - begin))
-                                : buffer;
-                        newBuffer.set(buffer.subarray(begin, end), 0);
-                        newBuffer.set(data, end - begin);
-                        buffer = newBuffer;
-                        end = end - begin + data.length;
-                        begin = 0;
+                        // 当前缓冲区足够，直接写入
+                        cursor.data.set(chunk, cursor.size);
+                        cursor.size += chunkSize;
                     }
-                    while (end - begin > 0) {
-                        try {
-                            const helper = new StreamDecoderHelper(buffer.slice(begin, end));
-                            const result = helper.decode();
-                            if (result !== undefined) {
-                                subscriber.next(result);
-                            }
-                            begin += helper.readLength;
-                        } catch (ex) {
-                            if (ex === kEof) {
-                                return;
+
+                    required -= chunkSize;
+                    // 未读够数据，继续等待
+                    if (required > 0) return;
+
+                    try {
+                        for (;;) {
+                            const result = reader.next();
+                            if (result.done) {
+                                // 读取完成，新建 reader 读取下一个值
+                                subscriber.next(result.value);
+                                reader = read(cursor);
+                                if (cursor.offset === cursor.size) {
+                                    break;
+                                }
                             } else {
-                                subscriber.error(ex as Error);
-                                buffer = EMPTY_BUFFER;
-                                return;
+                                required = result.value;
+                                break;
                             }
                         }
+                    } catch (ex) {
+                        subscriber.error(ex);
                     }
-                    // 完全消费了 Buffer 内容，重置 Buffer
-                    begin = end = 0;
                 },
                 error(err) {
                     subscriber.error(err);
-                    buffer = EMPTY_BUFFER;
+                    cursor.data = EMPTY_BUFFER;
+                    cursor.view = EMPTY_VIEW;
                 },
                 complete() {
-                    if (end - begin > 0) {
+                    if (cursor.size > cursor.offset) {
                         subscriber.error(new UnexpectedEof());
                     } else {
                         subscriber.complete();
                     }
-                    buffer = EMPTY_BUFFER;
+                    cursor.data = EMPTY_BUFFER;
+                    cursor.view = EMPTY_VIEW;
                 },
             });
         });

package/src/rxjs/encoder.ts

@@ -1,11 +1,12 @@
 import { Observable, type OperatorFunction } from 'rxjs';
 import { StreamEncoderHelper } from '../stream-helper/encoder.js';
+import type { EncodeOptions } from '../options.js';
 
 /** 流式编码 UBJSON */
-export function encode(): OperatorFunction<unknown, Uint8Array> {
+export function encode(options?: EncodeOptions): OperatorFunction<unknown, Uint8Array> {
     return (observable) => {
         return new Observable<Uint8Array>((subscriber) => {
-            const helper = new StreamEncoderHelper((chunk: Uint8Array): void => subscriber.next(chunk));
+            const helper = new StreamEncoderHelper(options, (chunk: Uint8Array): void => subscriber.next(chunk));
             const sub = observable.subscribe({
                 next(value) {
                     try {

package/src/rxjs/index.ts

@@ -1,3 +1,4 @@
 export { encode } from './encoder.js';
 export { decode } from './decoder.js';
 export { UnexpectedEofError as UnexpectedEof } from '../helper/errors.js';
+export type { EncodeOptions } from '../options.js';

package/src/stream/encoder.ts

@@ -1,14 +1,15 @@
 import { Transform, type TransformCallback } from 'node:stream';
 import { StreamEncoderHelper } from '../stream-helper/encoder.js';
+import type { EncodeOptions } from '../options.js';
 
 /** 流式编码 UBJSON */
 export class StreamEncoder extends Transform {
-    constructor() {
+    constructor(options?: EncodeOptions) {
         super({
             readableObjectMode: false,
             writableObjectMode: true,
         });
-        this.helper = new StreamEncoderHelper((binary) => this.push(binary));
+        this.helper = new StreamEncoderHelper(options, (binary) => this.push(binary));
     }
 
     private readonly helper;
@@ -24,7 +25,7 @@ export class StreamEncoder extends Transform {
     }
 
     /** @inheritdoc */
-    override _destroy(error: Error | null, callback: (error?: Error | null | undefined) => void): void {
+    override _destroy(error: Error | null, callback: (error?: Error | null) => void): void {
         this.helper.destroy();
         super._destroy(error, callback);
     }

package/src/stream/index.ts

@@ -1,22 +1,24 @@
 import { Readable, type Transform } from 'node:stream';
 import { StreamEncoder } from './encoder.js';
 import { StreamDecoder } from './decoder.js';
+import type { EncodeOptions } from '../options.js';
 
 export { UnexpectedEofError as UnexpectedEof } from '../helper/errors.js';
+export type { EncodeOptions };
 
 /** 编码为 UBJSON */
-export function encode(value: unknown): Readable {
+export function encode(value: unknown, options?: EncodeOptions): Readable {
     if (value == null) {
         return Readable.from([value === null ? 'Z' : 'N'], { objectMode: false });
     }
-    const encoder = new StreamEncoder();
+    const encoder = new StreamEncoder(options);
     encoder.write(value);
     encoder.end();
     return encoder;
 }
 /** 编码为 UBJSON */
-export function encodeMany(value: AsyncIterable<unknown>): Readable {
-    const encoder = new StreamEncoder();
+export function encodeMany(value: AsyncIterable<unknown>, options?: EncodeOptions): Readable {
+    const encoder = new StreamEncoder(options);
     void (async () => {
         try {
             for await (const v of value) {
@@ -32,8 +34,8 @@ export function encodeMany(value: AsyncIterable<unknown>): Readable {
 }
 
 /** 编码为 UBJSON */
-export function encoder(): Transform {
-    return new StreamEncoder();
+export function encoder(options?: EncodeOptions): Transform {
+    return new StreamEncoder(options);
 }
 
 /** 解码 UBJSON */