@bare-ts/lib 0.1.1 → 0.2.0

package/dist/codec/data.d.ts

@@ -1,5 +1,5 @@
 import type { ByteCursor } from "../core/index.js";
-export declare function decodeData(bc: ByteCursor): ArrayBuffer;
-export declare function encodeData(bc: ByteCursor, x: ArrayBuffer): void;
-export declare function decodeFixedData(bc: ByteCursor, len: number): ArrayBuffer;
-export declare function encodeFixedData(bc: ByteCursor, x: ArrayBuffer, len: number): void;
+export declare function readData(bc: ByteCursor): ArrayBuffer;
+export declare function writeData(bc: ByteCursor, x: ArrayBuffer): void;
+export declare function readFixedData(bc: ByteCursor, len: number): ArrayBuffer;
+export declare function writeFixedData(bc: ByteCursor, x: ArrayBuffer): void;

package/dist/codec/data.js

@@ -1,26 +1,26 @@
 // src/codec/data.ts
 import {
-  decodeU8Array,
-  decodeU8FixedArray,
-  encodeU8Array,
-  encodeU8FixedArray
+  readU8Array,
+  readU8FixedArray,
+  writeU8Array,
+  writeU8FixedArray
 } from "./u8-array.js";
-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));
 }
 export {
-  decodeData,
-  decodeFixedData,
-  encodeData,
-  encodeFixedData
+  readData,
+  readFixedData,
+  writeData,
+  writeFixedData
 };
 //# sourceMappingURL=data.js.map

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

@@ -1,14 +1,14 @@
 import type { ByteCursor } from "../core/index.js";
-export declare const decodeF32FixedArray: typeof decodeF32FixedArrayLE;
-declare function decodeF32FixedArrayLE(bc: ByteCursor, len: number): Float32Array;
-export declare const encodeF32FixedArray: typeof encodeF32FixedArrayLE;
-declare function encodeF32FixedArrayLE(bc: ByteCursor, x: Float32Array, len: number): void;
-export declare function decodeF32Array(bc: ByteCursor): Float32Array;
-export declare function encodeF32Array(bc: ByteCursor, x: Float32Array): void;
-export declare const decodeF64FixedArray: typeof decodeF64FixedArrayLE;
-declare function decodeF64FixedArrayLE(bc: ByteCursor, len: number): Float64Array;
-export declare const encodeF64FixedArray: typeof encodeF64FixedArrayLE;
-declare function encodeF64FixedArrayLE(bc: ByteCursor, x: Float64Array, len: number): void;
-export declare function decodeF64Array(bc: ByteCursor): Float64Array;
-export declare function encodeF64Array(bc: ByteCursor, x: Float64Array): void;
+export declare const readF32FixedArray: typeof readF32FixedArrayLE;
+declare function readF32FixedArrayLE(bc: ByteCursor, len: number): Float32Array;
+export declare const writeF32FixedArray: typeof writeF32FixedArrayLE;
+declare function writeF32FixedArrayLE(bc: ByteCursor, x: Float32Array): void;
+export declare function readF32Array(bc: ByteCursor): Float32Array;
+export declare function writeF32Array(bc: ByteCursor, x: Float32Array): void;
+export declare const readF64FixedArray: typeof readF64FixedArrayLE;
+declare function readF64FixedArrayLE(bc: ByteCursor, len: number): Float64Array;
+export declare const writeF64FixedArray: typeof writeF64FixedArrayLE;
+declare function writeF64FixedArrayLE(bc: ByteCursor, x: Float64Array): void;
+export declare function readF64Array(bc: ByteCursor): Float64Array;
+export declare function writeF64Array(bc: ByteCursor, x: Float64Array): void;
 export {};

package/dist/codec/float-array.js

@@ -2,98 +2,95 @@
 import { ok as assert } from "assert";
 import { BareError } from "../core/index.js";
 import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
-import { decodeFixedData } from "./data.js";
+import { readFixedData } from "./data.js";
 import {
-  decodeF32,
-  decodeF64,
-  decodeUintSafe,
-  encodeF32,
-  encodeF64,
-  encodeUintSafe
+  readF32,
+  readF64,
+  readUintSafe,
+  writeF32,
+  writeF64,
+  writeUintSafe
 } from "./primitive.js";
