@bare-ts/lib 0.1.1 → 0.2.0

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

@@ -1,8 +1,8 @@
 import type { ByteCursor } from "../core/index.js";
-export declare const decodeU16FixedArray: typeof decodeU16FixedArrayLE;
-export declare function decodeU16Array(bc: ByteCursor): Uint16Array;
-declare function decodeU16FixedArrayLE(bc: ByteCursor, len: number): Uint16Array;
-export declare const encodeU16FixedArray: typeof encodeU16FixedArrayLE;
-export declare function encodeU16Array(bc: ByteCursor, x: Uint16Array): void;
-declare function encodeU16FixedArrayLE(bc: ByteCursor, x: Uint16Array, len: number): void;
+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;
+export declare function writeU16Array(bc: ByteCursor, x: Uint16Array): void;
+declare function writeU16FixedArrayLE(bc: ByteCursor, x: Uint16Array): void;
 export {};

package/dist/codec/u16-array.js

@@ -1,50 +1,43 @@
 // src/codec/u16-array.ts
-import { ok as assert } from "assert";
 import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
-import { decodeFixedData } from "./data.js";
-import {
-  decodeU16,
-  decodeUintSafe,
-  encodeU16,
-  encodeUintSafe
-} from "./primitive.js";
+import { readFixedData } from "./data.js";
+import { readU16, readUintSafe, writeU16, writeUintSafe } from "./primitive.js";
+import { writeU8FixedArray } from "./u8-array.js";
 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) {
-  assert(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) {
-  assert(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]);
 }
 export {
-  decodeU16Array,
-  decodeU16FixedArray,
-  encodeU16Array,
-  encodeU16FixedArray
+  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 decodeU32FixedArray: typeof decodeU32FixedArrayLE;
-export declare function decodeU32Array(bc: ByteCursor): Uint32Array;
-declare function decodeU32FixedArrayLE(bc: ByteCursor, len: number): Uint32Array;
-export declare const encodeU32FixedArray: typeof encodeU32FixedArrayLE;
-export declare function encodeU32Array(bc: ByteCursor, x: Uint32Array): void;
-declare function encodeU32FixedArrayLE(bc: ByteCursor, x: Uint32Array, len: number): void;
+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;
+export declare function writeU32Array(bc: ByteCursor, x: Uint32Array): void;
+declare function writeU32FixedArrayLE(bc: ByteCursor, x: Uint32Array): void;
 export {};

package/dist/codec/u32-array.js

@@ -1,50 +1,43 @@
 // src/codec/u32-array.ts
-import { ok as assert } from "assert";
 import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
-import { decodeFixedData } from "./data.js";
-import {
-  decodeU32,
-  decodeUintSafe,
-  encodeU32,
-  encodeUintSafe
-} from "./primitive.js";
+import { readFixedData } from "./data.js";
+import { readU32, readUintSafe, writeU32, writeUintSafe } from "./primitive.js";
+import { writeU8FixedArray } from "./u8-array.js";
 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) {
-  assert(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) {
-  assert(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]);
 }
 export {
-  decodeU32Array,
-  decodeU32FixedArray,
-  encodeU32Array,
-  encodeU32FixedArray
+  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 decodeU64FixedArray: typeof decodeU64FixedArrayLE;
-export declare function decodeU64Array(bc: ByteCursor): BigUint64Array;
-declare function decodeU64FixedArrayLE(bc: ByteCursor, len: number): BigUint64Array;
-export declare const encodeU64FixedArray: typeof encodeU64FixedArrayLE;
-export declare function encodeU64Array(bc: ByteCursor, x: BigUint64Array): void;
-declare function encodeU64FixedArrayLE(bc: ByteCursor, x: BigUint64Array, len: number): void;
+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;
+export declare function writeU64Array(bc: ByteCursor, x: BigUint64Array): void;
+declare function writeU64FixedArrayLE(bc: ByteCursor, x: BigUint64Array): void;
 export {};

package/dist/codec/u64-array.js

@@ -1,50 +1,43 @@
 // src/codec/u64-array.ts
-import { ok as assert } from "assert";
 import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
-import { decodeFixedData } from "./data.js";
-import {
-  decodeU64,
-  decodeUintSafe,
-  encodeU64,
-  encodeUintSafe
-} from "./primitive.js";
+import { readFixedData } from "./data.js";
+import { readU64, readUintSafe, writeU64, writeUintSafe } from "./primitive.js";
+import { writeU8FixedArray } from "./u8-array.js";
 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) {
-  assert(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) {
-  assert(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]);
 }
 export {
-  decodeU64Array,
-  decodeU64FixedArray,
-  encodeU64Array,
-  encodeU64FixedArray
+  readU64Array,
+  readU64FixedArray,
+  writeU64Array,
+  writeU64FixedArray
 };
 //# sourceMappingURL=u64-array.js.map

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

