@cloudpss/ubjson 0.5.40 → 0.5.42

package/src/helper/decode.ts

@@ -1,3 +1,4 @@
+import type { DecodeOptions } from '../options.js';
 import { constants } from './constants.js';
 import { UnexpectedEofError, unsupportedType } from './errors.js';
 import { decode } from './string-decoder.js';
@@ -15,10 +16,12 @@ export interface DecodeCursor {
     offset: number;
     /** 读取到末尾时调用 */
     eof(): never;
+    /** 选项 */
+    readonly options: DecodeOptions | undefined;
 }
 
 /** 创建数据包装 */
-export function DecodeCursor(data: BinaryData): DecodeCursor {
+export function DecodeCursor(data: BinaryData, options?: DecodeOptions): DecodeCursor {
     const d = toUint8Array(data);
     const v = new DataView(d.buffer, d.byteOffset, d.byteLength);
     return {
@@ -28,6 +31,7 @@ export function DecodeCursor(data: BinaryData): DecodeCursor {
         eof() {
             throw new UnexpectedEofError();
         },
+        options,
     };
 }
 
@@ -81,7 +85,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');
@@ -160,6 +164,35 @@ export function read(cursor: DecodeCursor): unknown {
     return readData(cursor, marker);
 }
 
+/** 处理 `__proto__` */
+export function protoAction(cursor: Pick<DecodeCursor, 'options'>, obj: Record<string, unknown>, value: unknown): void {
+    if (cursor.options?.protoAction === 'error') {
+        throw new Error('Unexpected "__proto__"');
+    } else if (cursor.options?.protoAction === 'allow') {
+        defineProperty(obj, '__proto__', {
+            value,
+            enumerable: true,
+            configurable: true,
+            writable: true,
+        });
+    }
+}
+
+/** 处理 `constructor` */
+export function constructorAction(
+    cursor: Pick<DecodeCursor, 'options'>,
+    obj: Record<string, unknown>,
+    value: unknown,
+): void {
+    if (cursor.options?.constructorAction === 'error') {
+        throw new Error('Unexpected "constructor"');
+    } else if (cursor.options?.constructorAction === 'remove') {
+        return;
+    }
+    // eslint-disable-next-line @typescript-eslint/dot-notation
+    obj['constructor'] = value;
+}
+
 /** 读取优化对象数据 */
 function readObjectOptimizedData(cursor: DecodeCursor, marker: OptimizedFormatMarkers): unknown {
     const { count, type } = marker;
@@ -168,7 +201,12 @@ function readObjectOptimizedData(cursor: DecodeCursor, marker: OptimizedFormatMa
         const key = readKey(cursor);
         const value = readData(cursor, type ?? readMarker(cursor));
         if (key === '__proto__') {
-            defineProperty(object, key, { value, enumerable: true, configurable: true, writable: true });
+            protoAction(cursor, object, value);
+            continue;
+        }
+        if (key === 'constructor') {
+            constructorAction(cursor, object, value);
+            continue;
         }
         object[key] = value;
     }
@@ -198,7 +236,12 @@ export function readData(cursor: DecodeCursor, marker: number): unknown {
                     const key = readKey(cursor);
                     const value = read(cursor);
                     if (key === '__proto__') {
-                        defineProperty(object, key, { value, enumerable: true, configurable: true, writable: true });
+                        protoAction(cursor, object, value);
+                        continue;
+                    }
+                    if (key === 'constructor') {
+                        constructorAction(cursor, object, value);
+                        continue;
                     }
                     object[key] = value;
                 }
@@ -210,10 +253,11 @@ export function readData(cursor: DecodeCursor, marker: number): unknown {
             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;
             }

package/src/helper/string-decoder.ts

@@ -69,118 +69,103 @@ export function shortStringInJS(buf: Uint8Array, begin: number, length: number):
     if (length < 4) {
         if (length < 2) {
             if (length === 0) return '';
-            else {
-                const a = buf[begin++]!;
-                if ((a & 0x80) > 1) {
-                    return;
-                }
-                return fromCharCode(a);
-            }
-        } else {
-            const a = buf[begin++]!;
-            const b = buf[begin++]!;
-            if ((a & 0x80) > 0 || (b & 0x80) > 0) {
+            const a = buf[begin]!;
+            if ((a & 0x80) > 0) {
                 return;
             }
-            if (length < 3) return fromCharCode(a, b);
-            const c = buf[begin++]!;
-            if ((c & 0x80) > 0) {
-                return;
-            }
-            return fromCharCode(a, b, c);
+            return fromCharCode(a);
         }
-    } else {
         const a = buf[begin++]!;
         const b = buf[begin++]!;
+        if ((a & 0x80) > 0 || (b & 0x80) > 0) {
+            return;
+        }
+        if (length < 3) return fromCharCode(a, b);
         const c = buf[begin++]!;
-        const d = buf[begin++]!;
-        if ((a & 0x80) > 0 || (b & 0x80) > 0 || (c & 0x80) > 0 || (d & 0x80) > 0) {
+        if ((c & 0x80) > 0) {
             return;
         }
-        if (length < 6) {
-            if (length === 4) return fromCharCode(a, b, c, d);
-            else {
-                const e = buf[begin++]!;
-                if ((e & 0x80) > 0) {
-                    return;
-                }
-                return fromCharCode(a, b, c, d, e);
-            }
-        } else if (length < 8) {
-            const e = buf[begin++]!;
-            const f = buf[begin++]!;
-            if ((e & 0x80) > 0 || (f & 0x80) > 0) {
-                return;
-            }
-            if (length < 7) return fromCharCode(a, b, c, d, e, f);
-            const g = buf[begin++]!;
-            if ((g & 0x80) > 0) {
-                return;
-            }
-            return fromCharCode(a, b, c, d, e, f, g);
-        } else {
-            const e = buf[begin++]!;
-            const f = buf[begin++]!;
-            const g = buf[begin++]!;
-            const h = buf[begin++]!;
-            if ((e & 0x80) > 0 || (f & 0x80) > 0 || (g & 0x80) > 0 || (h & 0x80) > 0) {
-                return;
-            }
-            if (length < 10) {
-                if (length === 8) return fromCharCode(a, b, c, d, e, f, g, h);
-                else {
-                    const i = buf[begin++]!;
-                    if ((i & 0x80) > 0) {
-                        return;
-                    }
-                    return fromCharCode(a, b, c, d, e, f, g, h, i);
-                }
-            } else if (length < 12) {
-                const i = buf[begin++]!;
-                const j = buf[begin++]!;
-                if ((i & 0x80) > 0 || (j & 0x80) > 0) {
-                    return;
-                }
-                if (length < 11) return fromCharCode(a, b, c, d, e, f, g, h, i, j);
-                const k = buf[begin++]!;
-                if ((k & 0x80) > 0) {
-                    return;
-                }
-                return fromCharCode(a, b, c, d, e, f, g, h, i, j, k);
-            } else {
-                const i = buf[begin++]!;
-                const j = buf[begin++]!;
-                const k = buf[begin++]!;
-                const l = buf[begin++]!;
-                if ((i & 0x80) > 0 || (j & 0x80) > 0 || (k & 0x80) > 0 || (l & 0x80) > 0) {
-                    return;
-                }
-                if (length < 14) {
-                    if (length === 12) return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l);
-                    else {
-                        const m = buf[begin++]!;
-                        if ((m & 0x80) > 0) {
-                            begin -= 13;
-                            return;
-                        }
-                        return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m);
-                    }
-                } else {
-                    const m = buf[begin++]!;
-                    const n = buf[begin++]!;
-                    if ((m & 0x80) > 0 || (n & 0x80) > 0) {
-                        return;
-                    }
-                    if (length < 15) return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n);
-                    const o = buf[begin++]!;
-                    if ((o & 0x80) > 0) {
-                        return;
-                    }
-                    return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o);
-                }
-            }
+        return fromCharCode(a, b, c);
+    }
+    const a = buf[begin++]!;
+    const b = buf[begin++]!;
+    const c = buf[begin++]!;
+    const d = buf[begin++]!;
+    if ((a & 0x80) > 0 || (b & 0x80) > 0 || (c & 0x80) > 0 || (d & 0x80) > 0) {
+        return;
+    }
+    if (length < 6) {
+        if (length === 4) return fromCharCode(a, b, c, d);
+        const e = buf[begin++]!;
+        if ((e & 0x80) > 0) {
+            return;
         }
+        return fromCharCode(a, b, c, d, e);
+    }
+    const e = buf[begin++]!;
+    const f = buf[begin++]!;
+    if ((e & 0x80) > 0 || (f & 0x80) > 0) {
+        return;
+    }
+    if (length < 8) {
+        if (length < 7) return fromCharCode(a, b, c, d, e, f);
+        const g = buf[begin++]!;
+        if ((g & 0x80) > 0) {
+            return;
+        }
+        return fromCharCode(a, b, c, d, e, f, g);
+    }
+    const g = buf[begin++]!;
+    const h = buf[begin++]!;
+    if ((g & 0x80) > 0 || (h & 0x80) > 0) {
+        return;
+    }
+    if (length < 10) {
+        if (length === 8) return fromCharCode(a, b, c, d, e, f, g, h);
+        const i = buf[begin++]!;
+        if ((i & 0x80) > 0) {
+            return;
+        }
+        return fromCharCode(a, b, c, d, e, f, g, h, i);
+    }
+    const i = buf[begin++]!;
+    const j = buf[begin++]!;
+    if ((i & 0x80) > 0 || (j & 0x80) > 0) {
+        return;
+    }
+    if (length < 12) {
+        if (length < 11) return fromCharCode(a, b, c, d, e, f, g, h, i, j);
+        const k = buf[begin++]!;
+        if ((k & 0x80) > 0) {
+            return;
+        }
+        return fromCharCode(a, b, c, d, e, f, g, h, i, j, k);
+    }
+    const k = buf[begin++]!;
+    const l = buf[begin++]!;
+    if ((k & 0x80) > 0 || (l & 0x80) > 0) {
+        return;
+    }
+    if (length < 14) {
+        if (length === 12) return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l);
+        const m = buf[begin++]!;
+        if ((m & 0x80) > 0) {
+            begin -= 13;
+            return;
+        }
+        return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m);
+    }
+    const m = buf[begin++]!;
+    const n = buf[begin++]!;
+    if ((m & 0x80) > 0 || (n & 0x80) > 0) {
+        return;
+    }
+    if (length < 15) return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n);
+    const o = buf[begin++]!;
+    if ((o & 0x80) > 0) {
+        return;
     }
