@cloudpss/ubjson 0.5.34 → 0.5.36

package/src/common/encoder.ts

@@ -1,10 +1,11 @@
 import { constants } from './constants.js';
-import { getStringByteLength, getEncodeInto } from './string-encoder.js';
+import { unsupportedType, unsupportedView } from './errors.js';
+import { stringByteLength, encodeInto } from './string-encoder.js';
+
+const LARGE_DATA_LENGTH = 65536;
 
 /** 编码至 ubjson */
 export abstract class EncoderBase {
-    protected readonly stringByteLength = getStringByteLength();
-    protected readonly encodeInto = getEncodeInto();
     /** 当前写指针位置 */
     protected length = 0;
     /** 数据 */
@@ -79,7 +80,9 @@ export abstract class EncoderBase {
                 if (value === null) {
                     this.ensureCapacity(1);
                     this.buffer[this.length++] = constants.NULL;
-                } else if (Array.isArray(value)) {
+                    return;
+                }
+                if (Array.isArray(value)) {
                     this.ensureCapacity(1);
                     this.buffer[this.length++] = constants.ARRAY;
                     const size = value.length;
@@ -95,7 +98,9 @@ export abstract class EncoderBase {
                     }
                     this.ensureCapacity(1);
                     this.buffer[this.length++] = constants.ARRAY_END;
-                } else if (!ArrayBuffer.isView(value)) {
+                    return;
+                }
+                if (!ArrayBuffer.isView(value)) {
                     const { toJSON } = value as Record<string, unknown>;
                     if (typeof toJSON == 'function') {
                         this.write(toJSON.call(value));
@@ -107,7 +112,7 @@ export abstract class EncoderBase {
                     const keys = Object.keys(value).sort();
                     const size = keys.length;
                     for (let index = 0; index < size; index++) {
-                        const key = keys[index];
+                        const key = keys[index]!;
                         const element = (value as Record<string, unknown>)[key];
                         if (element === undefined || typeof element == 'function') continue;
                         this.writeStringData(key);
@@ -115,6 +120,33 @@ export abstract class EncoderBase {
                     }
                     this.ensureCapacity(1);
                     this.buffer[this.length++] = constants.OBJECT_END;
+                    return;
+                }
+                if (value.byteLength > LARGE_DATA_LENGTH) {
+                    // ARRAY(1) + TYPE_MARKER(1) + TYPE(1) + COUNT_MARKER(1) + COUNT(5)
+                    this.ensureCapacity(9);
+                    this.buffer[this.length++] = constants.ARRAY;
+                    this.buffer[this.length++] = constants.TYPE_MARKER;
+                    if (value instanceof Uint8Array) {
+                        this.buffer[this.length++] = constants.UINT8;
+                    } else if (value instanceof Int8Array) {
+                        this.buffer[this.length++] = constants.INT8;
+                    } else if (value instanceof Int16Array) {
+                        this.buffer[this.length++] = constants.INT16;
+                    } else if (value instanceof Int32Array) {
+                        this.buffer[this.length++] = constants.INT32;
+                    } else if (value instanceof Float32Array) {
+                        this.buffer[this.length++] = constants.FLOAT32;
+                    } else if (value instanceof Float64Array) {
+                        this.buffer[this.length++] = constants.FLOAT64;
+                    } else if (value instanceof BigInt64Array) {
+                        this.buffer[this.length++] = constants.INT64;
+                    } else {
+                        unsupportedView(value);
+                    }
+                    this.buffer[this.length++] = constants.COUNT_MARKER;
+                    this.setLength(value.length);
+                    this.writeLargeTypedArrayData(value);
                 } else {
                     // ARRAY(1) + TYPE_MARKER(1) + TYPE(1) + COUNT_MARKER(1) + COUNT(MAX5) + DATA
                     this.ensureCapacity(9 + value.byteLength);
@@ -139,7 +171,7 @@ export abstract class EncoderBase {
                         this.buffer[this.length++] = constants.COUNT_MARKER;
                         this.setLength(arrayLength);
                         for (let i = 0; i < arrayLength; i++) {
-                            this.view.setInt16(this.length, value[i]);
+                            this.view.setInt16(this.length, value[i]!);
                             this.length += elementSize;
                         }
                     } else if (value instanceof Int32Array) {
@@ -147,7 +179,7 @@ export abstract class EncoderBase {
                         this.buffer[this.length++] = constants.COUNT_MARKER;
                         this.setLength(arrayLength);
                         for (let i = 0; i < arrayLength; i++) {
-                            this.view.setInt32(this.length, value[i]);
+                            this.view.setInt32(this.length, value[i]!);
                             this.length += elementSize;
                         }
                     } else if (value instanceof Float32Array) {
@@ -155,7 +187,7 @@ export abstract class EncoderBase {
                         this.buffer[this.length++] = constants.COUNT_MARKER;
                         this.setLength(arrayLength);
                         for (let i = 0; i < arrayLength; i++) {
-                            this.view.setFloat32(this.length, value[i]);
+                            this.view.setFloat32(this.length, value[i]!);
                             this.length += elementSize;
                         }
                     } else if (value instanceof Float64Array) {
@@ -163,7 +195,7 @@ export abstract class EncoderBase {
                         this.buffer[this.length++] = constants.COUNT_MARKER;
                         this.setLength(arrayLength);
                         for (let i = 0; i < arrayLength; i++) {
-                            this.view.setFloat64(this.length, value[i]);
+                            this.view.setFloat64(this.length, value[i]!);
                             this.length += elementSize;
                         }
                     } else if (value instanceof BigInt64Array) {
@@ -171,11 +203,11 @@ export abstract class EncoderBase {
                         this.buffer[this.length++] = constants.COUNT_MARKER;
                         this.setLength(arrayLength);
                         for (let i = 0; i < arrayLength; i++) {
-                            this.view.setBigInt64(this.length, value[i]);
+                            this.view.setBigInt64(this.length, value[i]!);
                             this.length += elementSize;
                         }
                     } else {
-                        throw new TypeError(`Unsupported typed array type ${Object.prototype.toString.call(value)}`);
+                        unsupportedView(value);
                     }
                 }
                 return;
@@ -200,18 +232,18 @@ export abstract class EncoderBase {
                 }
                 return;
             default:
-                throw new Error(`Unsupported type ${Object.prototype.toString.call(value)}`);
+                unsupportedType(value);
         }
     }
 
     /** writeStringData */
     private writeStringData(value: string): void {
         const strLength = value.length;
-        const maxUsage =
-            strLength < 65536
-                ? // 对于短字符串，直接计算最大使用空间
-                  strLength * 3
-                : this.stringByteLength(value);
+        if (strLength > LARGE_DATA_LENGTH) {
+            return this.writeLargeStringData(value);
+        }
+        // 对于短字符串，直接计算最大使用空间
+        const maxUsage = strLength * 3;
         // 一次性分配 setLength 和 encodeInto 的空间，避免无法回溯
         // 额外分配 3 字节，避免 encodeInto 无法写入最后一个字符
         this.ensureCapacity(maxUsage + 5 + 3);
@@ -219,36 +251,7 @@ export abstract class EncoderBase {
         // 预估头部大小
         const headerSize = strLength < 128 ? 2 : strLength < 32768 ? 3 : 5;
         const headerPos = this.length;
-        let bufLength;
-        // 优化小字符串
-        if (strLength < 0x40 || !this.encodeInto) {
-            let c1, c2;
-            let strPosition = headerPos + headerSize;
-            const target = this.buffer;
-            for (let i = 0; i < strLength; i++) {
-                c1 = value.charCodeAt(i);
-                if (c1 < 0x80) {
-                    target[strPosition++] = c1;
-                } else if (c1 < 0x800) {
-                    target[strPosition++] = (c1 >> 6) | 0xc0;
-                    target[strPosition++] = (c1 & 0x3f) | 0x80;
-                } else if ((c1 & 0xfc00) === 0xd800 && ((c2 = value.charCodeAt(i + 1)) & 0xfc00) === 0xdc00) {
-                    c1 = 0x1_0000 + ((c1 & 0x03ff) << 10) + (c2 & 0x03ff);
-                    i++;
-                    target[strPosition++] = (c1 >> 18) | 0xf0;
-                    target[strPosition++] = ((c1 >> 12) & 0x3f) | 0x80;
-                    target[strPosition++] = ((c1 >> 6) & 0x3f) | 0x80;
-                    target[strPosition++] = (c1 & 0x3f) | 0x80;
-                } else {
-                    target[strPosition++] = (c1 >> 12) | 0xe0;
-                    target[strPosition++] = ((c1 >> 6) & 0x3f) | 0x80;
-                    target[strPosition++] = (c1 & 0x3f) | 0x80;
-                }
-            }
-            bufLength = strPosition - headerPos - headerSize;
-        } else {
-            bufLength = this.encodeInto(value, this.buffer, headerPos + headerSize);
-        }
+        const bufLength = encodeInto(value, this.buffer, this.length + headerSize);
         if (bufLength < 128) {
             this.buffer[this.length++] = constants.INT8;
             this.buffer[this.length++] = bufLength;
@@ -270,6 +273,61 @@ export abstract class EncoderBase {
         this.length += bufLength;
     }
 
+    /** 写入大字符串 */
+    protected writeLargeStringData(value: string): void {
+        const binLen = stringByteLength(value);
+        this.ensureCapacity(5);
+        this.buffer[this.length++] = constants.INT32;
+        this.view.setInt32(this.length, binLen);
+        this.length += 4;
+        this.ensureCapacity(binLen);
+        encodeInto(value, this.buffer, this.length);
+        this.length += binLen;
+    }
+
+    /** 写入数组 */
+    protected writeLargeTypedArrayData(value: ArrayBufferView): void {
+        this.ensureCapacity(value.byteLength);
+        if (value instanceof Uint8Array || value instanceof Int8Array) {
+            // fast path for typed arrays with `BYTES_PER_ELEMENT` of 1
+            this.buffer.set(value, this.length);
+            this.length += value.byteLength;
+            return;
+        }
+
+        const arrayLength = (value as Int16Array | Int32Array | BigInt64Array | Float32Array | Float64Array).length;
+        const elementSize = (value as Int16Array | Int32Array | BigInt64Array | Float32Array | Float64Array)
+            .BYTES_PER_ELEMENT;
+        if (value instanceof Int16Array) {
+            for (let i = 0; i < arrayLength; i++) {
+                this.view.setInt16(this.length, value[i]!);
+                this.length += elementSize;
+            }
+        } else if (value instanceof Int32Array) {
+            for (let i = 0; i < arrayLength; i++) {
+                this.view.setInt32(this.length, value[i]!);
+                this.length += elementSize;
+            }
+        } else if (value instanceof Float32Array) {
+            for (let i = 0; i < arrayLength; i++) {
+                this.view.setFloat32(this.length, value[i]!);
+                this.length += elementSize;
+            }
+        } else if (value instanceof Float64Array) {
+            for (let i = 0; i < arrayLength; i++) {
+                this.view.setFloat64(this.length, value[i]!);
+                this.length += elementSize;
+            }
+        } else if (value instanceof BigInt64Array) {
+            for (let i = 0; i < arrayLength; i++) {
+                this.view.setBigInt64(this.length, value[i]!);
+                this.length += elementSize;
+            }
+        } else {
+            unsupportedView(value);
+        }
+    }
+
     /**
      * 写入整形数字，选取合适的大小，需提前分配空间
      */

package/src/common/errors.ts

@@ -0,0 +1,14 @@
+/** unsupported view */
+export function unsupportedView(view: ArrayBufferView): never {
+    const type = Object.prototype.toString.call(view).slice(8, -1);
+    throw new Error(`Unsupported array buffer view of type ${type}`);
+}
+
+/** unsupported type */
+export function unsupportedType(value: unknown): never {
+    if (value && typeof value == 'string') {
+        throw new Error(`Unsupported type ${value}`);
+    }
+    const type = Object.prototype.toString.call(value).slice(8, -1);
+    throw new Error(`Unsupported type ${type}`);
+}

package/src/common/string-decoder.ts

@@ -1,40 +1,33 @@
-/* c8 ignore next 2: TextDecoder always present, fallback tested */
-export const textDecoder =
-    typeof TextDecoder == 'function' ? new TextDecoder('utf8', { ignoreBOM: true, fatal: false }) : null;
-
-/* c8 ignore next: TextDecoder always present, fallback tested */
-export const TEXT_ENCODER_THRESHOLD = textDecoder == null ? 0xffff_ffff : 200;
-
 const CHUNK_SIZE = 0x1000;
 const REPLACE_CHAR = 0xfffd;
 
 const fromCharCode = String.fromCharCode;
 
 /** 解码 */
-export function decodeJs(bytes: Uint8Array, begin: number, end: number): string {
+export function jsDecode(bytes: Uint8Array, begin: number, end: number): string {
     let offset = begin;
 
     const units: number[] = [];
     let result = '';
     while (offset < end) {
-        const byte1 = bytes[offset++];
+        const byte1 = bytes[offset++]!;
         if ((byte1 & 0x80) === 0) {
             // 1 byte
             units.push(byte1);
         } else if ((byte1 & 0xe0) === 0xc0) {
             // 2 bytes
-            const byte2 = bytes[offset++] & 0x3f;
+            const byte2 = bytes[offset++]! & 0x3f;
             units.push(((byte1 & 0x1f) << 6) | byte2);
         } else if ((byte1 & 0xf0) === 0xe0) {
             // 3 bytes
-            const byte2 = bytes[offset++] & 0x3f;
-            const byte3 = bytes[offset++] & 0x3f;
+            const byte2 = bytes[offset++]! & 0x3f;
+            const byte3 = bytes[offset++]! & 0x3f;
             units.push(((byte1 & 0x1f) << 12) | (byte2 << 6) | byte3);
         } else if ((byte1 & 0xf8) === 0xf0) {
             // 4 bytes
-            const byte2 = bytes[offset++] & 0x3f;
-            const byte3 = bytes[offset++] & 0x3f;
-            const byte4 = bytes[offset++] & 0x3f;
+            const byte2 = bytes[offset++]! & 0x3f;
+            const byte3 = bytes[offset++]! & 0x3f;
+            const byte4 = bytes[offset++]! & 0x3f;
             let unit = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0c) | (byte3 << 0x06) | byte4;
             if (unit > 0xffff) {
                 unit -= 0x1_0000;
@@ -63,7 +56,7 @@ export function decodeJs(bytes: Uint8Array, begin: number, end: number): string
 function longStringInJS(buf: Uint8Array, begin: number, length: number): string | undefined {
     const bytes = Array.from<number>({ length });
     for (let i = 0; i < length; i++) {
-        const byte = buf[begin++];
+        const byte = buf[begin++]!;
         if ((byte & 0x80) > 0) {
             return;
         }
@@ -77,95 +70,95 @@ function shortStringInJS(buf: Uint8Array, begin: number, length: number): string
         if (length < 2) {
             if (length === 0) return '';
             else {
-                const a = buf[begin++];
+                const a = buf[begin++]!;
                 if ((a & 0x80) > 1) {
                     return;
                 }
                 return fromCharCode(a);
             }
         } else {
-            const a = buf[begin++];
-            const b = buf[begin++];
+            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 c = buf[begin++]!;
             if ((c & 0x80) > 0) {
                 return;
             }
             return fromCharCode(a, b, c);
         }
     } else {
-        const a = buf[begin++];
-        const b = buf[begin++];
-        const c = buf[begin++];
-        const d = buf[begin++];
+        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);
             else {
-                const e = buf[begin++];
+                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++];
+            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++];
+            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++];
+            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++];
+                    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++];
+                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++];
+                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++];
+                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++];
+                        const m = buf[begin++]!;
                         if ((m & 0x80) > 0) {
                             begin -= 13;
                             return;
@@ -173,13 +166,13 @@ function shortStringInJS(buf: Uint8Array, begin: number, length: number): string
                         return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m);
                     }
                 } else {
-                    const m = buf[begin++];
-                    const n = buf[begin++];
+                    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++];
+                    const o = buf[begin++]!;
                     if ((o & 0x80) > 0) {
                         return;
                     }
@@ -190,6 +183,14 @@ function shortStringInJS(buf: Uint8Array, begin: number, length: number): string
     }
 }
 
+let TEXT_DECODER: TextDecoder | null;
+let TEXT_DECODER_THRESHOLD: number;
+
+/** 解码 */
+export function nativeDecode(data: Uint8Array, begin: number, end: number): string {
+    return TEXT_DECODER!.decode(data.subarray(begin, end));
+}
+
 /** 字符串解码，无缓存 */
 export function decode(data: Uint8Array, begin: number, end: number): string {
     const length = end - begin;
@@ -198,22 +199,22 @@ export function decode(data: Uint8Array, begin: number, end: number): string {
         if (result != null) return result;
     }
     // 只有小字符串有优化价值，见 benchmark-string.js
-    if (length < TEXT_ENCODER_THRESHOLD) {
+    if (length < TEXT_DECODER_THRESHOLD) {
         // 为小字符串优化
-        return decodeJs(data, begin, end);
+        return jsDecode(data, begin, end);
     }
     // 使用系统解码
-    return textDecoder!.decode(data.subarray(begin, end));
+    return nativeDecode(data, begin, end);
 }
 
-const keyCache = Array.from<{ value: string; buffer: Uint8Array } | undefined>({ length: 4096 });
+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 = keyCache[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++) {
@@ -225,15 +226,23 @@ export function decodeKey(data: Uint8Array, begin: number, end: number): string
     let str = length < 16 ? shortStringInJS(data, begin, length) : longStringInJS(data, begin, length);
     if (str == null) {
         // 只有小字符串有优化价值，见 benchmark-string.js
-        if (length < TEXT_ENCODER_THRESHOLD) {
+        if (length < TEXT_DECODER_THRESHOLD) {
             // 为小字符串优化
-            str = decodeJs(data, begin, end);
+            str = jsDecode(data, begin, end);
         } else {
             // 使用系统解码
-            str = textDecoder!.decode(data.subarray(begin, end));
+            str = nativeDecode(data, begin, end);
         }
     }
     entry = { value: str, buffer: data.slice(begin, end) };
-    keyCache[cacheKey] = entry;
+    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();