@@ -1,5 +1,5 @@
 import type { ByteCursor } from "../core/index.js";
-export declare function decodeU8Array(bc: ByteCursor): Uint8Array;
-export declare function encodeU8Array(bc: ByteCursor, x: Uint8Array): void;
-export declare function decodeU8FixedArray(bc: ByteCursor, len: number): Uint8Array;
-export declare function encodeU8FixedArray(bc: ByteCursor, x: Uint8Array, len: number): void;
+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;

package/dist/codec/u8-array.js

@@ -1,25 +1,27 @@
 // src/codec/u8-array.ts
-import { ok as assert } from "assert";
-import { decodeUintSafe, encodeUintSafe } from "./primitive.js";
-function decodeU8Array(bc) {
-  const len = decodeUintSafe(bc);
-  return bc.read(len).slice();
+import { readUintSafe, writeUintSafe } from "./primitive.js";
+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) {
-  assert(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;
+  }
 }
 export {
-  decodeU8Array,
-  decodeU8FixedArray,
-  encodeU8Array,
-  encodeU8FixedArray
+  readU8Array,
+  readU8FixedArray,
+  writeU8Array,
+  writeU8FixedArray
 };
 //# sourceMappingURL=u8-array.js.map

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

@@ -1,5 +1,5 @@
 import type { ByteCursor } from "../core/index.js";
-export declare function decodeU8ClampedArray(bc: ByteCursor): Uint8ClampedArray;
-export declare function encodeU8ClampedArray(bc: ByteCursor, x: Uint8ClampedArray): void;
-export declare function decodeU8ClampedFixedArray(bc: ByteCursor, len: number): Uint8ClampedArray;
-export declare function encodeU8ClampedFixedArray(bc: ByteCursor, x: Uint8ClampedArray, len: number): void;
+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;
+export declare function writeU8ClampedFixedArray(bc: ByteCursor, x: Uint8ClampedArray): void;

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

@@ -1,24 +1,24 @@
 // src/codec/u8-clamped-array.ts
-import { decodeFixedData } from "./data.js";
-import { decodeUintSafe, encodeUintSafe } from "./primitive.js";
-import { encodeU8FixedArray } from "./u8-array.js";
-function decodeU8ClampedArray(bc) {
-  return decodeU8ClampedFixedArray(bc, decodeUintSafe(bc));
+import { readFixedData } from "./data.js";
+import { readUintSafe, writeUintSafe } from "./primitive.js";
+import { writeU8FixedArray } from "./u8-array.js";
+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));
 }
 export {
-  decodeU8ClampedArray,
-  decodeU8ClampedFixedArray,
-  encodeU8ClampedArray,
-  encodeU8ClampedFixedArray
+  readU8ClampedArray,
+  readU8ClampedFixedArray,
+  writeU8ClampedArray,
+  writeU8ClampedFixedArray
 };
 //# sourceMappingURL=u8-clamped-array.js.map

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

@@ -1,9 +1,32 @@
 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
+ *
+ * |         {bytes,view}.buffer                      |
+ *        |          bytes                    |
+ *        |          view                     |
+ *        |<------ offset ------>|
+ *        |<----------- config.maxBufferLength ------------>|
+ */
 export declare class ByteCursor {
+    bytes: Uint8Array;
     readonly config: Config;
+    /**
+     * Read and write Offset in {@link view} and {@link bytes}
+     */
     offset: number;
     view: DataView;
-    constructor(bytes: ArrayBuffer | Uint8Array, config: Config);
+    /**
+     * @param bytes read and/or write buffer
+     * @param config runtime configuration
+     * @throw BareError when the buffer exceeds the maximum allowed length
+     *  `config.maxBufferLength`
+     */
+    constructor(bytes: Uint8Array, config: Config);
     /**
      * @param min number of needed bytes
      * @throw BareError when there is not enough bytes
@@ -11,6 +34,8 @@ export declare class ByteCursor {
     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;
     /**
@@ -21,11 +46,4 @@ export declare class ByteCursor {
      * @returns read bytes
      */
     read(len: number): Uint8Array;
-    /**
-     * Write {@code bytes} in the buffer and advance cursor by
-     *  {@code bytes.length}
-     *
-     * @param bytes bytes to copy
-     */
-    write(bytes: Uint8Array): void;
 }

package/dist/core/byte-cursor.js

@@ -1,49 +1,39 @@
 // src/core/byte-cursor.ts
-import { ok as assert } from "assert";
-import { BareError } from "../core/bare-error.js";
+import { BareError } from "./bare-error.js";
 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;
-      assert(bytes.length === view.byteOffset + view.byteLength, "un-growable buffer");
-      assert(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);
   }
 };
 export {