+    return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o);
 }
 
 let TEXT_DECODER: TextDecoder | null;

package/src/index.ts

@@ -1,26 +1,29 @@
 import { getEncoder } from './encoder.js';
 import { Decoder } from './decoder.js';
+import type { EncodeOptions, DecodeOptions } from './options.js';
+
 export { UnexpectedEofError as UnexpectedEof } from './helper/errors.js';
+export type { EncodeOptions, DecodeOptions };
 
 /** 编码为 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 */
-export function decode(value: BinaryData): unknown {
-    const decoder = new Decoder(value);
+export function decode(value: BinaryData, options?: DecodeOptions): unknown {
+    const decoder = new Decoder(value, options);
     return decoder.decode();
 }
 
 /** 解码 UBJSON */
-export function* decodeMany(value: BinaryData): Iterable<unknown> {
-    const decoder = new Decoder(value);
+export function* decodeMany(value: BinaryData, options?: DecodeOptions): Iterable<unknown> {
+    const decoder = new Decoder(value, options);
     while (!decoder.ended) {
         yield decoder.decode();
     }

package/src/options.ts

@@ -0,0 +1,22 @@
+/** 序列化选项 */
+export interface EncodeOptions {
+    /**
+     * 序列化对象时排序属性
+     * @default false
+     */
+    sortObjectKeys?: boolean;
+}
+
+/** 反序列化选项 */
+export interface DecodeOptions {
+    /**
+     * 解析对象时对 `__proto__` 属性的处理方式
+     * @default 'remove'
+     */
+    protoAction?: 'error' | 'allow' | 'remove';
+    /**
+     * 解析对象时对 `constructor` 属性的处理方式
+     * @default 'allow'
+     */
+    constructorAction?: 'error' | 'allow' | 'remove';
+}

package/src/rxjs/decoder.ts

@@ -1,71 +1,98 @@
 import { Observable, type OperatorFunction } from 'rxjs';
-import { StreamDecoderHelper, kEof, UnexpectedEof } from '../stream-helper/decoder.js';
 import { toUint8Array } from '../helper/utils.js';
+import { read } from '../helper/decode-ae.js';
+import type { DecodeOptions } from '../options.js';
+import { UnexpectedEofError } from '../helper/errors.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;
+export function decode(options?: DecodeOptions): OperatorFunction<BinaryData, unknown> {
+    return (observable) =>
+        new Observable<unknown>((subscriber) => {
+            const data = EMPTY_BUFFER;
+            const cursor = {
+                view: EMPTY_VIEW,
+                data,
+                capacity: 0,
+                size: 0,
+                offset: 0,
+                options,
+            };
+            /** 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) {
-                        subscriber.error(new UnexpectedEof());
+                    if (cursor.size > cursor.offset) {
+                        subscriber.error(new UnexpectedEofError());
                     } 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, DecodeOptions } from '../options.js';

package/src/stream/decoder.ts

@@ -1,16 +1,17 @@
 import { Transform, type TransformCallback } from 'node:stream';
 import { Subject } from 'rxjs';
 import { decode } from '../rxjs/decoder.js';
+import type { DecodeOptions } from '../options.js';
 
 /** 流式解码 UBJSON */
 export class StreamDecoder extends Transform {
-    constructor() {
+    constructor(options?: DecodeOptions) {
         super({
             readableObjectMode: true,
             writableObjectMode: false,
         });
         this.buffer = new Subject<BinaryData>();
-        this.buffer.pipe(decode()).subscribe({
+        this.buffer.pipe(decode(options)).subscribe({
             next: (value) => {
                 // null is not allowed in a stream
                 if (value == null) return;

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, DecodeOptions } from '../options.js';
 
 export { UnexpectedEofError as UnexpectedEof } from '../helper/errors.js';
+export type { EncodeOptions, DecodeOptions };
 
 /** 编码为 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,14 +34,14 @@ 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 */
-export async function decode(stream: NodeJS.ReadableStream): Promise<unknown> {
+export async function decode(stream: NodeJS.ReadableStream, options?: DecodeOptions): Promise<unknown> {
     return new Promise((resolve, reject) => {
-        const decoder = new StreamDecoder();
+        const decoder = new StreamDecoder(options);
         decoder.on('error', reject);
         decoder.on('end', resolve);
         decoder.on('data', resolve);
@@ -48,12 +50,12 @@ export async function decode(stream: NodeJS.ReadableStream): Promise<unknown> {
 }
 
 /** 解码 UBJSON */
-export function decodeMany(stream: NodeJS.ReadableStream): AsyncIterable<unknown> {
-    const decoder = new StreamDecoder();
+export function decodeMany(stream: NodeJS.ReadableStream, options?: DecodeOptions): AsyncIterable<unknown> {
+    const decoder = new StreamDecoder(options);
     return stream.pipe(decoder);
 }
 
 /** 解码 UBJSON */
-export function decoder(): Transform {
-    return new StreamDecoder();
+export function decoder(options?: DecodeOptions): Transform {
+    return new StreamDecoder(options);
 }