+import { writeU8FixedArray } from "./u8-array.js";
 var NAN_NOT_ALLOWED = "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_ALLOWED);
   }
   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) {
-  assert(x.length === len);
+var writeF32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeF32FixedArrayLE : writeF32FixedArrayBE;
+function writeF32FixedArrayLE(bc, x) {
   assert(!x.every(Number.isNaN), NAN_NOT_ALLOWED);
-  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+  writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
 }
-function encodeF32FixedArrayBE(bc, val, len) {
-  assert(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_ALLOWED);
   }
   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) {
-  assert(x.length === len);
+var writeF64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeF64FixedArrayLE : writeF64FixedArrayBE;
+function writeF64FixedArrayLE(bc, x) {
   assert(!x.every(Number.isNaN), NAN_NOT_ALLOWED);
-  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+  writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
 }
-function encodeF64FixedArrayBE(bc, x, len) {
-  assert(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);
   }
 }
 export {
-  decodeF32Array,
-  decodeF32FixedArray,
-  decodeF64Array,
-  decodeF64FixedArray,
-  encodeF32Array,
-  encodeF32FixedArray,
-  encodeF64Array,
-  encodeF64FixedArray
+  readF32Array,
+  readF32FixedArray,
+  readF64Array,
+  readF64FixedArray,
+  writeF32Array,
+  writeF32FixedArray,
+  writeF64Array,
+  writeF64FixedArray
 };
 //# sourceMappingURL=float-array.js.map

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

@@ -1,8 +1,8 @@
 import type { ByteCursor } from "../core/index.js";
-export declare const decodeI16FixedArray: typeof decodeI16FixedArrayLE;
-export declare function decodeI16Array(bc: ByteCursor): Int16Array;
-declare function decodeI16FixedArrayLE(bc: ByteCursor, len: number): Int16Array;
-export declare const encodeI16FixedArray: typeof encodeI16FixedArrayLE;
-export declare function encodeI16Array(bc: ByteCursor, x: Int16Array): void;
-declare function encodeI16FixedArrayLE(bc: ByteCursor, x: Int16Array, len: number): void;
+export declare const readI16FixedArray: typeof readI16FixedArrayLE;
+export declare function readI16Array(bc: ByteCursor): Int16Array;
+declare function readI16FixedArrayLE(bc: ByteCursor, len: number): Int16Array;
+export declare const writeI16FixedArray: typeof writeI16FixedArrayLE;
+export declare function writeI16Array(bc: ByteCursor, x: Int16Array): void;
+declare function writeI16FixedArrayLE(bc: ByteCursor, x: Int16Array): void;
 export {};

package/dist/codec/i16-array.js

@@ -1,50 +1,43 @@
 // src/codec/i16-array.ts
-import { ok as assert } from "assert";
 import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
-import { decodeFixedData } from "./data.js";
-import {
-  decodeI16,
-  decodeUintSafe,
-  encodeI16,
-  encodeUintSafe
-} from "./primitive.js";
+import { readFixedData } from "./data.js";
+import { readI16, readUintSafe, writeI16, writeUintSafe } from "./primitive.js";
+import { writeU8FixedArray } from "./u8-array.js";
 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) {
-  assert(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) {
-  assert(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]);
 }
 export {
-  decodeI16Array,
-  decodeI16FixedArray,
-  encodeI16Array,
-  encodeI16FixedArray
+  readI16Array,
+  readI16FixedArray,
+  writeI16Array,
+  writeI16FixedArray
 };
 //# sourceMappingURL=i16-array.js.map

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

@@ -1,8 +1,8 @@
 import type { ByteCursor } from "../core/index.js";
-export declare const decodeI32FixedArray: typeof decodeI32FixedArrayLE;
-export declare function decodeI32Array(bc: ByteCursor): Int32Array;
-declare function decodeI32FixedArrayLE(bc: ByteCursor, len: number): Int32Array;
-export declare const encodeI32FixedArray: typeof encodeI32FixedArrayLE;
-export declare function encodeI32Array(bc: ByteCursor, x: Int32Array): void;
-declare function encodeI32FixedArrayLE(bc: ByteCursor, x: Int32Array, len: number): void;
+export declare const readI32FixedArray: typeof readI32FixedArrayLE;
+export declare function readI32Array(bc: ByteCursor): Int32Array;
+declare function readI32FixedArrayLE(bc: ByteCursor, len: number): Int32Array;
+export declare const writeI32FixedArray: typeof writeI32FixedArrayLE;
+export declare function writeI32Array(bc: ByteCursor, x: Int32Array): void;
+declare function writeI32FixedArrayLE(bc: ByteCursor, x: Int32Array): void;
 export {};

package/dist/codec/i32-array.js

@@ -1,50 +1,43 @@
 // src/codec/i32-array.ts
-import { ok as assert } from "assert";
 import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
