@cloudpss/ubjson 0.5.41 → 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,
     };
 }
 
@@ -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;
                 }

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,9 +1,9 @@
 import { getEncoder } from './encoder.js';
 import { Decoder } from './decoder.js';
-import type { EncodeOptions } from './options.js';
+import type { EncodeOptions, DecodeOptions } from './options.js';
 
 export { UnexpectedEofError as UnexpectedEof } from './helper/errors.js';
-export type { EncodeOptions };
+export type { EncodeOptions, DecodeOptions };
 
 /** 编码为 UBJSON */
 export function encode(value: unknown, options?: EncodeOptions): Uint8Array {
@@ -16,14 +16,14 @@ export function encodeMany(value: Iterable<unknown>, options?: EncodeOptions): U
 }
 
 /** 解码 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

@@ -1,5 +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,15 +1,16 @@
 import { Observable, type OperatorFunction } from 'rxjs';
-import { 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 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) => {
+export function decode(options?: DecodeOptions): OperatorFunction<BinaryData, unknown> {
+    return (observable) =>
+        new Observable<unknown>((subscriber) => {
             const data = EMPTY_BUFFER;
             const cursor = {
                 view: EMPTY_VIEW,
@@ -17,6 +18,7 @@ export function decode(): OperatorFunction<BinaryData, unknown> {
                 capacity: 0,
                 size: 0,
                 offset: 0,
+                options,
             };
             /** reader 返回的还需接收的字节数 */
             let required = 1;
@@ -84,7 +86,7 @@ export function decode(): OperatorFunction<BinaryData, unknown> {
                 },
                 complete() {
                     if (cursor.size > cursor.offset) {
-                        subscriber.error(new UnexpectedEof());
+                        subscriber.error(new UnexpectedEofError());
                     } else {
                         subscriber.complete();
                     }
@@ -93,5 +95,4 @@ export function decode(): OperatorFunction<BinaryData, unknown> {
                 },
             });
         });
-    };
 }

package/src/rxjs/index.ts

@@ -1,4 +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';
+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/index.ts

@@ -1,10 +1,10 @@
 import { Readable, type Transform } from 'node:stream';
 import { StreamEncoder } from './encoder.js';
 import { StreamDecoder } from './decoder.js';
-import type { EncodeOptions } from '../options.js';
+import type { EncodeOptions, DecodeOptions } from '../options.js';
 
 export { UnexpectedEofError as UnexpectedEof } from '../helper/errors.js';
