@bare-ts/lib 0.1.1 → 0.2.0

package/dist/index.cjs

@@ -27,99 +27,98 @@ __export(src_exports, {
   BareError: () => BareError,
   ByteCursor: () => ByteCursor,
   Config: () => Config,
-  decodeBool: () => decodeBool,
-  decodeData: () => decodeData,
-  decodeF32: () => decodeF32,
-  decodeF32Array: () => decodeF32Array,
-  decodeF32FixedArray: () => decodeF32FixedArray,
-  decodeF64: () => decodeF64,
-  decodeF64Array: () => decodeF64Array,
-  decodeF64FixedArray: () => decodeF64FixedArray,
-  decodeFixedData: () => decodeFixedData,
-  decodeI16: () => decodeI16,
-  decodeI16Array: () => decodeI16Array,
-  decodeI16FixedArray: () => decodeI16FixedArray,
-  decodeI32: () => decodeI32,
-  decodeI32Array: () => decodeI32Array,
-  decodeI32FixedArray: () => decodeI32FixedArray,
-  decodeI64: () => decodeI64,
-  decodeI64Array: () => decodeI64Array,
-  decodeI64FixedArray: () => decodeI64FixedArray,
-  decodeI64Safe: () => decodeI64Safe,
-  decodeI8: () => decodeI8,
-  decodeI8Array: () => decodeI8Array,
-  decodeI8FixedArray: () => decodeI8FixedArray,
-  decodeInt: () => decodeInt,
-  decodeIntSafe: () => decodeIntSafe,
-  decodeString: () => decodeString,
-  decodeU16: () => decodeU16,
-  decodeU16Array: () => decodeU16Array,
-  decodeU16FixedArray: () => decodeU16FixedArray,
-  decodeU32: () => decodeU32,
-  decodeU32Array: () => decodeU32Array,
-  decodeU32FixedArray: () => decodeU32FixedArray,
-  decodeU64: () => decodeU64,
-  decodeU64Array: () => decodeU64Array,
-  decodeU64FixedArray: () => decodeU64FixedArray,
-  decodeU64Safe: () => decodeU64Safe,
-  decodeU8: () => decodeU8,
-  decodeU8Array: () => decodeU8Array,
-  decodeU8ClampedArray: () => decodeU8ClampedArray,
-  decodeU8ClampedFixedArray: () => decodeU8ClampedFixedArray,
-  decodeU8FixedArray: () => decodeU8FixedArray,
-  decodeUint: () => decodeUint,
-  decodeUintSafe: () => decodeUintSafe,
-  decodeVoid: () => decodeVoid,
-  encodeBool: () => encodeBool,
-  encodeData: () => encodeData,
-  encodeF32: () => encodeF32,
-  encodeF32Array: () => encodeF32Array,
-  encodeF32FixedArray: () => encodeF32FixedArray,
-  encodeF64: () => encodeF64,
-  encodeF64Array: () => encodeF64Array,
-  encodeF64FixedArray: () => encodeF64FixedArray,
-  encodeFixedData: () => encodeFixedData,
-  encodeI16: () => encodeI16,
-  encodeI16Array: () => encodeI16Array,
-  encodeI16FixedArray: () => encodeI16FixedArray,
-  encodeI32: () => encodeI32,
-  encodeI32Array: () => encodeI32Array,
-  encodeI32FixedArray: () => encodeI32FixedArray,
-  encodeI64: () => encodeI64,
-  encodeI64Array: () => encodeI64Array,
-  encodeI64FixedArray: () => encodeI64FixedArray,
-  encodeI64Safe: () => encodeI64Safe,
-  encodeI8: () => encodeI8,
-  encodeI8Array: () => encodeI8Array,
-  encodeI8FixedArray: () => encodeI8FixedArray,
-  encodeInt: () => encodeInt,
-  encodeIntSafe: () => encodeIntSafe,
-  encodeString: () => encodeString,
-  encodeU16: () => encodeU16,
-  encodeU16Array: () => encodeU16Array,
-  encodeU16FixedArray: () => encodeU16FixedArray,
-  encodeU32: () => encodeU32,
-  encodeU32Array: () => encodeU32Array,
-  encodeU32FixedArray: () => encodeU32FixedArray,
-  encodeU64: () => encodeU64,
-  encodeU64Array: () => encodeU64Array,
-  encodeU64FixedArray: () => encodeU64FixedArray,
-  encodeU64Safe: () => encodeU64Safe,
-  encodeU8: () => encodeU8,
-  encodeU8Array: () => encodeU8Array,
-  encodeU8ClampedArray: () => encodeU8ClampedArray,
-  encodeU8ClampedFixedArray: () => encodeU8ClampedFixedArray,
-  encodeU8FixedArray: () => encodeU8FixedArray,
-  encodeUint: () => encodeUint,
-  encodeUintSafe: () => encodeUintSafe,
-  encodeVoid: () => encodeVoid
+  readBool: () => readBool,
+  readData: () => readData,
+  readF32: () => readF32,
+  readF32Array: () => readF32Array,
+  readF32FixedArray: () => readF32FixedArray,
+  readF64: () => readF64,
+  readF64Array: () => readF64Array,
+  readF64FixedArray: () => readF64FixedArray,
+  readFixedData: () => readFixedData,
+  readFixedString: () => readFixedString,
+  readI16: () => readI16,
+  readI16Array: () => readI16Array,
+  readI16FixedArray: () => readI16FixedArray,
+  readI32: () => readI32,
+  readI32Array: () => readI32Array,
+  readI32FixedArray: () => readI32FixedArray,
+  readI64: () => readI64,
+  readI64Array: () => readI64Array,
+  readI64FixedArray: () => readI64FixedArray,
+  readI64Safe: () => readI64Safe,
+  readI8: () => readI8,
+  readI8Array: () => readI8Array,
+  readI8FixedArray: () => readI8FixedArray,
+  readInt: () => readInt,
+  readIntSafe: () => readIntSafe,
+  readString: () => readString,
+  readU16: () => readU16,
+  readU16Array: () => readU16Array,
+  readU16FixedArray: () => readU16FixedArray,
+  readU32: () => readU32,
+  readU32Array: () => readU32Array,
+  readU32FixedArray: () => readU32FixedArray,
+  readU64: () => readU64,
+  readU64Array: () => readU64Array,
+  readU64FixedArray: () => readU64FixedArray,
+  readU64Safe: () => readU64Safe,
+  readU8: () => readU8,
+  readU8Array: () => readU8Array,
+  readU8ClampedArray: () => readU8ClampedArray,
+  readU8ClampedFixedArray: () => readU8ClampedFixedArray,
+  readU8FixedArray: () => readU8FixedArray,
+  readUint: () => readUint,
+  readUintSafe: () => readUintSafe,
+  readVoid: () => readVoid,
+  writeBool: () => writeBool,
+  writeData: () => writeData,
+  writeF32: () => writeF32,
+  writeF32Array: () => writeF32Array,
+  writeF32FixedArray: () => writeF32FixedArray,
+  writeF64: () => writeF64,
+  writeF64Array: () => writeF64Array,
+  writeF64FixedArray: () => writeF64FixedArray,
+  writeFixedData: () => writeFixedData,
+  writeFixedString: () => writeFixedString,
+  writeI16: () => writeI16,
+  writeI16Array: () => writeI16Array,
+  writeI16FixedArray: () => writeI16FixedArray,
+  writeI32: () => writeI32,
+  writeI32Array: () => writeI32Array,
+  writeI32FixedArray: () => writeI32FixedArray,
+  writeI64: () => writeI64,
+  writeI64Array: () => writeI64Array,
+  writeI64FixedArray: () => writeI64FixedArray,
+  writeI64Safe: () => writeI64Safe,
+  writeI8: () => writeI8,
+  writeI8Array: () => writeI8Array,
+  writeI8FixedArray: () => writeI8FixedArray,
+  writeInt: () => writeInt,
+  writeIntSafe: () => writeIntSafe,
+  writeString: () => writeString,
+  writeU16: () => writeU16,
+  writeU16Array: () => writeU16Array,
+  writeU16FixedArray: () => writeU16FixedArray,
+  writeU32: () => writeU32,
+  writeU32Array: () => writeU32Array,
+  writeU32FixedArray: () => writeU32FixedArray,
+  writeU64: () => writeU64,
+  writeU64Array: () => writeU64Array,
+  writeU64FixedArray: () => writeU64FixedArray,
+  writeU64Safe: () => writeU64Safe,
+  writeU8: () => writeU8,
+  writeU8Array: () => writeU8Array,
+  writeU8ClampedArray: () => writeU8ClampedArray,
+  writeU8ClampedFixedArray: () => writeU8ClampedFixedArray,
+  writeU8FixedArray: () => writeU8FixedArray,
+  writeUint: () => writeUint,
+  writeUintSafe: () => writeUintSafe,
+  writeVoid: () => writeVoid
 });
 
