@cloudpss/ubjson 0.5.36 → 0.5.38

package/src/common/decoder.ts

@@ -1,356 +0,0 @@
-import { UnexpectedEof, toUint8Array } from '../utils.js';
-import { constants } from './constants.js';
-import { unsupportedType } from './errors.js';
-import { decode, decodeKey } from './string-decoder.js';
-
-const fromEntries = Object.fromEntries;
-
-/** decoder options */
-export interface DecoderOptions {
-    /** 对 {@link Uint8Array} 使用 subarray */
-    noAllocBuffer?: boolean;
-}
-
-/** decoder */
-export class DecoderBase {
-    protected readonly view: DataView;
-    protected readonly data: Uint8Array;
-    /** 当前读指针位置 */
-    protected offset = 0;
-
-    /** 选项 */
-    protected readonly noAllocBuffer;
-    constructor(data: BinaryData, options?: DecoderOptions) {
-        this.data = toUint8Array(data);
-        this.view = new DataView(this.data.buffer, this.data.byteOffset, this.data.byteLength);
-        if (options) {
-            this.noAllocBuffer = !!options.noAllocBuffer;
-        } else {
-            this.noAllocBuffer = false;
-        }
-    }
-
-    /** EOF */
-    protected eof(): never {
-        throw new UnexpectedEof();
-    }
-
-    /** 解码 */
-    decode(): unknown {
-        let marker = constants.NO_OP;
-        do {
-            marker = this.data[this.offset++]!;
-        } while (marker === constants.NO_OP); // 跳过 noop
-        if (marker === undefined) return undefined;
-        return this.readData(marker);
-    }
-
-    /** 读取数据 */
-    private read(): unknown {
-        const marker = this.readMarker();
-        return this.readData(marker);
-    }
-
-    /** 读取 marker，跳过 noop */
-    private readMarker(): number {
-        let marker = constants.NO_OP;
-        do {
-            marker = this.data[this.offset++]!;
-        } while (marker === constants.NO_OP);
-        if (marker === undefined) this.eof();
-        return marker;
-    }
-
-    /** 读取数据 */
-    private readData(marker: number): unknown {
-        // 按照出现频率排序
-        switch (marker) {
-            case constants.STRING: {
-                const length = this.readIntLength();
-                const begin = this.offset;
-                const end = begin + length;
-                this.offset = end;
-                const data = this.data;
-                if (end > data.length) this.eof();
-                return decode(data, begin, end);
-            }
-            case constants.OBJECT: {
-                const markers = this.readOptimizedFormatMarkers();
-                if (markers == null) {
-                    // 直到 '}'
-                    const object: Array<[string, unknown]> = [];
-                    while (this.readMarker() !== constants.OBJECT_END) {
-                        this.offset--;
-                        object.push([this.readKey(), this.read()]);
-                    }
-                    return fromEntries(object);
-                }
-
-                const { count, type } = markers;
-                const object: Array<[string, unknown]> = [];
-                object.length = count;
-                for (let i = 0; i < count; i++) {
-                    const key = this.readKey();
-                    const value = this.readData(type ?? this.readMarker());
-                    object[i] = [key, value];
-                }
-                return fromEntries(object);
-            }
-            case constants.ARRAY: {
-                const markers = this.readOptimizedFormatMarkers();
-                if (markers == null) {
-                    const array = [];
-                    // 直到 ']'
-                    while (this.readMarker() !== constants.ARRAY_END) {
-                        this.offset--;
-                        array.push(this.read());
-                    }
-                    return array;
-                }
-
-                const { count, type } = markers;
-                switch (type) {
-                    case constants.UINT8:
-                        try {
-                            const buf = new Uint8Array(this.data.buffer, this.data.byteOffset + this.offset, count);
-                            this.offset += count;
-                            return this.noAllocBuffer ? buf : buf.slice();
-                        } catch {
-                            return this.eof();
-                        }
-                    case constants.INT8:
-                        try {
-                            const buf = new Int8Array(
-                                this.data.buffer,
-                                this.data.byteOffset + this.offset,
-                                count,
-                            ).slice();
-                            this.offset += count;
-                            return buf;
-                        } catch {
-                            return this.eof();
-                        }
-                    case constants.INT16: {
-                        const result = new Int16Array(count);
-                        for (let i = 0; i < count; i++) {
-                            result[i] = this.readInt16Data();
-                        }
-                        return result;
-                    }
-                    case constants.INT32: {
-                        const result = new Int32Array(count);
-                        for (let i = 0; i < count; i++) {
-                            result[i] = this.readInt32Data();
-                        }
-                        return result;
-                    }
-                    case constants.FLOAT32: {
-                        const result = new Float32Array(count);
-                        for (let i = 0; i < count; i++) {
-                            result[i] = this.readFloat32Data();
-                        }
-                        return result;
-                    }
-                    case constants.FLOAT64: {
-                        const result = new Float64Array(count);
-                        for (let i = 0; i < count; i++) {
-                            result[i] = this.readFloat64Data();
-                        }
-                        return result;
-                    }
-                    case constants.INT64: {
-                        const result = new BigInt64Array(count);
-                        for (let i = 0; i < count; i++) {
-                            result[i] = this.readInt64Data();
-                        }
-                        return result;
-                    }
-                    case constants.NULL:
-                        return Array.from({ length: count }).fill(null);
-                    case constants.TRUE:
-                        return Array.from({ length: count }).fill(true);
-                    case constants.FALSE:
-                        return Array.from({ length: count }).fill(false);
-                    default:
-                        break;
-                }
-                const array: unknown[] = [];
-                array.length = count;
-                for (let i = 0; i < count; i++) {
-                    array[i] = type == null ? this.read() : this.readData(type);
-                }
-                return array;
-            }
-            case constants.FLOAT64:
-                return this.readFloat64Data();
-            case constants.UINT8:
-                return this.readUint8Data();
-            case constants.INT16:
-                return this.readInt16Data();
-            case constants.FLOAT32:
-                return this.readFloat32Data();
-            case constants.CHAR:
-                return String.fromCharCode(this.readUint8Data());
-            case constants.INT32:
-                return this.readInt32Data();
-            case constants.INT8:
-                return this.readInt8Data();
-            case constants.NULL:
-                return null;
-            case constants.TRUE:
-                return true;
-            case constants.FALSE:
-                return false;
-            case constants.INT64: {
-                const n = this.readInt64Data();
-                if (n < Number.MIN_SAFE_INTEGER || n > Number.MAX_SAFE_INTEGER) {
-                    return n;
-                }
-                return Number(n);
-            }
-            case constants.HIGH_PRECISION_NUMBER: {
-                const length = this.readIntLength();
-                try {
-                    const _buffer = new Uint8Array(this.data.buffer, this.offset, length).slice();
-                    this.offset += length;
-                    // return buffer;
-                } catch {
-                    return this.eof();
-                }
-                unsupportedType('high precision number');
-            }
-        }
-        throw new Error(`Unexpected marker '${String.fromCharCode(marker)}'(${marker})`);
-    }
-
-    /** 读取一个大于 0 的整数 */
-    private readIntLength(): number {
-        const marker = this.readMarker();
-        let length;
-        switch (marker) {
-            case constants.INT8:
-                length = this.readInt8Data();
-                break;
-            case constants.UINT8:
-                length = this.readUint8Data();
-                break;
-            case constants.INT16:
-                length = this.readInt16Data();
-                break;
-            case constants.INT32:
-                length = this.readInt32Data();
-                break;
-            case constants.INT64: {
-                const l = this.readInt64Data();
-                if (l < 0 || l > Number.MAX_SAFE_INTEGER) {
-                    throw new Error('Invalid length');
-                }
-                length = Number(l);
-                break;
-            }
-            default:
-                throw new Error(`Unexpected marker '${String.fromCharCode(marker)}'(${marker}) for int length`);
-        }
-        if (length < 0) {
-            throw new Error('Invalid length');
-        }
-        return length;
-    }
-
-    /** readKey */
-    private readKey(): string {
-        const length = this.readIntLength();
-        const begin = this.offset;
-        const end = begin + length;
-        this.offset = end;
-        const data = this.data;
-        if (end > data.length) this.eof();
-        return decodeKey(data, begin, end);
-    }
-    /** readInt8Data */
-    private readInt8Data(): number {
-        try {
-            return this.view.getInt8(this.offset++);
-        } catch {
-            this.eof();
-        }
-    }
-    /** readUint8Data */
-    private readUint8Data(): number {
-        const num = this.data[this.offset++];
-        if (num === undefined) this.eof();
-        return num;
-    }
-    /** readInt16Data */
-    private readInt16Data(): number {
-        try {
-            const result = this.view.getInt16(this.offset);
-            this.offset += 2;
-            return result;
-        } catch {
-            this.eof();
-        }
-    }
-    /** readInt32Data */
-    private readInt32Data(): number {
-        try {
-            const result = this.view.getInt32(this.offset);
-            this.offset += 4;
-            return result;
-        } catch {
-            this.eof();
-        }
-    }
-    /** readInt64Data */
-    private readInt64Data(): bigint {
-        try {
-            const result = this.view.getBigInt64(this.offset);
-            this.offset += 8;
-            return result;
-        } catch {
-            this.eof();
-        }
-    }
-    /** readFloat32Data */
-    private readFloat32Data(): number {
-        try {
-            const result = this.view.getFloat32(this.offset);
-            this.offset += 4;
-            return result;
-        } catch {
-            this.eof();
-        }
-    }
-    /** readFloat64Data */
-    private readFloat64Data(): number {
-        try {
-            const result = this.view.getFloat64(this.offset);
-            this.offset += 8;
-            return result;
-        } catch {
-            this.eof();
-        }
-    }
-
-    /** 读取 Optimized Format 数据 */
-    private readOptimizedFormatMarkers(): { type?: number; count: number } | undefined {
-        let type;
-        let count;
-        switch (this.readMarker()) {
-            case constants.TYPE_MARKER:
-                type = this.readMarker();
-                if (this.readMarker() !== constants.COUNT_MARKER) {
-                    throw new Error('Expected count marker');
-                }
-            /* fall through */
-            case constants.COUNT_MARKER:
-                count = this.readIntLength();
-                break;
-            default:
-                // 不是 '$' 或 '#'，回溯
-                this.offset--;
-                return undefined;
-        }
-        return { type, count };
-    }
-}