-export type { EncodeOptions };
+export type { EncodeOptions, DecodeOptions };
 
 /** 编码为 UBJSON */
 export function encode(value: unknown, options?: EncodeOptions): Readable {
@@ -39,9 +39,9 @@ export function encoder(options?: EncodeOptions): Transform {
 }
 
 /** 解码 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);
@@ -50,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);
 }

package/tests/.utils.js

@@ -34,5 +34,13 @@ export function toArray(...args) {
  * @returns {Uint8Array} Uint8Array
  */
 export function toBuffer(...args) {
-    return Uint8Array.from(args, (x) => (typeof x == 'number' ? x : x.charCodeAt(0)));
+    const data = [];
+    for (const x of args) {
+        if (typeof x == 'number') {
+            data.push(x);
+        } else {
+            data.push(...Buffer.from(x, 'ascii'));
+        }
+    }
+    return Uint8Array.from(data);
 }

package/tests/decode.js

@@ -504,3 +504,55 @@ test('decode (eof at marker)', () => {
 test('decode (eof at key)', () => {
     expect(() => decode(toBuffer('{', 'i', 2, 'a'))).toThrow(UnexpectedEof);
 });
+
+describe('proto poisoning attack', () => {
+    it('should remove __proto__ key', () => {
+        const obj = /** @type {Record<string, unknown>} */ (
+            decode(toBuffer('{', 'i', 9, '__proto__', '{', 'i', 1, 'a', 'S', 'i', 3, 'abc', '}', '}'))
+        );
+        expect(Object.hasOwn(obj, '__proto__')).toBe(false);
+        expect(obj['__proto__']).toBe(Object.prototype);
+    });
+    it('should allow __proto__ key', () => {
+        const obj = /** @type {Record<string, unknown>} */ (
+            decode(toBuffer('{', 'i', 9, '__proto__', '{', 'i', 1, 'a', 'S', 'i', 3, 'abc', '}', '}'), {
+                protoAction: 'allow',
+            })
+        );
+        expect(Object.hasOwn(obj, '__proto__')).toBe(true);
+        expect(obj['__proto__']).toEqual({ a: 'abc' });
+    });
+    it('should throw on __proto__ key', () => {
+        expect(() =>
+            decode(toBuffer('{', 'i', 9, '__proto__', '{', 'i', 1, 'a', 'S', 'i', 3, 'abc', '}', '}'), {
+                protoAction: 'error',
+            }),
+        ).toThrow(`Unexpected "__proto__"`);
+    });
+});
+
+describe('constructor poisoning attack', () => {
+    it('should remove constructor key', () => {
+        const obj = /** @type {Record<string, unknown>} */ (
+            decode(toBuffer('{', 'i', 11, 'constructor', '{', 'i', 1, 'a', 'S', 'i', 3, 'abc', '}', '}'), {
+                constructorAction: 'remove',
+            })
+        );
+        expect(Object.hasOwn(obj, 'constructor')).toBe(false);
+        expect(obj.constructor).toBe(Object);
+    });
+    it('should allow constructor key', () => {
+        const obj = /** @type {Record<string, unknown>} */ (
+            decode(toBuffer('{', 'i', 11, 'constructor', '{', 'i', 1, 'a', 'S', 'i', 3, 'abc', '}', '}'))
+        );
+        expect(Object.hasOwn(obj, 'constructor')).toBe(true);
+        expect(obj.constructor).toEqual({ a: 'abc' });
+    });
+    it('should throw on constructor key', () => {
+        expect(() =>
+            decode(toBuffer('{', 'i', 11, 'constructor', '{', 'i', 1, 'a', 'S', 'i', 3, 'abc', '}', '}'), {
+                constructorAction: 'error',
+            }),
+        ).toThrow(`Unexpected "constructor"`);
+    });
+});

package/tests/e2e/.data.js

@@ -465,6 +465,17 @@ EXPECTED['object with undefined values'] = { a: 1, c: { d: 2, f: null } };
 INPUTS['array with undefined values'] = [1, undefined, 2, undefined, 3];
 EXPECTED['array with undefined values'] = [1, null, 2, null, 3];
 
+INPUTS['inject __proto__'] = JSON.parse('{"__proto__": {"a":1}}');
+EXPECTED['inject __proto__'] = {};
+
 INPUTS['invalid __proto__'] = JSON.parse('{"__proto__":"xxx"}');
+EXPECTED['invalid __proto__'] = {};
 
 INPUTS['null __proto__'] = JSON.parse('{"__proto__":null}');
+EXPECTED['null __proto__'] = {};
+
+INPUTS['inject constructor'] = { constructor: { prototype: { a: 1 } } };
+INPUTS['invalid constructor prototype'] = { constructor: { prototype: 'xxx' } };
+INPUTS['null constructor prototype'] = { constructor: { prototype: null } };
+INPUTS['invalid constructor'] = { constructor: 'xxx' };
+INPUTS['null constructor'] = { constructor: null };

package/dist/stream-helper/decoder.d.ts

@@ -1,12 +0,0 @@
-import { DecoderBase } from '../base/decoder.js';
-/** 未结束的流 */
-export declare const kEof: unique symbol;
-/** 流式解码 UBJSON */
-export declare class StreamDecoderHelper extends DecoderBase {
-    /** @inheritdoc */
-    protected eof(): never;
-    /** 读取的字节数 */
-    get readLength(): number;
-}
-export { UnexpectedEofError as UnexpectedEof } from '../helper/errors.js';
-//# sourceMappingURL=decoder.d.ts.map

package/dist/stream-helper/decoder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"decoder.d.ts","sourceRoot":"","sources":["../../src/stream-helper/decoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD,YAAY;AACZ,eAAO,MAAM,IAAI,eAAgB,CAAC;AAElC,kBAAkB;AAClB,qBAAa,mBAAoB,SAAQ,WAAW;IAChD,kBAAkB;cACC,GAAG,IAAI,KAAK;IAM/B,aAAa;IACb,IAAI,UAAU,IAAI,MAAM,CAEvB;CACJ;AAED,OAAO,EAAE,kBAAkB,IAAI,aAAa,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/stream-helper/decoder.js

@@ -1,18 +0,0 @@
-import { DecoderBase } from '../base/decoder.js';
-/** 未结束的流 */
-export const kEof = Symbol('EOF');
-/** 流式解码 UBJSON */
-export class StreamDecoderHelper extends DecoderBase {
-    /** @inheritdoc */
-    eof() {
-        // 性能优化，避免 new Error 的开销
-        // eslint-disable-next-line @typescript-eslint/only-throw-error
-        throw kEof;
-    }
-    /** 读取的字节数 */
-    get readLength() {
-        return this.offset;
-    }
-}
-export { UnexpectedEofError as UnexpectedEof } from '../helper/errors.js';
-//# sourceMappingURL=decoder.js.map

package/dist/stream-helper/decoder.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"decoder.js","sourceRoot":"","sources":["../../src/stream-helper/decoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD,YAAY;AACZ,MAAM,CAAC,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;AAElC,kBAAkB;AAClB,MAAM,OAAO,mBAAoB,SAAQ,WAAW;IAChD,kBAAkB;IACC,GAAG;QAClB,wBAAwB;QACxB,+DAA+D;QAC/D,MAAM,IAAI,CAAC;IACf,CAAC;IAED,aAAa;IACb,IAAI,UAAU;QACV,OAAO,IAAI,CAAC,MAAM,CAAC;IACvB,CAAC;CACJ;AAED,OAAO,EAAE,kBAAkB,IAAI,aAAa,EAAE,MAAM,qBAAqB,CAAC"}

package/src/stream-helper/decoder.ts

@@ -1,21 +0,0 @@
-import { DecoderBase } from '../base/decoder.js';
-
-/** 未结束的流 */
-export const kEof = Symbol('EOF');
-
-/** 流式解码 UBJSON */
-export class StreamDecoderHelper extends DecoderBase {
-    /** @inheritdoc */
-    protected override eof(): never {
-        // 性能优化，避免 new Error 的开销
-        // eslint-disable-next-line @typescript-eslint/only-throw-error
-        throw kEof;
-    }
-
-    /** 读取的字节数 */
-    get readLength(): number {
-        return this.offset;
-    }
-}
-
-export { UnexpectedEofError as UnexpectedEof } from '../helper/errors.js';