-import { decodeFixedData } from "./data.js";
-import {
-  decodeI32,
-  decodeUintSafe,
-  encodeI32,
-  encodeUintSafe
-} from "./primitive.js";
+import { readFixedData } from "./data.js";
+import { readI32, readUintSafe, writeI32, writeUintSafe } from "./primitive.js";
+import { writeU8FixedArray } from "./u8-array.js";
 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) {
-  assert(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) {
-  assert(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]);
 }
 export {
-  decodeI32Array,
-  decodeI32FixedArray,
-  encodeI32Array,
-  encodeI32FixedArray
+  readI32Array,
+  readI32FixedArray,
+  writeI32Array,
+  writeI32FixedArray
 };
 //# sourceMappingURL=i32-array.js.map

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

@@ -1,8 +1,8 @@
 import type { ByteCursor } from "../core/index.js";
-export declare const decodeI64FixedArray: typeof decodeI64FixedArrayLE;
-export declare function decodeI64Array(bc: ByteCursor): BigInt64Array;
-declare function decodeI64FixedArrayLE(bc: ByteCursor, len: number): BigInt64Array;
-export declare const encodeI64FixedArray: typeof encodeI64FixedArrayLE;
-export declare function encodeI64Array(bc: ByteCursor, x: BigInt64Array): void;
-declare function encodeI64FixedArrayLE(bc: ByteCursor, x: BigInt64Array, len: number): void;
+export declare const readI64FixedArray: typeof readI64FixedArrayLE;
+export declare function readI64Array(bc: ByteCursor): BigInt64Array;
+declare function readI64FixedArrayLE(bc: ByteCursor, len: number): BigInt64Array;
+export declare const writeI64FixedArray: typeof writeI64FixedArrayLE;
+export declare function writeI64Array(bc: ByteCursor, x: BigInt64Array): void;
+declare function writeI64FixedArrayLE(bc: ByteCursor, x: BigInt64Array): void;
 export {};

package/dist/codec/i64-array.js

@@ -1,50 +1,43 @@
 // src/codec/i64-array.ts
-import { ok as assert } from "assert";
 import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
-import { decodeFixedData } from "./data.js";
-import {
-  decodeI64,
-  decodeUintSafe,
-  encodeI64,
-  encodeUintSafe
-} from "./primitive.js";
+import { readFixedData } from "./data.js";
+import { readI64, readUintSafe, writeI64, writeUintSafe } from "./primitive.js";
+import { writeU8FixedArray } from "./u8-array.js";
 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) {
-  assert(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) {
-  assert(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]);
 }
 export {
-  decodeI64Array,
-  decodeI64FixedArray,
-  encodeI64Array,
-  encodeI64FixedArray
+  readI64Array,
+  readI64FixedArray,
+  writeI64Array,
+  writeI64FixedArray
 };
 //# sourceMappingURL=i64-array.js.map

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

@@ -1,5 +1,5 @@
 import type { ByteCursor } from "../core/index.js";
-export declare function decodeI8Array(bc: ByteCursor): Int8Array;
-export declare function encodeI8Array(bc: ByteCursor, x: Int8Array): void;
-export declare function decodeI8FixedArray(bc: ByteCursor, len: number): Int8Array;
-export declare function encodeI8FixedArray(bc: ByteCursor, x: Int8Array, len: number): void;
+export declare function readI8Array(bc: ByteCursor): Int8Array;
+export declare function writeI8Array(bc: ByteCursor, x: Int8Array): void;
+export declare function readI8FixedArray(bc: ByteCursor, len: number): Int8Array;
+export declare function writeI8FixedArray(bc: ByteCursor, x: Int8Array): void;

package/dist/codec/i8-array.js

@@ -1,24 +1,24 @@
 // src/codec/i8-array.ts
-import { decodeFixedData } from "./data.js";
-import { decodeUintSafe, encodeUintSafe } from "./primitive.js";
-import { encodeU8FixedArray } from "./u8-array.js";
-function decodeI8Array(bc) {
-  return decodeI8FixedArray(bc, decodeUintSafe(bc));
+import { readFixedData } from "./data.js";
+import { readUintSafe, writeUintSafe } from "./primitive.js";
+import { writeU8FixedArray } from "./u8-array.js";
+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));
 }
 export {
-  decodeI8Array,
-  decodeI8FixedArray,
-  encodeI8Array,
-  encodeI8FixedArray
+  readI8Array,
+  readI8FixedArray,
+  writeI8Array,
+  writeI8FixedArray
 };
 //# sourceMappingURL=i8-array.js.map

package/dist/codec/primitive.d.ts

@@ -1,37 +1,37 @@
 import { type ByteCursor } from "../core/index.js";