-// src/codec/u8-array.ts
-var import_assert4 = require("assert");
-
 // src/codec/primitive.ts
-var import_assert3 = require("assert");
+var import_assert2 = require("assert");
 
 // src/core/bare-error.ts
 var BareError = class extends Error {
@@ -186,50 +185,40 @@ function Config(part) {
 }
 
 // src/core/byte-cursor.ts
-var import_assert2 = require("assert");
 var TOO_LARGE_BUFFER = "too large buffer";
 var ByteCursor = class {
   constructor(bytes, config) {
-    this.config = config;
-    this.offset = 0;
-    this.view = bytes instanceof Uint8Array ? new DataView(bytes.buffer, bytes.byteOffset, bytes.length) : new DataView(bytes);
-    if (this.view.byteLength > config.maxBufferLength) {
+    if (bytes.length > config.maxBufferLength) {
       throw new BareError(0, TOO_LARGE_BUFFER);
     }
+    this.bytes = bytes;
+    this.config = config;
+    this.offset = 0;
+    this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);
   }
   check(min) {
-    if (this.offset + min > this.view.byteLength) {
+    if (this.offset + min > this.bytes.length) {
       throw new BareError(this.offset, "missing bytes");
     }
   }
   reserve(min) {
-    const { config, offset, view } = this;
-    if (offset + min > view.byteLength) {
-      const bytes = new Uint8Array(view.buffer);
-      const minExtraLength = min + offset - view.byteLength;
-      (0, import_assert2.ok)(bytes.length === view.byteOffset + view.byteLength, "un-growable buffer");
-      (0, import_assert2.ok)(bytes.length + minExtraLength <= config.maxBufferLength, TOO_LARGE_BUFFER);
-      const newLen = Math.min(bytes.length + Math.max(minExtraLength, bytes.length), config.maxBufferLength);
+    const minLen = this.offset + min | 0;
+    if (minLen > this.bytes.length) {
+      if (minLen > this.config.maxBufferLength) {
+        throw new BareError(0, TOO_LARGE_BUFFER);
+      }
+      const newLen = Math.min(minLen << 1, this.config.maxBufferLength);
       const newBytes = new Uint8Array(newLen);
-      newBytes.set(bytes);
-      this.view = new DataView(newBytes.buffer, view.byteOffset);
+      newBytes.set(this.bytes);
+      this.bytes = newBytes;
+      this.view = new DataView(newBytes.buffer);
     }
   }
   read(len) {
     this.check(len);
-    const bufferOffset = this.view.byteOffset + this.offset;
+    const offset = this.offset;
     this.offset += len;
-    return new Uint8Array(this.view.buffer, bufferOffset, len);
-  }
-  write(bytes) {
-    const len = bytes.length;
-    if (len !== 0) {
-      this.reserve(len);
-      const bufferOffset = this.view.byteOffset + this.offset;
-      const buffer = new Uint8Array(this.view.buffer);
-      buffer.set(bytes, bufferOffset);
-      this.offset += len;
-    }
+    return this.bytes.subarray(offset, offset + len);
   }
 };
 
@@ -237,18 +226,18 @@ var ByteCursor = class {
 var NAN_NOT_ALLOWED = "NaN is not allowed";
 var NON_CANONICAL_REPRESENTATION = "must be canonical";
 var TOO_LARGE_NUMBER2 = "too large number";
-function decodeBool(bc) {
-  const val = decodeU8(bc);
+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;
 }
-function encodeBool(bc, x) {
-  encodeU8(bc, x ? 1 : 0);
+function writeBool(bc, x) {
+  writeU8(bc, x ? 1 : 0);
 }
-function decodeF32(bc) {
+function readF32(bc) {
   bc.check(4);
   const result = bc.view.getFloat32(bc.offset, true);
   if (Number.isNaN(result)) {
@@ -257,14 +246,14 @@ function decodeF32(bc) {
   bc.offset += 4;
   return result;
 }
-function encodeF32(bc, x) {
-  (0, import_assert3.ok)(!Number.isNaN(x), NAN_NOT_ALLOWED);
+function writeF32(bc, x) {
+  (0, import_assert2.ok)(!Number.isNaN(x), NAN_NOT_ALLOWED);
   bc.reserve(4);
   bc.view.setFloat32(bc.offset, x, true);
-  (0, import_assert3.ok)(Math.abs(bc.view.getFloat32(bc.offset, true) - x) <= Number.EPSILON, TOO_LARGE_NUMBER2);
+  (0, import_assert2.ok)(Math.abs(bc.view.getFloat32(bc.offset, true) - x) <= Number.EPSILON, TOO_LARGE_NUMBER2);
   bc.offset += 4;
 }
-function decodeF64(bc) {
+function readF64(bc) {
   bc.check(8);
   const result = bc.view.getFloat64(bc.offset, true);
   if (Number.isNaN(result)) {
@@ -273,69 +262,69 @@ function decodeF64(bc) {
   bc.offset += 8;
   return result;
 }
-function encodeF64(bc, x) {
-  (0, import_assert3.ok)(!Number.isNaN(x), NAN_NOT_ALLOWED);
+function writeF64(bc, x) {
+  (0, import_assert2.ok)(!Number.isNaN(x), NAN_NOT_ALLOWED);
   bc.reserve(8);
   bc.view.setFloat64(bc.offset, x, true);
   bc.offset += 8;
 }
-function decodeI8(bc) {
+function readI8(bc) {
   bc.check(1);
   return bc.view.getInt8(bc.offset++);
 }
-function encodeI8(bc, x) {
-  (0, import_assert3.ok)(isI8(x), TOO_LARGE_NUMBER2);
+function writeI8(bc, x) {
+  (0, import_assert2.ok)(isI8(x), TOO_LARGE_NUMBER2);
   bc.reserve(1);
   bc.view.setInt8(bc.offset++, x);
 }
-function decodeI16(bc) {
+function readI16(bc) {
   bc.check(2);
   const result = bc.view.getInt16(bc.offset, true);
   bc.offset += 2;
   return result;
 }
-function encodeI16(bc, x) {
-  (0, import_assert3.ok)(isI16(x), TOO_LARGE_NUMBER2);
+function writeI16(bc, x) {
+  (0, import_assert2.ok)(isI16(x), TOO_LARGE_NUMBER2);
   bc.reserve(2);
   bc.view.setInt16(bc.offset, x, true);
   bc.offset += 2;
 }
-function decodeI32(bc) {
+function readI32(bc) {
   bc.check(4);
   const result = bc.view.getInt32(bc.offset, true);
   bc.offset += 4;
   return result;
 }
-function encodeI32(bc, x) {
-  (0, import_assert3.ok)(isI32(x), TOO_LARGE_NUMBER2);
+function writeI32(bc, x) {
+  (0, import_assert2.ok)(isI32(x), TOO_LARGE_NUMBER2);
   bc.reserve(4);
   bc.view.setInt32(bc.offset, x, true);
   bc.offset += 4;
 }
-function decodeI64(bc) {
+function readI64(bc) {
   bc.check(8);
   const result = bc.view.getBigInt64(bc.offset, true);
   bc.offset += 8;
   return result;
 }
-function encodeI64(bc, x) {
-  (0, import_assert3.ok)(isI64(x), TOO_LARGE_NUMBER2);
+function writeI64(bc, x) {
+  (0, import_assert2.ok)(isI64(x), TOO_LARGE_NUMBER2);
   bc.reserve(8);
   bc.view.setBigInt64(bc.offset, x, true);
   bc.offset += 8;
 }
-function decodeI64Safe(bc) {
-  const result = decodeU32(bc) + decodeI32(bc) * 4294967296;
+function readI64Safe(bc) {
+  const result = readU32(bc) + readI32(bc) * 4294967296;
   if (!Number.isSafeInteger(result)) {
     bc.offset -= 8;
     throw new BareError(bc.offset, TOO_LARGE_NUMBER2);
   }
   return result;
 }
-function encodeI64Safe(bc, x) {
-  (0, import_assert3.ok)(Number.isSafeInteger(x), TOO_LARGE_NUMBER2);
+function writeI64Safe(bc, x) {
+  (0, import_assert2.ok)(Number.isSafeInteger(x), TOO_LARGE_NUMBER2);
   const lowest32 = x >>> 0;
-  encodeU32(bc, lowest32);
+  writeU32(bc, lowest32);
   let highest32 = x / 4294967296 | 0;
   if (x < 0) {
     highest32 = ~Math.abs(highest32) >>> 0;
@@ -343,27 +332,27 @@ function encodeI64Safe(bc, x) {
       highest32++;
     }
   }
-  encodeU32(bc, highest32);
+  writeU32(bc, highest32);
 }
-function decodeInt(bc) {
-  const zigZag = decodeUint(bc);
+function readInt(bc) {
+  const zigZag = readUint(bc);
   return zigZag >> BigInt(1) ^ -(zigZag & BigInt(1));
 }
-function encodeInt(bc, x) {
-  (0, import_assert3.ok)(isI64(x), TOO_LARGE_NUMBER2);
+function writeInt(bc, x) {
+  (0, import_assert2.ok)(isI64(x), TOO_LARGE_NUMBER2);
   const zigZag = x >> BigInt(63) ^ x << BigInt(1);
-  encodeUint(bc, zigZag);
+  writeUint(bc, zigZag);
 }
 var INT_SAFE_MAX_BYTE_COUNT = 8;
-function decodeIntSafe(bc) {
-  const firstByte = decodeU8(bc);
+function readIntSafe(bc) {
+  const firstByte = readU8(bc);
   let result = (firstByte & 127) >> 1;
   if (firstByte >= 128) {
     let shiftMul = 64;
     let byteCount = 1;
     let byte;
     do {
-      byte = decodeU8(bc);
+      byte = readU8(bc);
       result += (byte & 127) * shiftMul;
       shiftMul *= 128;
       byteCount++;
@@ -383,8 +372,8 @@ function decodeIntSafe(bc) {
   }
   return result;
 }
-function encodeIntSafe(bc, x) {
-  (0, import_assert3.ok)(Number.isSafeInteger(x), TOO_LARGE_NUMBER2);
+function writeIntSafe(bc, x) {
+  (0, import_assert2.ok)(Number.isSafeInteger(x), TOO_LARGE_NUMBER2);
   const sign = x < 0 ? 1 : 0;
   if (x < 0) {
     x = -(x + 1);
@@ -392,103 +381,107 @@ function encodeIntSafe(bc, x) {
   const firstByte = (x & 63) << 1 | sign;
   x = Math.floor(x / 64);
   if (x > 0) {
-    encodeU8(bc, 128 | firstByte);
-    encodeUintSafe(bc, x);
+    writeU8(bc, 128 | firstByte);
+    writeUintSafe(bc, x);
   } else {
-    encodeU8(bc, firstByte);
+    writeU8(bc, firstByte);
   }
 }
-function decodeU8(bc) {
+function readU8(bc) {
   bc.check(1);
-  return bc.view.getUint8(bc.offset++);
+  return bc.bytes[bc.offset++];
 }
-function encodeU8(bc, x) {
-  (0, import_assert3.ok)(isU8(x), TOO_LARGE_NUMBER2);
+function writeU8(bc, x) {
+  (0, import_assert2.ok)(isU8(x), TOO_LARGE_NUMBER2);
   bc.reserve(1);
-  bc.view.setUint8(bc.offset++, x);
+  bc.bytes[bc.offset++] = x;
 }
-function decodeU16(bc) {
+function readU16(bc) {
   bc.check(2);
   const result = bc.view.getUint16(bc.offset, true);
   bc.offset += 2;
   return result;
 }
-function encodeU16(bc, x) {
-  (0, import_assert3.ok)(isU16(x), TOO_LARGE_NUMBER2);
+function writeU16(bc, x) {
+  (0, import_assert2.ok)(isU16(x), TOO_LARGE_NUMBER2);
   bc.reserve(2);
   bc.view.setUint16(bc.offset, x, true);
   bc.offset += 2;
 }
-function decodeU32(bc) {
+function readU32(bc) {
   bc.check(4);
   const result = bc.view.getUint32(bc.offset, true);
   bc.offset += 4;
   return result;
 }
-function encodeU32(bc, x) {
-  (0, import_assert3.ok)(isU32(x), TOO_LARGE_NUMBER2);
+function writeU32(bc, x) {
+  (0, import_assert2.ok)(isU32(x), TOO_LARGE_NUMBER2);
   bc.reserve(4);
   bc.view.setUint32(bc.offset, x, true);
   bc.offset += 4;
 }
-function decodeU64(bc) {
+function readU64(bc) {
   bc.check(8);
   const result = bc.view.getBigUint64(bc.offset, true);
   bc.offset += 8;
   return result;
 }
-function encodeU64(bc, x) {
-  (0, import_assert3.ok)(isU64(x), TOO_LARGE_NUMBER2);
+function writeU64(bc, x) {
+  (0, import_assert2.ok)(isU64(x), TOO_LARGE_NUMBER2);
   bc.reserve(8);
   bc.view.setBigUint64(bc.offset, x, true);
   bc.offset += 8;
 }
-function decodeU64Safe(bc) {
-  const result = decodeU32(bc) + decodeU32(bc) * 4294967296;
+function readU64Safe(bc) {
+  const result = readU32(bc) + readU32(bc) * 4294967296;
   if (!isSafeU64(result)) {
     bc.offset -= 8;
     throw new BareError(bc.offset, TOO_LARGE_NUMBER2);
   }
   return result;
 }
-function encodeU64Safe(bc, x) {
-  (0, import_assert3.ok)(isSafeU64(x), TOO_LARGE_NUMBER2);
-  encodeU32(bc, x >>> 0);
-  encodeU32(bc, x / 4294967296 >>> 0);
+function writeU64Safe(bc, x) {
+  (0, import_assert2.ok)(isSafeU64(x), TOO_LARGE_NUMBER2);
+  writeU32(bc, x >>> 0);
+  writeU32(bc, x / 4294967296 >>> 0);
 }
 var UINT_MAX_BYTE_COUNT = 10;
-function decodeUint(bc) {
-  let byteCount = 0;
-  let byte;
-  let low = 0;
-  let shiftMul = 1;
-  do {
-    byte = decodeU8(bc);
-    low += (byte & 127) * shiftMul;
-    shiftMul *= 128;
-    byteCount++;
-  } while (byte >= 128 && byteCount < 7);
-  let height = 0;
-  shiftMul = 1;
-  while (byte >= 128 && byteCount < UINT_MAX_BYTE_COUNT) {
-    byte = decodeU8(bc);
-    height += (byte & 127) * shiftMul;
-    shiftMul *= 128;
-    byteCount++;
-  }
-  if (byteCount !== 1 && byte === 0 || byteCount === UINT_MAX_BYTE_COUNT && byte > 1) {
-    bc.offset -= byteCount;
-    throw new BareError(bc.offset, NON_CANONICAL_REPRESENTATION);
+function readUint(bc) {
+  let low = readU8(bc);
+  if (low >= 128) {
+    low &= 127;
+    let shiftMul = 128;
+    let byteCount = 1;
+    let byte;
+    do {
+      byte = readU8(bc);
+      low += (byte & 127) * shiftMul;
+      shiftMul *= 128;
+      byteCount++;
+    } while (byte >= 128 && byteCount < 7);
+    let height = 0;
+    shiftMul = 1;
+    while (byte >= 128 && byteCount < UINT_MAX_BYTE_COUNT) {
+      byte = readU8(bc);
+      height += (byte & 127) * shiftMul;
+      shiftMul *= 128;
+      byteCount++;
+    }
+    if (byte === 0 || byteCount === UINT_MAX_BYTE_COUNT && byte > 1) {
+      bc.offset -= byteCount;
+      throw new BareError(bc.offset, NON_CANONICAL_REPRESENTATION);
+    }
+    return BigInt(low) + (BigInt(height) << BigInt(7 * 7));
   }
-  return BigInt(low) + (BigInt(height) << BigInt(7 * 7));
+  return BigInt(low);
 }
-function encodeUint(bc, x) {
-  (0, import_assert3.ok)(isU64(x), TOO_LARGE_NUMBER2);
+function writeUint(bc, x) {
+  (0, import_assert2.ok)(isU64(x), TOO_LARGE_NUMBER2);
   let tmp = Number(BigInt.asUintN(7 * 7, x));
   let rest = Number(x >> BigInt(7 * 7));
   let byteCount = 0;
   while (tmp >= 128 || rest !== 0) {
-    encodeU8(bc, 128 | tmp & 127);
+    writeU8(bc, 128 | tmp & 127);
     tmp = Math.floor(tmp / 128);
     byteCount++;
     if (byteCount === 7) {
@@ -496,387 +489,381 @@ function encodeUint(bc, x) {
       rest = 0;
     }
   }
-  encodeU8(bc, tmp);
+  writeU8(bc, tmp);
 }
 var UINT_SAFE_MAX_BYTE_COUNT = 8;
-function decodeUintSafe(bc) {
-  let result = 0;
-  let shiftMul = 1;
-  let byteCount = 0;
-  let byte;
-  do {
-    byte = decodeU8(bc);
-    result += (byte & 127) * shiftMul;
-    shiftMul *= 128;
-    byteCount++;
-  } while (byte >= 128 && byteCount < UINT_SAFE_MAX_BYTE_COUNT);
-  if (byteCount !== 1 && byte === 0) {
-    bc.offset -= byteCount - 1;
-    throw new BareError(bc.offset - byteCount + 1, NON_CANONICAL_REPRESENTATION);
-  }
-  if (byteCount === UINT_SAFE_MAX_BYTE_COUNT && byte > 15) {
-    bc.offset -= byteCount - 1;
-    throw new BareError(bc.offset, TOO_LARGE_NUMBER2);
+function readUintSafe(bc) {
+  let result = readU8(bc);
+  if (result >= 128) {
+    result &= 127;
+    let shiftMul = 128;
+    let byteCount = 1;
+    let byte;
+    do {
+      byte = readU8(bc);
+      result += (byte & 127) * shiftMul;
+      shiftMul *= 128;
+      byteCount++;
+    } while (byte >= 128 && byteCount < UINT_SAFE_MAX_BYTE_COUNT);
+    if (byte === 0) {
+      bc.offset -= byteCount - 1;
+      throw new BareError(bc.offset - byteCount + 1, NON_CANONICAL_REPRESENTATION);
+    }
+    if (byteCount === UINT_SAFE_MAX_BYTE_COUNT && byte > 15) {
+      bc.offset -= byteCount - 1;
+      throw new BareError(bc.offset, TOO_LARGE_NUMBER2);
+    }
   }
   return result;
 }
-function encodeUintSafe(bc, x) {
-  (0, import_assert3.ok)(isSafeU64(x), TOO_LARGE_NUMBER2);
+function writeUintSafe(bc, x) {
+  (0, import_assert2.ok)(isSafeU64(x), TOO_LARGE_NUMBER2);
   while (x >= 128) {
-    encodeU8(bc, 128 | x & 127);
+    writeU8(bc, 128 | x & 127);
     x = Math.floor(x / 128);
   }
-  encodeU8(bc, x);
+  writeU8(bc, x);
 }
-function decodeVoid(_dc) {
+function readVoid(_dc) {
   return void 0;
 }
-function encodeVoid(_dc, _x) {
+function writeVoid(_dc, _x) {
 }
 
 // src/codec/u8-array.ts
-function decodeU8Array(bc) {
-  const len = decodeUintSafe(bc);
-  return bc.read(len).slice();
+function readU8Array(bc) {
+  return readU8FixedArray(bc, readUintSafe(bc));
 }
-function encodeU8Array(bc, x) {
-  encodeUintSafe(bc, x.length);
-  bc.write(x);
+function writeU8Array(bc, x) {
+  writeUintSafe(bc, x.length);
+  writeU8FixedArray(bc, x);
 }
-function decodeU8FixedArray(bc, len) {
+function readU8FixedArray(bc, len) {
   return bc.read(len).slice();
 }
-function encodeU8FixedArray(bc, x, len) {
-  (0, import_assert4.ok)(x.length === len);
-  bc.write(x);
+function writeU8FixedArray(bc, x) {
+  const len = x.length;
+  if (len !== 0) {
+    bc.reserve(len);
+    bc.bytes.set(x, bc.offset);
+    bc.offset += len;
+  }
 }
 
 // src/codec/data.ts
-function decodeData(bc) {
-  return decodeU8Array(bc).buffer;
+function readData(bc) {
+  return readU8Array(bc).buffer;
 }
-function encodeData(bc, x) {
-  encodeU8Array(bc, new Uint8Array(x));
+function writeData(bc, x) {
+  writeU8Array(bc, new Uint8Array(x));
 }
-function decodeFixedData(bc, len) {
-  return decodeU8FixedArray(bc, len).buffer;
+function readFixedData(bc, len) {
+  return readU8FixedArray(bc, len).buffer;
 }
-function encodeFixedData(bc, x, len) {
-  encodeU8FixedArray(bc, new Uint8Array(x), len);
+function writeFixedData(bc, x) {
+  writeU8FixedArray(bc, new Uint8Array(x));
 }
 
 // src/codec/float-array.ts
-var import_assert5 = require("assert");
+var import_assert3 = require("assert");
 
 // src/util/util.ts
 var IS_LITTLE_ENDIAN_PLATFORM = new DataView(Uint16Array.of(1).buffer).getUint8(0) === 1;
 
 // src/codec/float-array.ts
 var NAN_NOT_ALLOWED2 = "NaN is not allowed";
-var decodeF32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeF32FixedArrayLE : decodeF32FixedArrayBE;
-function decodeF32FixedArrayLE(bc, len) {
+var readF32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readF32FixedArrayLE : readF32FixedArrayBE;
+function readF32FixedArrayLE(bc, len) {
   const byteLen = len * 4;
-  const result = new Float32Array(decodeFixedData(bc, byteLen));
+  const result = new Float32Array(readFixedData(bc, byteLen));
   if (result.some(Number.isNaN)) {
     throw new BareError(bc.offset, NAN_NOT_ALLOWED2);
   }
   return result;
 }
-function decodeF32FixedArrayBE(bc, len) {
+function readF32FixedArrayBE(bc, len) {
   bc.check(len * 4);
   const result = new Float32Array(len);
   for (let i = 0; i < len; i++)
-    result[i] = decodeF32(bc);
+    result[i] = readF32(bc);
   return result;
 }
-var encodeF32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? encodeF32FixedArrayLE : encodeF32FixedArrayBE;
-function encodeF32FixedArrayLE(bc, x, len) {
-  (0, import_assert5.ok)(x.length === len);
-  (0, import_assert5.ok)(!x.every(Number.isNaN), NAN_NOT_ALLOWED2);
-  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+var writeF32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeF32FixedArrayLE : writeF32FixedArrayBE;
+function writeF32FixedArrayLE(bc, x) {
+  (0, import_assert3.ok)(!x.every(Number.isNaN), NAN_NOT_ALLOWED2);
+  writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
 }
-function encodeF32FixedArrayBE(bc, val, len) {
-  (0, import_assert5.ok)(val.length === len);
+function writeF32FixedArrayBE(bc, val) {
   bc.reserve(val.length * 4);
   for (let i = 0; i < val.length; i++)
-    encodeF32(bc, val[i]);
+    writeF32(bc, val[i]);
 }
-function decodeF32Array(bc) {
-  return decodeF32FixedArray(bc, decodeUintSafe(bc));
+function readF32Array(bc) {
+  return readF32FixedArray(bc, readUintSafe(bc));
 }
-function encodeF32Array(bc, x) {
-  encodeUintSafe(bc, x.length);
+function writeF32Array(bc, x) {
+  writeUintSafe(bc, x.length);
   if (x.length !== 0) {
-    encodeF32FixedArray(bc, x, x.length);
+    writeF32FixedArray(bc, x);
   }
 }
-var decodeF64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeF64FixedArrayLE : decodeF64FixedArrayBE;
-function decodeF64FixedArrayLE(bc, len) {
+var readF64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readF64FixedArrayLE : readF64FixedArrayBE;
+function readF64FixedArrayLE(bc, len) {
   const byteLen = len * 8;
-  const result = new Float64Array(decodeFixedData(bc, byteLen));
+  const result = new Float64Array(readFixedData(bc, byteLen));
   if (result.some(Number.isNaN)) {
     throw new BareError(bc.offset, NAN_NOT_ALLOWED2);
   }
   return result;
 }
-function decodeF64FixedArrayBE(bc, len) {
+function readF64FixedArrayBE(bc, len) {
   bc.check(len * 8);
   const result = new Float64Array(len);
   for (let i = 0; i < len; i++)
-    result[i] = decodeF64(bc);
+    result[i] = readF64(bc);
   return result;
 }
-var encodeF64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? encodeF64FixedArrayLE : encodeF64FixedArrayBE;
-function encodeF64FixedArrayLE(bc, x, len) {
-  (0, import_assert5.ok)(x.length === len);
-  (0, import_assert5.ok)(!x.every(Number.isNaN), NAN_NOT_ALLOWED2);
-  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+var writeF64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeF64FixedArrayLE : writeF64FixedArrayBE;
+function writeF64FixedArrayLE(bc, x) {
+  (0, import_assert3.ok)(!x.every(Number.isNaN), NAN_NOT_ALLOWED2);
+  writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
 }
-function encodeF64FixedArrayBE(bc, x, len) {
-  (0, import_assert5.ok)(x.length === len);
+function writeF64FixedArrayBE(bc, x) {
   bc.reserve(x.length * 8);
   for (let i = 0; i < x.length; i++)
-    encodeF64(bc, x[i]);
+    writeF64(bc, x[i]);
 }
-function decodeF64Array(bc) {
-  return decodeF64FixedArray(bc, decodeUintSafe(bc));
+function readF64Array(bc) {
+  return readF64FixedArray(bc, readUintSafe(bc));
 }
-function encodeF64Array(bc, x) {
-  encodeUintSafe(bc, x.length);
+function writeF64Array(bc, x) {
+  writeUintSafe(bc, x.length);
   if (x.length !== 0) {
-    encodeF64FixedArray(bc, x, x.length);
+    writeF64FixedArray(bc, x);
   }
 }
 
 // src/codec/i16-array.ts
-var import_assert6 = require("assert");
 var I16_BYTE_COUNT = 2;
-var decodeI16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeI16FixedArrayLE : decodeI16FixedArrayBE;
-function decodeI16Array(bc) {
-  return decodeI16FixedArray(bc, decodeUintSafe(bc));
+var readI16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readI16FixedArrayLE : readI16FixedArrayBE;
+function readI16Array(bc) {
+  return readI16FixedArray(bc, readUintSafe(bc));
 }
-function decodeI16FixedArrayLE(bc, len) {
+function readI16FixedArrayLE(bc, len) {
   const byteCount = len * I16_BYTE_COUNT;
-  return new Int16Array(decodeFixedData(bc, byteCount));
+  return new Int16Array(readFixedData(bc, byteCount));
 }
-function decodeI16FixedArrayBE(bc, len) {
+function readI16FixedArrayBE(bc, len) {
   bc.check(len * I16_BYTE_COUNT);
   const result = new Int16Array(len);
   for (let i = 0; i < len; i++)
-    result[i] = decodeI16(bc);
+    result[i] = readI16(bc);
   return result;
 }
-var encodeI16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? encodeI16FixedArrayLE : encodeI16FixedArrayBE;
-function encodeI16Array(bc, x) {
-  encodeUintSafe(bc, x.length);
+var writeI16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeI16FixedArrayLE : writeI16FixedArrayBE;
+function writeI16Array(bc, x) {
+  writeUintSafe(bc, x.length);
   if (x.length !== 0) {
-    encodeI16FixedArray(bc, x, x.length);
+    writeI16FixedArray(bc, x);
   }
 }
-function encodeI16FixedArrayLE(bc, x, len) {
-  (0, import_assert6.ok)(x.length === len);
-  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+function writeI16FixedArrayLE(bc, x) {
+  writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
 }
-function encodeI16FixedArrayBE(bc, x, len) {
-  (0, import_assert6.ok)(x.length === len);
+function writeI16FixedArrayBE(bc, x) {
   bc.reserve(x.length * I16_BYTE_COUNT);
   for (let i = 0; i < x.length; i++)
-    encodeI16(bc, x[i]);
+    writeI16(bc, x[i]);
 }
 
 // src/codec/i32-array.ts
-var import_assert7 = require("assert");
 var I32_BYTE_COUNT = 4;
-var decodeI32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeI32FixedArrayLE : decodeI32FixedArrayBE;
-function decodeI32Array(bc) {
-  return decodeI32FixedArray(bc, decodeUintSafe(bc));
+var readI32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readI32FixedArrayLE : readI32FixedArrayBE;
+function readI32Array(bc) {
+  return readI32FixedArray(bc, readUintSafe(bc));
 }
-function decodeI32FixedArrayLE(bc, len) {
+function readI32FixedArrayLE(bc, len) {
   const byteCount = len * I32_BYTE_COUNT;
-  return new Int32Array(decodeFixedData(bc, byteCount));
+  return new Int32Array(readFixedData(bc, byteCount));
 }
-function decodeI32FixedArrayBE(bc, len) {
+function readI32FixedArrayBE(bc, len) {
   bc.check(len * I32_BYTE_COUNT);
   const result = new Int32Array(len);
   for (let i = 0; i < len; i++)
-    result[i] = decodeI32(bc);
+    result[i] = readI32(bc);
   return result;
 }
-var encodeI32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? encodeI32FixedArrayLE : encodeI32FixedArrayBE;
-function encodeI32Array(bc, x) {
-  encodeUintSafe(bc, x.length);
+var writeI32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeI32FixedArrayLE : writeI32FixedArrayBE;
+function writeI32Array(bc, x) {
+  writeUintSafe(bc, x.length);
   if (x.length !== 0) {
-    encodeI32FixedArray(bc, x, x.length);
+    writeI32FixedArray(bc, x);
   }
 }
-function encodeI32FixedArrayLE(bc, x, len) {
-  (0, import_assert7.ok)(x.length === len);
-  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+function writeI32FixedArrayLE(bc, x) {
+  writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
 }
-function encodeI32FixedArrayBE(bc, x, len) {
-  (0, import_assert7.ok)(x.length === len);
+function writeI32FixedArrayBE(bc, x) {
   bc.reserve(x.length * I32_BYTE_COUNT);
   for (let i = 0; i < x.length; i++)
-    encodeI32(bc, x[i]);
+    writeI32(bc, x[i]);
 }
 
 // src/codec/i64-array.ts
-var import_assert8 = require("assert");
 var I64_BYTE_COUNT = 8;
-var decodeI64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeI64FixedArrayLE : decodeI64FixedArrayBE;
-function decodeI64Array(bc) {
-  return decodeI64FixedArray(bc, decodeUintSafe(bc));
+var readI64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readI64FixedArrayLE : readI64FixedArrayBE;
+function readI64Array(bc) {
+  return readI64FixedArray(bc, readUintSafe(bc));
 }
-function decodeI64FixedArrayLE(bc, len) {
+function readI64FixedArrayLE(bc, len) {
   const byteCount = len * I64_BYTE_COUNT;
-  return new BigInt64Array(decodeFixedData(bc, byteCount));
+  return new BigInt64Array(readFixedData(bc, byteCount));
 }
-function decodeI64FixedArrayBE(bc, len) {
+function readI64FixedArrayBE(bc, len) {
   bc.check(len * I64_BYTE_COUNT);
   const result = new BigInt64Array(len);
   for (let i = 0; i < len; i++)
-    result[i] = decodeI64(bc);
+    result[i] = readI64(bc);
   return result;
 }
-var encodeI64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? encodeI64FixedArrayLE : encodeI64FixedArrayBE;
-function encodeI64Array(bc, x) {
-  encodeUintSafe(bc, x.length);
+var writeI64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeI64FixedArrayLE : writeI64FixedArrayBE;
+function writeI64Array(bc, x) {
+  writeUintSafe(bc, x.length);
   if (x.length !== 0) {
-    encodeI64FixedArray(bc, x, x.length);
+    writeI64FixedArray(bc, x);
   }
 }
-function encodeI64FixedArrayLE(bc, x, len) {
-  (0, import_assert8.ok)(x.length === len);
-  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+function writeI64FixedArrayLE(bc, x) {
+  writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
 }
-function encodeI64FixedArrayBE(bc, x, len) {
-  (0, import_assert8.ok)(x.length === len);
+function writeI64FixedArrayBE(bc, x) {
   bc.reserve(x.length * I64_BYTE_COUNT);
   for (let i = 0; i < x.length; i++)
-    encodeI64(bc, x[i]);
+    writeI64(bc, x[i]);
 }
 
 // src/codec/i8-array.ts
-function decodeI8Array(bc) {
-  return decodeI8FixedArray(bc, decodeUintSafe(bc));
+function readI8Array(bc) {
+  return readI8FixedArray(bc, readUintSafe(bc));
 }
-function encodeI8Array(bc, x) {
-  encodeUintSafe(bc, x.length);
-  encodeI8FixedArray(bc, x, x.length);
+function writeI8Array(bc, x) {
+  writeUintSafe(bc, x.length);
+  writeI8FixedArray(bc, x);
 }
-function decodeI8FixedArray(bc, len) {
-  return new Int8Array(decodeFixedData(bc, len));
+function readI8FixedArray(bc, len) {
+  return new Int8Array(readFixedData(bc, len));
 }
-function encodeI8FixedArray(bc, x, len) {
-  encodeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength), len);
+function writeI8FixedArray(bc, x) {
+  writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
 }
 
 // src/codec/string.ts
-function decodeString(bc) {
-  const strBytesLen = decodeUintSafe(bc);
-  const strBytes = bc.read(strBytesLen);
+var INVALID_UTF8_STRING = "invalid UTF-8 string";
+function readString(bc) {
+  return readFixedString(bc, readUintSafe(bc));
+}
+function writeString(bc, x) {
+  if (x.length < bc.config.textEncoderThreshold) {
+    const byteLen = utf8ByteLength(x);
+    writeUintSafe(bc, byteLen);
+    bc.reserve(byteLen);
+    writeUtf8Js(bc, x);
+  } else {
+    const strBytes = UTF8_ENCODER.encode(x);
+    writeUintSafe(bc, strBytes.length);
+    writeU8FixedArray(bc, strBytes);
+  }
+}
+function readFixedString(bc, byteLen) {
+  if (byteLen < bc.config.textDecoderThreshold) {
+    return readUtf8Js(bc, byteLen);
+  }
   try {
-    return strBytesLen < bc.config.textDecoderThreshold ? decodeUtf8Js(strBytes) : UTF8_DECODER.decode(strBytes);
+    return UTF8_DECODER.decode(bc.read(byteLen));
   } catch (cause) {
-    throw new BareError(bc.offset - strBytesLen, "invalid UTF-8 string", {
-      cause
-    });
+    throw new BareError(bc.offset, INVALID_UTF8_STRING);
   }
 }
-function encodeString(bc, x) {
+function writeFixedString(bc, x) {
   if (x.length < bc.config.textEncoderThreshold) {
     const byteLen = utf8ByteLength(x);
-    encodeUintSafe(bc, byteLen);
     bc.reserve(byteLen);
-    encodeUtf8Js(bc, x);
+    writeUtf8Js(bc, x);
   } else {
-    const strBytes = UTF8_ENCODER.encode(x);
-    encodeUintSafe(bc, strBytes.length);
-    bc.write(strBytes);
+    writeU8FixedArray(bc, UTF8_ENCODER.encode(x));
   }
 }
-function decodeUtf8Js(bytes) {
-  const bytesLen = bytes.length;
+function readUtf8Js(bc, byteLen) {
+  bc.check(byteLen);
   let result = "";
-  let i = 0;
-  while (i < bytesLen) {
-    let codePoint = bytes[i++] | 0;
-    switch (Math.clz32(~codePoint << 24)) {
-      case 0:
-        break;
-      case 2: {
-        if (i < bytesLen) {
-          codePoint = (codePoint & 31) << 6 | bytes[i] & 63;
-        }
-        if (codePoint >> 7 === 0 || bytes[i] >> 6 !== 2) {
-          throw TypeError("Decoding failed");
-        }
-        i += 1;
-        break;
-      }
-      case 3: {
-        if (i + 1 < bytesLen) {
-          codePoint = (codePoint & 15) << 12 | (bytes[i] & 63) << 6 | bytes[i + 1] & 63;
-        }
-        if (codePoint >> 11 === 0 || bytes[i] >> 6 !== 2 || bytes[i + 1] >> 6 !== 2 || codePoint >> 11 === 27) {
-          throw TypeError("Decoding failed");
-        }
-        i += 2;
-        break;
+  const bytes = bc.bytes;
+  let offset = bc.offset;
+  const upperOffset = offset + byteLen;
+  while (offset < upperOffset) {
+    let codePoint = bytes[offset++];
+    if (codePoint > 127) {
+      let malformed = true;
+      const byte1 = codePoint;
+      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;
+      } 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;
+      } 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;
       }
-      case 4: {
-        if (i + 2 < bytesLen) {
-          codePoint = (codePoint & 7) << 18 | (bytes[i] & 63) << 12 | (bytes[i + 1] & 63) << 6 | bytes[i + 2] & 63;
-        }
-        if (codePoint >> 16 === 0 || codePoint > 1114111 || bytes[i] >> 6 !== 2 || bytes[i + 1] >> 6 !== 2 || bytes[i + 2] >> 6 !== 2) {
-          throw TypeError("Decoding failed");
-        }
-        i += 3;
-        break;
+      if (malformed) {
+        throw new BareError(bc.offset, INVALID_UTF8_STRING);
       }
-      default:
-        throw TypeError("Decoding failed");
     }
     result += String.fromCodePoint(codePoint);
   }
+  bc.offset = offset;
   return result;
 }
-function encodeUtf8Js(bc, s) {
-  const sLen = s.length;
+function writeUtf8Js(bc, s) {
+  const bytes = bc.bytes;
   let offset = bc.offset;
-  const view = bc.view;
   let i = 0;
-  while (i < sLen) {
+  while (i < s.length) {
     const codePoint = s.codePointAt(i++);
     if (codePoint < 128) {
-      view.setUint8(offset++, codePoint);
-    } else if (codePoint < 2048) {
-      view.setUint8(offset++, 192 | codePoint >> 6);
-      view.setUint8(offset++, 128 | codePoint & 63);
-    } else if (codePoint < 65536) {
-      view.setUint8(offset++, 224 | codePoint >> 12);
-      view.setUint8(offset++, 128 | codePoint >> 6 & 63);
-      view.setUint8(offset++, 128 | codePoint & 63);
+      bytes[offset++] = codePoint;
     } else {
-      view.setUint8(offset++, 240 | codePoint >> 18);
-      view.setUint8(offset++, 128 | codePoint >> 12 & 63);
-      view.setUint8(offset++, 128 | codePoint >> 6 & 63);
-      view.setUint8(offset++, 128 | codePoint & 63);
-      i++;
+      if (codePoint < 2048) {
+        bytes[offset++] = 192 | codePoint >> 6;
+      } else {
+        if (codePoint < 65536) {
+          bytes[offset++] = 224 | codePoint >> 12;
+        } else {
+          bytes[offset++] = 240 | codePoint >> 18;
+          bytes[offset++] = 128 | codePoint >> 12 & 63;
+          i++;
+        }
+        bytes[offset++] = 128 | codePoint >> 6 & 63;
+      }
+      bytes[offset++] = 128 | codePoint & 63;
     }
   }
   bc.offset = offset;
 }
 function utf8ByteLength(s) {
-  const sLen = s.length;
-  let result = sLen;
-  for (let i = 0; i < sLen; i++) {
+  let result = s.length;
+  for (let i = 0; i < s.length; i++) {
     const codePoint = s.codePointAt(i);
-    if (codePoint >= 128) {
+    if (codePoint > 127) {
       result++;
-      if (codePoint >= 2048) {
+      if (codePoint > 2047) {
         result++;
-        if (codePoint >= 65536) {
+        if (codePoint > 65535) {
           i++;
         }
       }
@@ -888,126 +875,117 @@ var UTF8_DECODER = new TextDecoder("utf-8", { fatal: true });
 var UTF8_ENCODER = new TextEncoder();
 
 // src/codec/u16-array.ts
-var import_assert9 = require("assert");
 var U16_BYTE_COUNT = 2;
-var decodeU16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeU16FixedArrayLE : decodeU16FixedArrayBE;
-function decodeU16Array(bc) {
-  return decodeU16FixedArray(bc, decodeUintSafe(bc));
+var readU16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readU16FixedArrayLE : readU16FixedArrayBE;
+function readU16Array(bc) {
+  return readU16FixedArray(bc, readUintSafe(bc));
 }
-function decodeU16FixedArrayLE(bc, len) {
+function readU16FixedArrayLE(bc, len) {
   const byteCount = len * U16_BYTE_COUNT;
-  return new Uint16Array(decodeFixedData(bc, byteCount));
+  return new Uint16Array(readFixedData(bc, byteCount));
 }
-function decodeU16FixedArrayBE(bc, len) {
+function readU16FixedArrayBE(bc, len) {
   bc.check(len * U16_BYTE_COUNT);
   const result = new Uint16Array(len);
   for (let i = 0; i < len; i++)
-    result[i] = decodeU16(bc);
+    result[i] = readU16(bc);
   return result;
 }
-var encodeU16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? encodeU16FixedArrayLE : encodeU16FixedArrayBE;
-function encodeU16Array(bc, x) {
-  encodeUintSafe(bc, x.length);
+var writeU16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeU16FixedArrayLE : writeU16FixedArrayBE;
+function writeU16Array(bc, x) {
+  writeUintSafe(bc, x.length);
   if (x.length !== 0) {
-    encodeU16FixedArray(bc, x, x.length);
+    writeU16FixedArray(bc, x);
   }
 }
-function encodeU16FixedArrayLE(bc, x, len) {
-  (0, import_assert9.ok)(x.length === len);
-  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+function writeU16FixedArrayLE(bc, x) {
+  writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
 }
-function encodeU16FixedArrayBE(bc, x, len) {
-  (0, import_assert9.ok)(x.length === len);
+function writeU16FixedArrayBE(bc, x) {
   bc.reserve(x.length * U16_BYTE_COUNT);
   for (let i = 0; i < x.length; i++)
-    encodeU16(bc, x[i]);
+    writeU16(bc, x[i]);
 }
 
 // src/codec/u32-array.ts
-var import_assert10 = require("assert");
 var U32_BYTE_COUNT = 4;
-var decodeU32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeU32FixedArrayLE : decodeU32FixedArrayBE;
-function decodeU32Array(bc) {
-  return decodeU32FixedArray(bc, decodeUintSafe(bc));
+var readU32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readU32FixedArrayLE : readU32FixedArrayBE;
+function readU32Array(bc) {
+  return readU32FixedArray(bc, readUintSafe(bc));
 }
-function decodeU32FixedArrayLE(bc, len) {
+function readU32FixedArrayLE(bc, len) {
   const byteCount = len * U32_BYTE_COUNT;
-  return new Uint32Array(decodeFixedData(bc, byteCount));
+  return new Uint32Array(readFixedData(bc, byteCount));
 }
-function decodeU32FixedArrayBE(bc, len) {
+function readU32FixedArrayBE(bc, len) {
   bc.check(len * U32_BYTE_COUNT);
   const result = new Uint32Array(len);
   for (let i = 0; i < len; i++)
-    result[i] = decodeU32(bc);
+    result[i] = readU32(bc);
   return result;
 }
-var encodeU32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? encodeU32FixedArrayLE : encodeU32FixedArrayBE;
-function encodeU32Array(bc, x) {
-  encodeUintSafe(bc, x.length);
+var writeU32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeU32FixedArrayLE : writeU32FixedArrayBE;
+function writeU32Array(bc, x) {
+  writeUintSafe(bc, x.length);
   if (x.length !== 0) {
-    encodeU32FixedArray(bc, x, x.length);
+    writeU32FixedArray(bc, x);
   }
 }
-function encodeU32FixedArrayLE(bc, x, len) {
-  (0, import_assert10.ok)(x.length === len);
-  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+function writeU32FixedArrayLE(bc, x) {
+  writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
 }
-function encodeU32FixedArrayBE(bc, x, len) {
-  (0, import_assert10.ok)(x.length === len);
+function writeU32FixedArrayBE(bc, x) {
   bc.reserve(x.length * U32_BYTE_COUNT);
   for (let i = 0; i < x.length; i++)
-    encodeU32(bc, x[i]);
+    writeU32(bc, x[i]);
 }
 
 // src/codec/u64-array.ts
-var import_assert11 = require("assert");
 var U64_BYTE_COUNT = 8;
-var decodeU64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeU64FixedArrayLE : decodeU64FixedArrayBE;
-function decodeU64Array(bc) {
-  return decodeU64FixedArray(bc, decodeUintSafe(bc));
+var readU64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readU64FixedArrayLE : readU64FixedArrayBE;
+function readU64Array(bc) {
+  return readU64FixedArray(bc, readUintSafe(bc));
 }
-function decodeU64FixedArrayLE(bc, len) {
+function readU64FixedArrayLE(bc, len) {
   const byteCount = len * U64_BYTE_COUNT;
-  return new BigUint64Array(decodeFixedData(bc, byteCount));
+  return new BigUint64Array(readFixedData(bc, byteCount));
 }
-function decodeU64FixedArrayBE(bc, len) {
+function readU64FixedArrayBE(bc, len) {
   bc.check(len * U64_BYTE_COUNT);
   const result = new BigUint64Array(len);
   for (let i = 0; i < len; i++)
-    result[i] = decodeU64(bc);
+    result[i] = readU64(bc);
   return result;
 }
-var encodeU64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? encodeU64FixedArrayLE : encodeU64FixedArrayBE;
-function encodeU64Array(bc, x) {
-  encodeUintSafe(bc, x.length);
+var writeU64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeU64FixedArrayLE : writeU64FixedArrayBE;
+function writeU64Array(bc, x) {
+  writeUintSafe(bc, x.length);
   if (x.length !== 0) {
-    encodeU64FixedArray(bc, x, x.length);
+    writeU64FixedArray(bc, x);
   }
 }
-function encodeU64FixedArrayLE(bc, x, len) {
-  (0, import_assert11.ok)(x.length === len);
-  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+function writeU64FixedArrayLE(bc, x) {
+  writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
 }
-function encodeU64FixedArrayBE(bc, x, len) {
-  (0, import_assert11.ok)(x.length === len);
+function writeU64FixedArrayBE(bc, x) {
   bc.reserve(x.length * U64_BYTE_COUNT);
   for (let i = 0; i < x.length; i++)
-    encodeU64(bc, x[i]);
+    writeU64(bc, x[i]);
 }
 
 // src/codec/u8-clamped-array.ts
-function decodeU8ClampedArray(bc) {
-  return decodeU8ClampedFixedArray(bc, decodeUintSafe(bc));
+function readU8ClampedArray(bc) {
+  return readU8ClampedFixedArray(bc, readUintSafe(bc));
 }
-function encodeU8ClampedArray(bc, x) {
-  encodeUintSafe(bc, x.length);
-  encodeU8ClampedFixedArray(bc, x, x.length);
+function writeU8ClampedArray(bc, x) {
+  writeUintSafe(bc, x.length);
+  writeU8ClampedFixedArray(bc, x);
 }
-function decodeU8ClampedFixedArray(bc, len) {
-  return new Uint8ClampedArray(decodeFixedData(bc, len));
+function readU8ClampedFixedArray(bc, len) {
+  return new Uint8ClampedArray(readFixedData(bc, len));
 }
-function encodeU8ClampedFixedArray(bc, x, len) {
-  encodeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength), len);
+function writeU8ClampedFixedArray(bc, x) {
+  writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
 }
 module.exports = __toCommonJS(src_exports);
 // Annotate the CommonJS export names for ESM import in node:
@@ -1015,90 +993,92 @@ module.exports = __toCommonJS(src_exports);
   BareError,
   ByteCursor,
   Config,
-  decodeBool,
-  decodeData,
-  decodeF32,
-  decodeF32Array,
-  decodeF32FixedArray,
-  decodeF64,
-  decodeF64Array,
-  decodeF64FixedArray,
-  decodeFixedData,
-  decodeI16,
-  decodeI16Array,
-  decodeI16FixedArray,
-  decodeI32,
-  decodeI32Array,
-  decodeI32FixedArray,
-  decodeI64,
-  decodeI64Array,
-  decodeI64FixedArray,
-  decodeI64Safe,
-  decodeI8,
-  decodeI8Array,
-  decodeI8FixedArray,
-  decodeInt,
-  decodeIntSafe,
-  decodeString,
-  decodeU16,
-  decodeU16Array,
-  decodeU16FixedArray,
-  decodeU32,
-  decodeU32Array,
-  decodeU32FixedArray,
-  decodeU64,
-  decodeU64Array,
-  decodeU64FixedArray,
-  decodeU64Safe,
-  decodeU8,
-  decodeU8Array,
-  decodeU8ClampedArray,
-  decodeU8ClampedFixedArray,
-  decodeU8FixedArray,
-  decodeUint,
-  decodeUintSafe,
-  decodeVoid,
-  encodeBool,
-  encodeData,
-  encodeF32,
-  encodeF32Array,
-  encodeF32FixedArray,
-  encodeF64,
-  encodeF64Array,
-  encodeF64FixedArray,
-  encodeFixedData,
-  encodeI16,
-  encodeI16Array,
-  encodeI16FixedArray,
-  encodeI32,
-  encodeI32Array,
-  encodeI32FixedArray,
-  encodeI64,
-  encodeI64Array,
-  encodeI64FixedArray,
-  encodeI64Safe,
-  encodeI8,
-  encodeI8Array,
-  encodeI8FixedArray,
-  encodeInt,
-  encodeIntSafe,
-  encodeString,
-  encodeU16,
-  encodeU16Array,
-  encodeU16FixedArray,
-  encodeU32,
-  encodeU32Array,
-  encodeU32FixedArray,
-  encodeU64,
-  encodeU64Array,
-  encodeU64FixedArray,
-  encodeU64Safe,
-  encodeU8,
-  encodeU8Array,
-  encodeU8ClampedArray,
-  encodeU8ClampedFixedArray,
-  encodeU8FixedArray,
-  encodeUint,
-  encodeUintSafe,
-  encodeVoid
+  readBool,
+  readData,
+  readF32,
+  readF32Array,
+  readF32FixedArray,
+  readF64,
+  readF64Array,
+  readF64FixedArray,
+  readFixedData,
+  readFixedString,
+  readI16,
+  readI16Array,
+  readI16FixedArray,
+  readI32,
+  readI32Array,
+  readI32FixedArray,
+  readI64,
+  readI64Array,
+  readI64FixedArray,
+  readI64Safe,
+  readI8,
+  readI8Array,
+  readI8FixedArray,
+  readInt,
+  readIntSafe,
+  readString,
+  readU16,
+  readU16Array,
+  readU16FixedArray,
+  readU32,
+  readU32Array,
+  readU32FixedArray,
+  readU64,
+  readU64Array,
+  readU64FixedArray,
+  readU64Safe,
+  readU8,
+  readU8Array,
+  readU8ClampedArray,
+  readU8ClampedFixedArray,
+  readU8FixedArray,
+  readUint,
+  readUintSafe,
+  readVoid,
+  writeBool,
+  writeData,
+  writeF32,
+  writeF32Array,
+  writeF32FixedArray,
+  writeF64,
+  writeF64Array,
+  writeF64FixedArray,
+  writeFixedData,
+  writeFixedString,
+  writeI16,
+  writeI16Array,
+  writeI16FixedArray,
+  writeI32,
+  writeI32Array,
+  writeI32FixedArray,
+  writeI64,
+  writeI64Array,
+  writeI64FixedArray,
+  writeI64Safe,
+  writeI8,
+  writeI8Array,
+  writeI8FixedArray,
+  writeInt,
+  writeIntSafe,
+  writeString,
+  writeU16,
+  writeU16Array,
+  writeU16FixedArray,
+  writeU32,
+  writeU32Array,
+  writeU32FixedArray,
+  writeU64,
+  writeU64Array,
+  writeU64FixedArray,
+  writeU64Safe,
+  writeU8,
+  writeU8Array,
+  writeU8ClampedArray,
+  writeU8ClampedFixedArray,
+  writeU8FixedArray,
+  writeUint,
+  writeUintSafe,
+  writeVoid
 });