@bare-ts/lib 0.3.0 → 0.4.1

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 { DEV, assert } 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();

package/dist/codec/u16-array.d.ts

@@ -1,8 +1,8 @@
-import type { ByteCursor } from "../core/index.js";
-export declare const readU16FixedArray: typeof readU16FixedArrayLE;
+import { type ByteCursor } from "../core/byte-cursor.js";
+export declare const readU16FixedArray: typeof readU16FixedArrayLe;
 export declare function readU16Array(bc: ByteCursor): Uint16Array;
-declare function readU16FixedArrayLE(bc: ByteCursor, len: number): Uint16Array;
-export declare const writeU16FixedArray: typeof writeU16FixedArrayLE;
+declare function readU16FixedArrayLe(bc: ByteCursor, len: number): Uint16Array;
+export declare const writeU16FixedArray: typeof writeU16FixedArrayLe;
 export declare function writeU16Array(bc: ByteCursor, x: Uint16Array): void;
-declare function writeU16FixedArrayLE(bc: ByteCursor, x: Uint16Array): void;
+declare function writeU16FixedArrayLe(bc: ByteCursor, x: Uint16Array): void;
 export {};

package/dist/codec/u16-array.js

@@ -1,43 +1,51 @@
-// src/codec/u16-array.ts
-import { U16_BYTE_COUNT } from "../util/constants.js";
-import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
+"use strict";
+import { check, reserve } from "../core/byte-cursor.js";
+import { DEV, assert } from "../util/assert.js";
+import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/constants.js";
+import { isU32 } from "../util/validator.js";
 import { readFixedData } from "./data.js";
-import { readU16, readUintSafe, writeU16, writeUintSafe } from "./primitive.js";
+import {
+  readU16,
+  readUintSafe32,
+  writeU16,
+  writeUintSafe32
+} from "./primitive.js";
 import { writeU8FixedArray } from "./u8-array.js";