-export declare function decodeBool(bc: ByteCursor): boolean;
-export declare function encodeBool(bc: ByteCursor, x: boolean): void;
-export declare function decodeF32(bc: ByteCursor): number;
-export declare function encodeF32(bc: ByteCursor, x: number): void;
-export declare function decodeF64(bc: ByteCursor): number;
-export declare function encodeF64(bc: ByteCursor, x: number): void;
-export declare function decodeI8(bc: ByteCursor): number;
-export declare function encodeI8(bc: ByteCursor, x: number): void;
-export declare function decodeI16(bc: ByteCursor): number;
-export declare function encodeI16(bc: ByteCursor, x: number): void;
-export declare function decodeI32(bc: ByteCursor): number;
-export declare function encodeI32(bc: ByteCursor, x: number): void;
-export declare function decodeI64(bc: ByteCursor): bigint;
-export declare function encodeI64(bc: ByteCursor, x: bigint): void;
-export declare function decodeI64Safe(bc: ByteCursor): number;
-export declare function encodeI64Safe(bc: ByteCursor, x: number): void;
-export declare function decodeInt(bc: ByteCursor): bigint;
-export declare function encodeInt(bc: ByteCursor, x: bigint): void;
-export declare function decodeIntSafe(bc: ByteCursor): number;
-export declare function encodeIntSafe(bc: ByteCursor, x: number): void;
-export declare function decodeU8(bc: ByteCursor): number;
-export declare function encodeU8(bc: ByteCursor, x: number): void;
-export declare function decodeU16(bc: ByteCursor): number;
-export declare function encodeU16(bc: ByteCursor, x: number): void;
-export declare function decodeU32(bc: ByteCursor): number;
-export declare function encodeU32(bc: ByteCursor, x: number): void;
-export declare function decodeU64(bc: ByteCursor): bigint;
-export declare function encodeU64(bc: ByteCursor, x: bigint): void;
-export declare function decodeU64Safe(bc: ByteCursor): number;
-export declare function encodeU64Safe(bc: ByteCursor, x: number): void;
-export declare function decodeUint(bc: ByteCursor): bigint;
-export declare function encodeUint(bc: ByteCursor, x: bigint): void;
-export declare function decodeUintSafe(bc: ByteCursor): number;
-export declare function encodeUintSafe(bc: ByteCursor, x: number): void;
-export declare function decodeVoid(_dc: ByteCursor): undefined;
-export declare function encodeVoid(_dc: ByteCursor, _x: undefined): void;
+export declare function readBool(bc: ByteCursor): boolean;
+export declare function writeBool(bc: ByteCursor, x: boolean): void;
+export declare function readF32(bc: ByteCursor): number;
+export declare function writeF32(bc: ByteCursor, x: number): void;
+export declare function readF64(bc: ByteCursor): number;
+export declare function writeF64(bc: ByteCursor, x: number): void;
+export declare function readI8(bc: ByteCursor): number;
+export declare function writeI8(bc: ByteCursor, x: number): void;
+export declare function readI16(bc: ByteCursor): number;
+export declare function writeI16(bc: ByteCursor, x: number): void;
+export declare function readI32(bc: ByteCursor): number;
+export declare function writeI32(bc: ByteCursor, x: number): void;
+export declare function readI64(bc: ByteCursor): bigint;
+export declare function writeI64(bc: ByteCursor, x: bigint): void;
+export declare function readI64Safe(bc: ByteCursor): number;
+export declare function writeI64Safe(bc: ByteCursor, x: number): void;
+export declare function readInt(bc: ByteCursor): bigint;
+export declare function writeInt(bc: ByteCursor, x: bigint): void;
+export declare function readIntSafe(bc: ByteCursor): number;
+export declare function writeIntSafe(bc: ByteCursor, x: number): void;
+export declare function readU8(bc: ByteCursor): number;
+export declare function writeU8(bc: ByteCursor, x: number): void;
+export declare function readU16(bc: ByteCursor): number;
+export declare function writeU16(bc: ByteCursor, x: number): void;
+export declare function readU32(bc: ByteCursor): number;
+export declare function writeU32(bc: ByteCursor, x: number): void;
+export declare function readU64(bc: ByteCursor): bigint;
+export declare function writeU64(bc: ByteCursor, x: bigint): void;
+export declare function readU64Safe(bc: ByteCursor): number;
+export declare function writeU64Safe(bc: ByteCursor, x: number): void;
+export declare function readUint(bc: ByteCursor): bigint;
+export declare function writeUint(bc: ByteCursor, x: bigint): void;
+export declare function readUintSafe(bc: ByteCursor): number;
+export declare function writeUintSafe(bc: ByteCursor, x: number): void;
+export declare function readVoid(_dc: ByteCursor): undefined;
+export declare function writeVoid(_dc: ByteCursor, _x: undefined): void;