@bare-ts/lib 0.3.0 → 0.5.0

package/dist/codec/primitive.js

@@ -1,144 +1,174 @@
-// src/codec/primitive.ts
-import { assert } from "../util/assert.js";
-import { BareError } from "../core/index.js";
+"use strict";
+import { BareError } from "../core/bare-error.js";
+import { check, reserve } from "../core/byte-cursor.js";
+import { assert, DEV } from "../util/assert.js";
 import {
   INT_SAFE_MAX_BYTE_COUNT,
   NON_CANONICAL_REPRESENTATION,
   TOO_LARGE_NUMBER,
   UINT_MAX_BYTE_COUNT,
-  UINT_SAFE_MAX_BYTE_COUNT
+  UINT_SAFE32_MAX_BYTE_COUNT
 } from "../util/constants.js";
 import {
+  isI8,
   isI16,
   isI32,
   isI64,
-  isI8,
-  isSafeU64,
+  isU8,
   isU16,
   isU32,
   isU64,
-  isU8
+  isU64Safe
 } from "../util/validator.js";
-function readBool(bc) {
+export function readBool(bc) {
   const val = readU8(bc);
   if (val > 1) {
     bc.offset--;
     throw new BareError(bc.offset, "a bool must be equal to 0 or 1");
   }
-  return val !== 0;
+  return val > 0;
 }
-function writeBool(bc, x) {
+export function writeBool(bc, x) {
   writeU8(bc, x ? 1 : 0);
 }
-function readF32(bc) {
-  bc.check(4);
+export function readF32(bc) {
+  check(bc, 4);
   const result = bc.view.getFloat32(bc.offset, true);
   bc.offset += 4;
   return result;
 }
-function writeF32(bc, x) {
-  bc.reserve(4);
+export function writeF32(bc, x) {
+  reserve(bc, 4);
   bc.view.setFloat32(bc.offset, x, true);
-  assert(Number.isNaN(x) || Math.abs(bc.view.getFloat32(bc.offset, true) - x) <= Number.EPSILON, TOO_LARGE_NUMBER);
+  if (DEV) {
+    assert(
+      Number.isNaN(x) || Math.abs(bc.view.getFloat32(bc.offset, true) - x) <= Number.EPSILON,
+      TOO_LARGE_NUMBER
+    );
+  }
   bc.offset += 4;
 }
-function readF64(bc) {
-  bc.check(8);
+export function readF64(bc) {
+  check(bc, 8);
   const result = bc.view.getFloat64(bc.offset, true);
   bc.offset += 8;
   return result;
 }
-function writeF64(bc, x) {
-  bc.reserve(8);
+export function writeF64(bc, x) {
+  reserve(bc, 8);
   bc.view.setFloat64(bc.offset, x, true);
   bc.offset += 8;
 }
-function readI8(bc) {
-  bc.check(1);
+export function readI8(bc) {
+  check(bc, 1);
   return bc.view.getInt8(bc.offset++);
 }
-function writeI8(bc, x) {
-  assert(isI8(x), TOO_LARGE_NUMBER);
-  bc.reserve(1);
+export function writeI8(bc, x) {
+  if (DEV) {
+    assert(isI8(x), TOO_LARGE_NUMBER);
+  }
+  reserve(bc, 1);
   bc.view.setInt8(bc.offset++, x);
 }
-function readI16(bc) {
-  bc.check(2);
+export function readI16(bc) {
+  check(bc, 2);
   const result = bc.view.getInt16(bc.offset, true);
   bc.offset += 2;
   return result;
 }
-function writeI16(bc, x) {
-  assert(isI16(x), TOO_LARGE_NUMBER);
-  bc.reserve(2);
+export function writeI16(bc, x) {
+  if (DEV) {
+    assert(isI16(x), TOO_LARGE_NUMBER);
+  }
+  reserve(bc, 2);
   bc.view.setInt16(bc.offset, x, true);
   bc.offset += 2;
 }
-function readI32(bc) {
-  bc.check(4);
+export function readI32(bc) {
+  check(bc, 4);
   const result = bc.view.getInt32(bc.offset, true);
   bc.offset += 4;
   return result;
 }
-function writeI32(bc, x) {
-  assert(isI32(x), TOO_LARGE_NUMBER);
-  bc.reserve(4);
+export function writeI32(bc, x) {
+  if (DEV) {
+    assert(isI32(x), TOO_LARGE_NUMBER);
+  }
+  reserve(bc, 4);
   bc.view.setInt32(bc.offset, x, true);
   bc.offset += 4;
 }
-function readI64(bc) {
-  bc.check(8);
+export function readI64(bc) {
+  check(bc, 8);
   const result = bc.view.getBigInt64(bc.offset, true);
   bc.offset += 8;
   return result;
 }
-function writeI64(bc, x) {
-  assert(isI64(x), TOO_LARGE_NUMBER);
-  bc.reserve(8);
+export function writeI64(bc, x) {
+  if (DEV) {
+    assert(isI64(x), TOO_LARGE_NUMBER);
+  }
+  reserve(bc, 8);
   bc.view.setBigInt64(bc.offset, x, true);
   bc.offset += 8;
 }
-function readI64Safe(bc) {
-  const result = readU32(bc) + readI32(bc) * 4294967296;
+export function readI64Safe(bc) {
+  const result = readU32(bc) + readI32(bc) * /* 2**32 */
+  4294967296;
   if (!Number.isSafeInteger(result)) {
     bc.offset -= 8;
     throw new BareError(bc.offset, TOO_LARGE_NUMBER);
   }
   return result;
 }
-function writeI64Safe(bc, x) {
-  assert(Number.isSafeInteger(x), TOO_LARGE_NUMBER);
-  const lowest32 = x >>> 0;
+export function writeI64Safe(bc, x) {
+  if (DEV) {
+    assert(Number.isSafeInteger(x), TOO_LARGE_NUMBER);
+  }
+  let lowest32 = x >>> 0;
   writeU32(bc, lowest32);
-  let highest32 = x / 4294967296 | 0;
+  let highest32 = x / /* 2**32 */
+  4294967296 | 0;
   if (x < 0) {
-    highest32 = ~Math.abs(highest32) >>> 0;
+    highest32 = ~(Math.abs(highest32) & /* 2**21-1 */
+    2097151) >>> 0;
     if (lowest32 === 0) {
-      highest32++;
+      if (highest32 === 2097151) {
+        lowest32 = 1;
+      } else {
+        highest32++;
+      }
     }
   }
   writeU32(bc, highest32);
 }
-function readInt(bc) {
+export function readInt(bc) {
   const zigZag = readUint(bc);
   return zigZag >> BigInt(1) ^ -(zigZag & BigInt(1));
 }
-function writeInt(bc, x) {
-  assert(isI64(x), TOO_LARGE_NUMBER);
-  const zigZag = x >> BigInt(63) ^ x << BigInt(1);
-  writeUint(bc, zigZag);
+export function writeInt(bc, x) {
+  const truncated = BigInt.asIntN(64, x);
+  if (DEV) {
+    assert(truncated === x, TOO_LARGE_NUMBER);
+  }
+  const zigZag = truncated >> BigInt(63) ^ truncated << BigInt(1);
+  writeTruncatedUint(bc, zigZag);
 }
-function readIntSafe(bc) {
+export function readIntSafe(bc) {
   const firstByte = readU8(bc);
   let result = (firstByte & 127) >> 1;
   if (firstByte >= 128) {
-    let shiftMul = 64;
+    let shiftMul = (
+      /* 2**6 */
+      64
+    );
     let byteCount = 1;
     let byte;
     do {
       byte = readU8(bc);
       result += (byte & 127) * shiftMul;
-      shiftMul *= 128;
+      shiftMul *= /* 2**7 */
+      128;
       byteCount++;
     } while (byte >= 128 && byteCount < INT_SAFE_MAX_BYTE_COUNT);
     if (byte === 0) {
@@ -156,80 +186,102 @@ function readIntSafe(bc) {
   }
   return result;
 }
-function writeIntSafe(bc, x) {
-  assert(Number.isSafeInteger(x), TOO_LARGE_NUMBER);
+export function writeIntSafe(bc, x) {
   const sign = x < 0 ? 1 : 0;
-  if (x < 0) {
-    x = -(x + 1);
-  }
-  const firstByte = (x & 63) << 1 | sign;
-  x = Math.floor(x / 64);
-  if (x > 0) {
-    writeU8(bc, 128 | firstByte);
-    writeUintSafe(bc, x);
+  let zigZag = x < 0 ? -(x + 1) : x;
+  let first7Bits = (zigZag & 63) << 1 | sign;
+  zigZag = Math.floor(zigZag / /* 2**6 */
+  64);
+  if (zigZag > 0) {
+    if (!Number.isSafeInteger(x)) {
+      if (DEV) {
+        assert(false, TOO_LARGE_NUMBER);
+      }
+      const low = zigZag & 32767;
+      const high = (zigZag / 32768 >>> 0) * 32768;
+      if (first7Bits === 127 && low === 32767 && high === 4294967295) {
+        first7Bits &= ~2;
+      }
+      zigZag = high + low;
+    }
+    writeU8(bc, 128 | first7Bits);
+    writeUintSafe(bc, zigZag);
   } else {
-    writeU8(bc, firstByte);
+    writeU8(bc, first7Bits);
   }
 }
-function readU8(bc) {
-  bc.check(1);
+export function readU8(bc) {
+  check(bc, 1);
   return bc.bytes[bc.offset++];
 }
-function writeU8(bc, x) {
-  assert(isU8(x), TOO_LARGE_NUMBER);
-  bc.reserve(1);
+export function writeU8(bc, x) {
+  if (DEV) {
+    assert(isU8(x), TOO_LARGE_NUMBER);
+  }
+  reserve(bc, 1);
   bc.bytes[bc.offset++] = x;
 }
-function readU16(bc) {
-  bc.check(2);
+export function readU16(bc) {
+  check(bc, 2);
   const result = bc.view.getUint16(bc.offset, true);
   bc.offset += 2;
   return result;
 }
-function writeU16(bc, x) {
-  assert(isU16(x), TOO_LARGE_NUMBER);
-  bc.reserve(2);
+export function writeU16(bc, x) {
+  if (DEV) {
+    assert(isU16(x), TOO_LARGE_NUMBER);
+  }
+  reserve(bc, 2);
   bc.view.setUint16(bc.offset, x, true);
   bc.offset += 2;
 }
-function readU32(bc) {
-  bc.check(4);
+export function readU32(bc) {
+  check(bc, 4);
   const result = bc.view.getUint32(bc.offset, true);
   bc.offset += 4;
   return result;
 }
-function writeU32(bc, x) {
-  assert(isU32(x), TOO_LARGE_NUMBER);
-  bc.reserve(4);
+export function writeU32(bc, x) {
+  if (DEV) {
+    assert(isU32(x), TOO_LARGE_NUMBER);
+  }
+  reserve(bc, 4);
   bc.view.setUint32(bc.offset, x, true);
   bc.offset += 4;
 }
-function readU64(bc) {
-  bc.check(8);
+export function readU64(bc) {
+  check(bc, 8);
   const result = bc.view.getBigUint64(bc.offset, true);
   bc.offset += 8;
   return result;
 }
-function writeU64(bc, x) {
-  assert(isU64(x), TOO_LARGE_NUMBER);
-  bc.reserve(8);
+export function writeU64(bc, x) {
+  if (DEV) {
+    assert(isU64(x), TOO_LARGE_NUMBER);
+  }
+  reserve(bc, 8);
   bc.view.setBigUint64(bc.offset, x, true);
   bc.offset += 8;
 }
-function readU64Safe(bc) {
-  const result = readU32(bc) + readU32(bc) * 4294967296;
-  if (!isSafeU64(result)) {
+export function readU64Safe(bc) {
+  const result = readU32(bc) + readU32(bc) * /* 2**32 */
+  4294967296;
+  if (!isU64Safe(result)) {
     bc.offset -= 8;
     throw new BareError(bc.offset, TOO_LARGE_NUMBER);
   }
   return result;
 }
-function writeU64Safe(bc, x) {
-  assert(isSafeU64(x), TOO_LARGE_NUMBER);
+export function writeU64Safe(bc, x) {
+  if (DEV) {
+    assert(isU64Safe(x), TOO_LARGE_NUMBER);
+  }
   writeU32(bc, x >>> 0);
-  writeU32(bc, x / 4294967296 >>> 0);
+  writeU32(bc, x / /* 2**32 */
+  4294967296 & /* 2**21-1 */
+  2097151);
 }
-function readUint(bc) {
+export function readUint(bc) {
   let low = readU8(bc);
   if (low >= 128) {
     low &= 127;
@@ -239,7 +291,8 @@ function readUint(bc) {
     do {
       byte = readU8(bc);
       low += (byte & 127) * shiftMul;
-      shiftMul *= 128;
+      shiftMul *= /* 2**7 */
+      128;
       byteCount++;
     } while (byte >= 128 && byteCount < 7);
     let height = 0;
@@ -247,7 +300,8 @@ function readUint(bc) {
     while (byte >= 128 && byteCount < UINT_MAX_BYTE_COUNT) {
       byte = readU8(bc);
       height += (byte & 127) * shiftMul;
-      shiftMul *= 128;
+      shiftMul *= /* 2**7 */
+      128;
       byteCount++;
     }
     if (byte === 0 || byteCount === UINT_MAX_BYTE_COUNT && byte > 1) {
@@ -258,14 +312,21 @@ function readUint(bc) {
   }
   return BigInt(low);
 }
-function writeUint(bc, x) {
-  assert(isU64(x), TOO_LARGE_NUMBER);
+export function writeUint(bc, x) {
+  const truncated = BigInt.asUintN(64, x);
+  if (DEV) {
+    assert(truncated === x, TOO_LARGE_NUMBER);
+  }
+  writeTruncatedUint(bc, truncated);
+}
+function writeTruncatedUint(bc, x) {
   let tmp = Number(BigInt.asUintN(7 * 7, x));
   let rest = Number(x >> BigInt(7 * 7));
   let byteCount = 0;
-  while (tmp >= 128 || rest !== 0) {
+  while (tmp >= 128 || rest > 0) {
     writeU8(bc, 128 | tmp & 127);
-    tmp = Math.floor(tmp / 128);
+    tmp = Math.floor(tmp / /* 2**7 */
+    128);
     byteCount++;
     if (byteCount === 7) {
       tmp = rest;
@@ -274,72 +335,89 @@ function writeUint(bc, x) {
   }
   writeU8(bc, tmp);
 }
-function readUintSafe(bc) {
+export function readUintSafe32(bc) {
   let result = readU8(bc);
   if (result >= 128) {
     result &= 127;
-    let shiftMul = 128;
+    let shift = 7;
     let byteCount = 1;
     let byte;
     do {
       byte = readU8(bc);
-      result += (byte & 127) * shiftMul;
-      shiftMul *= 128;
+      result += (byte & 127) << shift >>> 0;
+      shift += 7;
       byteCount++;
-    } while (byte >= 128 && byteCount < UINT_SAFE_MAX_BYTE_COUNT);
+    } while (byte >= 128 && byteCount < UINT_SAFE32_MAX_BYTE_COUNT);
     if (byte === 0) {
       bc.offset -= byteCount - 1;
-      throw new BareError(bc.offset - byteCount + 1, NON_CANONICAL_REPRESENTATION);
+      throw new BareError(
+        bc.offset - byteCount + 1,
+        NON_CANONICAL_REPRESENTATION
+      );
     }
-    if (byteCount === UINT_SAFE_MAX_BYTE_COUNT && byte > 15) {
+    if (byteCount === UINT_SAFE32_MAX_BYTE_COUNT && byte > 15) {
       bc.offset -= byteCount - 1;
       throw new BareError(bc.offset, TOO_LARGE_NUMBER);
     }
   }
   return result;
 }
-function writeUintSafe(bc, x) {
-  assert(isSafeU64(x), TOO_LARGE_NUMBER);
-  while (x >= 128) {
+export function writeUintSafe32(bc, x) {
+  if (DEV) {
+    assert(isU32(x), TOO_LARGE_NUMBER);
+  }
+  let zigZag = x >>> 0;
+  while (zigZag >= 128) {
     writeU8(bc, 128 | x & 127);
-    x = Math.floor(x / 128);
+    zigZag >>>= 7;
   }
-  writeU8(bc, x);
-}
-export {
-  readBool,
-  readF32,
-  readF64,
-  readI16,
-  readI32,
-  readI64,
-  readI64Safe,
-  readI8,
-  readInt,
-  readIntSafe,
-  readU16,
-  readU32,
-  readU64,
-  readU64Safe,
-  readU8,
-  readUint,
-  readUintSafe,
-  writeBool,
-  writeF32,
-  writeF64,
-  writeI16,
-  writeI32,
-  writeI64,
-  writeI64Safe,
-  writeI8,
-  writeInt,
-  writeIntSafe,
-  writeU16,
-  writeU32,
-  writeU64,
-  writeU64Safe,
-  writeU8,
-  writeUint,
-  writeUintSafe
-};
-//# sourceMappingURL=primitive.js.map
+  writeU8(bc, zigZag);
+}
+export function readUintSafe(bc) {
+  let result = readU8(bc);
+  if (result >= 128) {
+    result &= 127;
+    let shiftMul = (
+      /* 2**7 */
+      128
+    );
+    let byteCount = 1;
+    let byte;
+    do {
+      byte = readU8(bc);
+      result += (byte & 127) * shiftMul;
+      shiftMul *= /* 2**7 */
+      128;
+      byteCount++;
+    } while (byte >= 128 && byteCount < INT_SAFE_MAX_BYTE_COUNT);
+    if (byte === 0) {
+      bc.offset -= byteCount - 1;
+      throw new BareError(
+        bc.offset - byteCount + 1,
+        NON_CANONICAL_REPRESENTATION
+      );
+    }
+    if (byteCount === INT_SAFE_MAX_BYTE_COUNT && byte > 15) {
+      bc.offset -= byteCount - 1;
+      throw new BareError(bc.offset, TOO_LARGE_NUMBER);
+    }
+  }
+  return result;
+}
+export function writeUintSafe(bc, x) {
+  if (DEV) {
+    assert(isU64Safe(x), TOO_LARGE_NUMBER);
+  }
+  let byteCount = 1;
+  let zigZag = x;
+  while (zigZag >= 128 && byteCount < INT_SAFE_MAX_BYTE_COUNT) {
+    writeU8(bc, 128 | zigZag & 127);
+    zigZag = Math.floor(zigZag / /* 2**7 */
+    128);
+    byteCount++;
+  }
+  if (byteCount === INT_SAFE_MAX_BYTE_COUNT) {
+    zigZag &= 15;
+  }
+  writeU8(bc, zigZag);
+}

package/dist/codec/string.d.ts

@@ -1,4 +1,4 @@
-import type { ByteCursor } from "../core/index.js";
+import { type ByteCursor } from "../core/byte-cursor.js";
 export declare function readString(bc: ByteCursor): string;
 export declare function writeString(bc: ByteCursor, x: string): void;
 export declare function readFixedString(bc: ByteCursor, byteLen: number): string;

package/dist/codec/string.js

@@ -1,44 +1,54 @@
-// src/codec/string.ts
+"use strict";
 import { BareError } from "../core/bare-error.js";
-import { INVALID_UTF8_STRING } from "../util/constants.js";
-import { readUintSafe, writeUintSafe } from "./primitive.js";
-import { writeU8FixedArray } from "./u8-array.js";
-function readString(bc) {
-  return readFixedString(bc, readUintSafe(bc));
+import { check, reserve } from "../core/byte-cursor.js";
+import { assert, DEV } from "../util/assert.js";
+import {
+  INVALID_UTF8_STRING,
+  TEXT_DECODER_THRESHOLD,
+  TEXT_ENCODER_THRESHOLD
+} from "../util/constants.js";
+import { isU32 } from "../util/validator.js";
+import { readUintSafe32, writeUintSafe32 } from "./primitive.js";
+import { readUnsafeU8FixedArray, writeU8FixedArray } from "./u8-array.js";
+export function readString(bc) {
+  return readFixedString(bc, readUintSafe32(bc));
 }
-function writeString(bc, x) {
-  if (x.length < bc.config.textEncoderThreshold) {
+export function writeString(bc, x) {
+  if (x.length < TEXT_ENCODER_THRESHOLD) {
     const byteLen = utf8ByteLength(x);
-    writeUintSafe(bc, byteLen);
-    bc.reserve(byteLen);
+    writeUintSafe32(bc, byteLen);
+    reserve(bc, byteLen);
     writeUtf8Js(bc, x);
   } else {
     const strBytes = UTF8_ENCODER.encode(x);
-    writeUintSafe(bc, strBytes.length);
+    writeUintSafe32(bc, strBytes.length);
     writeU8FixedArray(bc, strBytes);
   }
 }
-function readFixedString(bc, byteLen) {
-  if (byteLen < bc.config.textDecoderThreshold) {
+export function readFixedString(bc, byteLen) {
+  if (DEV) {
+    assert(isU32(byteLen));
+  }
+  if (byteLen < TEXT_DECODER_THRESHOLD) {
     return readUtf8Js(bc, byteLen);
   }
   try {
-    return UTF8_DECODER.decode(bc.read(byteLen));
-  } catch (cause) {
+    return UTF8_DECODER.decode(readUnsafeU8FixedArray(bc, byteLen));
+  } catch (_cause) {
     throw new BareError(bc.offset, INVALID_UTF8_STRING);
   }
 }
-function writeFixedString(bc, x) {
-  if (x.length < bc.config.textEncoderThreshold) {
+export function writeFixedString(bc, x) {
+  if (x.length < TEXT_ENCODER_THRESHOLD) {
     const byteLen = utf8ByteLength(x);
-    bc.reserve(byteLen);
+    reserve(bc, byteLen);
     writeUtf8Js(bc, x);
   } else {
     writeU8FixedArray(bc, UTF8_ENCODER.encode(x));
   }
 }
 function readUtf8Js(bc, byteLen) {
-  bc.check(byteLen);
+  check(bc, byteLen);
   let result = "";
   const bytes = bc.bytes;
   let offset = bc.offset;
@@ -51,18 +61,29 @@ function readUtf8Js(bc, byteLen) {
       if (offset < upperOffset && codePoint < 224) {
         const byte2 = bytes[offset++];
         codePoint = (byte1 & 31) << 6 | byte2 & 63;
-        malformed = codePoint >> 7 === 0 || byte1 >> 5 !== 6 || byte2 >> 6 !== 2;
+        malformed = codePoint >> 7 === 0 || // non-canonical char
+        byte1 >> 5 !== 6 || // invalid tag
+        byte2 >> 6 !== 2;
       } else if (offset + 1 < upperOffset && codePoint < 240) {
         const byte2 = bytes[offset++];
         const byte3 = bytes[offset++];
         codePoint = (byte1 & 15) << 12 | (byte2 & 63) << 6 | byte3 & 63;
-        malformed = codePoint >> 11 === 0 || codePoint >> 11 === 27 || byte1 >> 4 !== 14 || byte2 >> 6 !== 2 || byte3 >> 6 !== 2;
+        malformed = codePoint >> 11 === 0 || // non-canonical char or missing data
+        codePoint >> 11 === 27 || // surrogate char (0xD800 <= codePoint <= 0xDFFF)
+        byte1 >> 4 !== 14 || // invalid tag
+        byte2 >> 6 !== 2 || // invalid tag
+        byte3 >> 6 !== 2;
       } else if (offset + 2 < upperOffset) {
         const byte2 = bytes[offset++];
         const byte3 = bytes[offset++];
         const byte4 = bytes[offset++];
         codePoint = (byte1 & 7) << 18 | (byte2 & 63) << 12 | (byte3 & 63) << 6 | byte4 & 63;
-        malformed = codePoint >> 16 === 0 || codePoint > 1114111 || byte1 >> 3 !== 30 || byte2 >> 6 !== 2 || byte3 >> 6 !== 2 || byte4 >> 6 !== 2;
+        malformed = codePoint >> 16 === 0 || // non-canonical char or missing data
+        codePoint > 1114111 || // too large code point
+        byte1 >> 3 !== 30 || // invalid tag
+        byte2 >> 6 !== 2 || // invalid tag
+        byte3 >> 6 !== 2 || // invalid tag
+        byte4 >> 6 !== 2;
       }
       if (malformed) {
         throw new BareError(bc.offset, INVALID_UTF8_STRING);
@@ -115,12 +136,5 @@ function utf8ByteLength(s) {
   }
   return result;
 }
-var UTF8_DECODER = /* @__PURE__ */ new TextDecoder("utf-8", { fatal: true });
-var UTF8_ENCODER = /* @__PURE__ */ new TextEncoder();
-export {
-  readFixedString,
-  readString,
-  writeFixedString,
-  writeString
-};
-//# sourceMappingURL=string.js.map
+const UTF8_DECODER = /* @__PURE__ */ new TextDecoder("utf-8", { fatal: true });
+const UTF8_ENCODER = /* @__PURE__ */ new TextEncoder();