-var readU16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readU16FixedArrayLE : readU16FixedArrayBE;
-function readU16Array(bc) {
-  return readU16FixedArray(bc, readUintSafe(bc));
+export const readU16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readU16FixedArrayLe : readU16FixedArrayBe;
+export function readU16Array(bc) {
+  return readU16FixedArray(bc, readUintSafe32(bc));
 }
-function readU16FixedArrayLE(bc, len) {
-  const byteCount = len * U16_BYTE_COUNT;
+function readU16FixedArrayLe(bc, len) {
+  if (DEV) {
+    assert(isU32(len));
+  }
+  const byteCount = len * 2;
   return new Uint16Array(readFixedData(bc, byteCount));
 }
-function readU16FixedArrayBE(bc, len) {
-  bc.check(len * U16_BYTE_COUNT);
+function readU16FixedArrayBe(bc, len) {
+  if (DEV) {
+    assert(isU32(len));
+  }
+  check(bc, len * 2);
   const result = new Uint16Array(len);
-  for (let i = 0; i < len; i++)
+  for (let i = 0; i < len; i++) {
     result[i] = readU16(bc);
+  }
   return result;
 }
-var writeU16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeU16FixedArrayLE : writeU16FixedArrayBE;
-function writeU16Array(bc, x) {
-  writeUintSafe(bc, x.length);
+export const writeU16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeU16FixedArrayLe : writeU16FixedArrayBe;
+export function writeU16Array(bc, x) {
+  writeUintSafe32(bc, x.length);
   if (x.length !== 0) {
     writeU16FixedArray(bc, x);
   }
 }
-function writeU16FixedArrayLE(bc, x) {
+function writeU16FixedArrayLe(bc, x) {
   writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
 }
-function writeU16FixedArrayBE(bc, x) {
-  bc.reserve(x.length * U16_BYTE_COUNT);
-  for (let i = 0; i < x.length; i++)
+function writeU16FixedArrayBe(bc, x) {
+  reserve(bc, x.length * 2);
+  for (let i = 0; i < x.length; i++) {
     writeU16(bc, x[i]);
+  }
 }
-export {
-  readU16Array,
-  readU16FixedArray,
-  writeU16Array,
-  writeU16FixedArray
-};
-//# sourceMappingURL=u16-array.js.map

package/dist/codec/u32-array.d.ts

@@ -1,8 +1,8 @@
-import type { ByteCursor } from "../core/index.js";
-export declare const readU32FixedArray: typeof readU32FixedArrayLE;
+import { type ByteCursor } from "../core/byte-cursor.js";
+export declare const readU32FixedArray: typeof readU32FixedArrayLe;
 export declare function readU32Array(bc: ByteCursor): Uint32Array;
-declare function readU32FixedArrayLE(bc: ByteCursor, len: number): Uint32Array;
-export declare const writeU32FixedArray: typeof writeU32FixedArrayLE;
+declare function readU32FixedArrayLe(bc: ByteCursor, len: number): Uint32Array;
+export declare const writeU32FixedArray: typeof writeU32FixedArrayLe;
 export declare function writeU32Array(bc: ByteCursor, x: Uint32Array): void;
-declare function writeU32FixedArrayLE(bc: ByteCursor, x: Uint32Array): void;
+declare function writeU32FixedArrayLe(bc: ByteCursor, x: Uint32Array): void;
 export {};

package/dist/codec/u32-array.js

@@ -1,43 +1,51 @@
-// src/codec/u32-array.ts
-import { U32_BYTE_COUNT } from "../util/constants.js";
-import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
+"use strict";
+import { check, reserve } from "../core/byte-cursor.js";
+import { DEV, assert } from "../util/assert.js";
+import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/constants.js";
+import { isU32 } from "../util/validator.js";
 import { readFixedData } from "./data.js";
-import { readU32, readUintSafe, writeU32, writeUintSafe } from "./primitive.js";
+import {
+  readU32,
+  readUintSafe32,
+  writeU32,
+  writeUintSafe32
+} from "./primitive.js";
 import { writeU8FixedArray } from "./u8-array.js";
-var readU32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readU32FixedArrayLE : readU32FixedArrayBE;
-function readU32Array(bc) {
-  return readU32FixedArray(bc, readUintSafe(bc));
+export const readU32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readU32FixedArrayLe : readU32FixedArrayBe;
+export function readU32Array(bc) {
+  return readU32FixedArray(bc, readUintSafe32(bc));
 }
-function readU32FixedArrayLE(bc, len) {
-  const byteCount = len * U32_BYTE_COUNT;
+function readU32FixedArrayLe(bc, len) {
+  if (DEV) {
+    assert(isU32(len));
+  }
+  const byteCount = len * 4;
   return new Uint32Array(readFixedData(bc, byteCount));
 }
-function readU32FixedArrayBE(bc, len) {
-  bc.check(len * U32_BYTE_COUNT);
+function readU32FixedArrayBe(bc, len) {
+  if (DEV) {
+    assert(isU32(len));
+  }
+  check(bc, len * 4);
   const result = new Uint32Array(len);
-  for (let i = 0; i < len; i++)
+  for (let i = 0; i < len; i++) {
     result[i] = readU32(bc);
+  }
   return result;
 }
-var writeU32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeU32FixedArrayLE : writeU32FixedArrayBE;
-function writeU32Array(bc, x) {
-  writeUintSafe(bc, x.length);
+export const writeU32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeU32FixedArrayLe : writeU32FixedArrayBe;
+export function writeU32Array(bc, x) {
+  writeUintSafe32(bc, x.length);
   if (x.length !== 0) {
     writeU32FixedArray(bc, x);
   }
 }
-function writeU32FixedArrayLE(bc, x) {
+function writeU32FixedArrayLe(bc, x) {
   writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
 }
-function writeU32FixedArrayBE(bc, x) {
-  bc.reserve(x.length * U32_BYTE_COUNT);
-  for (let i = 0; i < x.length; i++)
+function writeU32FixedArrayBe(bc, x) {
+  reserve(bc, x.length * 4);
+  for (let i = 0; i < x.length; i++) {
     writeU32(bc, x[i]);
+  }
 }
-export {
-  readU32Array,
-  readU32FixedArray,
-  writeU32Array,
-  writeU32FixedArray
-};
-//# sourceMappingURL=u32-array.js.map

package/dist/codec/u64-array.d.ts

@@ -1,8 +1,8 @@
-import type { ByteCursor } from "../core/index.js";
-export declare const readU64FixedArray: typeof readU64FixedArrayLE;
+import { type ByteCursor } from "../core/byte-cursor.js";
+export declare const readU64FixedArray: typeof readU64FixedArrayLe;
 export declare function readU64Array(bc: ByteCursor): BigUint64Array;
-declare function readU64FixedArrayLE(bc: ByteCursor, len: number): BigUint64Array;
-export declare const writeU64FixedArray: typeof writeU64FixedArrayLE;
+declare function readU64FixedArrayLe(bc: ByteCursor, len: number): BigUint64Array;
+export declare const writeU64FixedArray: typeof writeU64FixedArrayLe;
 export declare function writeU64Array(bc: ByteCursor, x: BigUint64Array): void;
-declare function writeU64FixedArrayLE(bc: ByteCursor, x: BigUint64Array): void;
+declare function writeU64FixedArrayLe(bc: ByteCursor, x: BigUint64Array): void;
 export {};

package/dist/codec/u64-array.js

@@ -1,43 +1,51 @@
-// src/codec/u64-array.ts
-import { U64_BYTE_COUNT } from "../util/constants.js";
-import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
+"use strict";
+import { check, reserve } from "../core/byte-cursor.js";
+import { DEV, assert } from "../util/assert.js";
+import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/constants.js";
+import { isU32 } from "../util/validator.js";
 import { readFixedData } from "./data.js";
-import { readU64, readUintSafe, writeU64, writeUintSafe } from "./primitive.js";
+import {
+  readU64,
+  readUintSafe32,
+  writeU64,
+  writeUintSafe32
+} from "./primitive.js";
 import { writeU8FixedArray } from "./u8-array.js";
-var readU64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readU64FixedArrayLE : readU64FixedArrayBE;
-function readU64Array(bc) {
-  return readU64FixedArray(bc, readUintSafe(bc));
+export const readU64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readU64FixedArrayLe : readU64FixedArrayBe;
+export function readU64Array(bc) {
+  return readU64FixedArray(bc, readUintSafe32(bc));
 }
-function readU64FixedArrayLE(bc, len) {
-  const byteCount = len * U64_BYTE_COUNT;
+function readU64FixedArrayLe(bc, len) {
+  if (DEV) {
+    assert(isU32(len));
+  }
+  const byteCount = len * 8;
   return new BigUint64Array(readFixedData(bc, byteCount));
 }
-function readU64FixedArrayBE(bc, len) {
-  bc.check(len * U64_BYTE_COUNT);
+function readU64FixedArrayBe(bc, len) {
+  if (DEV) {
+    assert(isU32(len));
+  }
+  check(bc, len * 8);
   const result = new BigUint64Array(len);
-  for (let i = 0; i < len; i++)
+  for (let i = 0; i < len; i++) {
     result[i] = readU64(bc);
+  }
   return result;
 }
-var writeU64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeU64FixedArrayLE : writeU64FixedArrayBE;
-function writeU64Array(bc, x) {
-  writeUintSafe(bc, x.length);
+export const writeU64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeU64FixedArrayLe : writeU64FixedArrayBe;
+export function writeU64Array(bc, x) {
+  writeUintSafe32(bc, x.length);
   if (x.length !== 0) {
     writeU64FixedArray(bc, x);
   }
 }
-function writeU64FixedArrayLE(bc, x) {
+function writeU64FixedArrayLe(bc, x) {
   writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
 }
-function writeU64FixedArrayBE(bc, x) {
-  bc.reserve(x.length * U64_BYTE_COUNT);
-  for (let i = 0; i < x.length; i++)
+function writeU64FixedArrayBe(bc, x) {
+  reserve(bc, x.length * 8);
+  for (let i = 0; i < x.length; i++) {
     writeU64(bc, x[i]);
+  }
 }
-export {
-  readU64Array,
-  readU64FixedArray,
-  writeU64Array,
-  writeU64FixedArray
-};
-//# sourceMappingURL=u64-array.js.map

package/dist/codec/u8-array.d.ts

@@ -1,5 +1,11 @@
-import type { ByteCursor } from "../core/index.js";
+import { type ByteCursor } from "../core/byte-cursor.js";
 export declare function readU8Array(bc: ByteCursor): Uint8Array;
 export declare function writeU8Array(bc: ByteCursor, x: Uint8Array): void;
 export declare function readU8FixedArray(bc: ByteCursor, len: number): Uint8Array;
 export declare function writeU8FixedArray(bc: ByteCursor, x: Uint8Array): void;
+/**
+ * Advance `bc` by `len` bytes and return a view of the read bytes.
+ *
+ * WARNING: The returned array should not be modified.
+ */
+export declare function readUnsafeU8FixedArray(bc: ByteCursor, len: number): Uint8Array;

package/dist/codec/u8-array.js

@@ -1,27 +1,32 @@
-// src/codec/u8-array.ts
-import { readUintSafe, writeUintSafe } from "./primitive.js";
-function readU8Array(bc) {
-  return readU8FixedArray(bc, readUintSafe(bc));
+"use strict";
+import { check, reserve } from "../core/byte-cursor.js";
+import { DEV, assert } from "../util/assert.js";
+import { isU32 } from "../util/validator.js";
+import { readUintSafe32, writeUintSafe32 } from "./primitive.js";
+export function readU8Array(bc) {
+  return readU8FixedArray(bc, readUintSafe32(bc));
 }
-function writeU8Array(bc, x) {
-  writeUintSafe(bc, x.length);
+export function writeU8Array(bc, x) {
+  writeUintSafe32(bc, x.length);
   writeU8FixedArray(bc, x);
 }
-function readU8FixedArray(bc, len) {
-  return bc.read(len).slice();
+export function readU8FixedArray(bc, len) {
+  return readUnsafeU8FixedArray(bc, len).slice();
 }
-function writeU8FixedArray(bc, x) {
+export function writeU8FixedArray(bc, x) {
   const len = x.length;
   if (len !== 0) {
-    bc.reserve(len);
+    reserve(bc, len);
     bc.bytes.set(x, bc.offset);
     bc.offset += len;
   }
 }
-export {
-  readU8Array,
-  readU8FixedArray,
-  writeU8Array,
-  writeU8FixedArray
-};
-//# sourceMappingURL=u8-array.js.map
+export function readUnsafeU8FixedArray(bc, len) {
+  if (DEV) {
+    assert(isU32(len));
+  }
+  check(bc, len);
+  const offset = bc.offset;
+  bc.offset += len;
+  return bc.bytes.subarray(offset, offset + len);
+}

package/dist/codec/u8-clamped-array.d.ts

@@ -1,4 +1,4 @@
-import type { ByteCursor } from "../core/index.js";
+import type { ByteCursor } from "../core/byte-cursor.js";
 export declare function readU8ClampedArray(bc: ByteCursor): Uint8ClampedArray;
 export declare function writeU8ClampedArray(bc: ByteCursor, x: Uint8ClampedArray): void;
 export declare function readU8ClampedFixedArray(bc: ByteCursor, len: number): Uint8ClampedArray;

package/dist/codec/u8-clamped-array.js

@@ -1,24 +1,22 @@
-// src/codec/u8-clamped-array.ts
+"use strict";
+import { DEV, assert } from "../util/assert.js";
+import { isU32 } from "../util/validator.js";
 import { readFixedData } from "./data.js";
-import { readUintSafe, writeUintSafe } from "./primitive.js";
+import { readUintSafe32, writeUintSafe32 } from "./primitive.js";
 import { writeU8FixedArray } from "./u8-array.js";
-function readU8ClampedArray(bc) {
-  return readU8ClampedFixedArray(bc, readUintSafe(bc));
+export function readU8ClampedArray(bc) {
+  return readU8ClampedFixedArray(bc, readUintSafe32(bc));
 }
-function writeU8ClampedArray(bc, x) {
-  writeUintSafe(bc, x.length);
+export function writeU8ClampedArray(bc, x) {
+  writeUintSafe32(bc, x.length);
   writeU8ClampedFixedArray(bc, x);
 }
-function readU8ClampedFixedArray(bc, len) {
+export function readU8ClampedFixedArray(bc, len) {
+  if (DEV) {
+    assert(isU32(len));
+  }
   return new Uint8ClampedArray(readFixedData(bc, len));
 }
-function writeU8ClampedFixedArray(bc, x) {
+export function writeU8ClampedFixedArray(bc, x) {
   writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
 }
-export {
-  readU8ClampedArray,
-  readU8ClampedFixedArray,
-  writeU8ClampedArray,
-  writeU8ClampedFixedArray
-};
-//# sourceMappingURL=u8-clamped-array.js.map

package/dist/core/bare-error.d.ts

@@ -1,5 +1,8 @@
+/**
+ * @sealed
+ */
 export declare class BareError extends Error {
-    readonly name: "BareError";
+    name: string;
     readonly cause: unknown;
     readonly issue: string;
     readonly offset: number;

package/dist/core/bare-error.js

@@ -1,14 +1,10 @@
-// src/core/bare-error.ts
-var BareError = class extends Error {
+"use strict";
+export class BareError extends Error {
   constructor(offset, issue, opts) {
     super(`(byte:${offset}) ${issue}`);
     this.name = "BareError";
     this.issue = issue;
     this.offset = offset;
-    this.cause = opts == null ? void 0 : opts.cause;
+    this.cause = opts?.cause;
   }
-};
-export {
-  BareError
-};
-//# sourceMappingURL=bare-error.js.map
+}

package/dist/core/byte-cursor.d.ts

@@ -1,16 +1,20 @@
 import type { Config } from "./config.js";
 /**
- * @invariant bytes.buffer === view.buffer
- * @invariant bytes.byteOffset === view.byteOffset
- * @invariant bytes.byteLength === view.byteLength
- * @invariant 0 <= offset <= bytes.byteLength
- * @invariant bytes.byteLength <= config.maxBufferLength
+ * @invariant `bytes.buffer === view.buffer`
+ * @invariant `bytes.byteOffset === view.byteOffset`
+ * @invariant `bytes.byteLength === view.byteLength`
+ * @invariant `0 <= offset <= bytes.byteLength`
+ * @invariant `bytes.byteLength <= config.maxBufferLength`
  *
+ * ```txt
  * |         {bytes,view}.buffer                      |
  *        |          bytes                    |
  *        |          view                     |
  *        |<------ offset ------>|
  *        |<----------- config.maxBufferLength ------------>|
+ * ```
+ *
+ * @sealed
  */
 export declare class ByteCursor {
     bytes: Uint8Array;
@@ -21,29 +25,19 @@ export declare class ByteCursor {
     offset: number;
     view: DataView;
     /**
-     * @param bytes read and/or write buffer
-     * @param config runtime configuration
-     * @throw BareError when the buffer exceeds the maximum allowed length
-     *  `config.maxBufferLength`
+     * @throws {BareError} Buffer exceeds `config.maxBufferLength`
      */
     constructor(bytes: Uint8Array, config: Config);
-    /**
-     * @param min number of needed bytes
-     * @throw BareError when there is not enough bytes
-     */
-    check(min: number): void;
-    /**
-     * @param min number of bytes to reserve
-     * @throw BareError when the buffer exceeds the maximum allowed length
-     *  `config.maxBufferLength`
-     */
-    reserve(min: number): void;
-    /**
-     * Advance cursor by {@code len} bytes and return a view of the read bytes.
-     * The returned array should not be modified.
-     *
-     * @param len number of bytes to read
-     * @returns read bytes
-     */
-    read(len: number): Uint8Array;
 }
+/**
+ * Check that `min` number of bytes are available.
+ *
+ * @throws {BareError} bytes are missing.
+ */
+export declare function check(bc: ByteCursor, min: number): void;
+/**
+ * Reserve `min` number of bytes.
+ *
+ * @throws {BareError} Buffer exceeds `config.maxBufferLength`.
+ */
+export declare function reserve(bc: ByteCursor, min: number): void;