@bare-ts/lib 0.1.0 → 0.3.0

package/README.md

@@ -1,6 +1,9 @@
 # bare-ts library
 
-![CI status][ci]
+[![CI status][ci-img]][ci-url]
+[![Coverage percentage][coveralls-img]][coveralls-url]
+[![minified and gzipped size][bundlephobia-img]][bundlephobia-url]
+[![NPM version][npm-img]][npm-url]
 
 [BARE][bare] (Binary Application Record Encoding) is a schema-based binary format that favors compactness and simplicity.
 [bare-ts/lib](#) provides decoders and encoders for basic BARE types.
@@ -12,4 +15,11 @@ The specification is likely to evolve before its final release. [bare-ts](#) imp
 
 [bare]: https://baremessages.org
 [bare-ts-tools]: https://github.com/bare-ts/tools
-[ci]: https://github.com/bare-ts/lib/actions/workflows/ci.yml/badge.svg
+[ci-img]: https://img.shields.io/github/workflow/status/bare-ts/lib/CI?label=CI&style=flat-square
+[ci-url]: https://github.com/bare-ts/lib/actions/workflows/ci.yml
+[npm-img]: https://img.shields.io/npm/v/@bare-ts/lib.svg?style=flat-square
+[npm-url]: https://www.npmjs.com/package/@bare-ts/lib
+[coveralls-img]: https://img.shields.io/coveralls/github/bare-ts/lib?style=flat-square
+[coveralls-url]: https://coveralls.io/github/bare-ts/lib?branch=main
+[bundlephobia-img]: https://img.shields.io/bundlephobia/minzip/@bare-ts/lib?label=minzipped&style=flat-square
+[bundlephobia-url]: https://bundlephobia.com/package/@bare-ts/lib

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

@@ -0,0 +1,26 @@
+// src/codec/data.ts
+import {
+  readU8Array,
+  readU8FixedArray,
+  writeU8Array,
+  writeU8FixedArray
+} from "./u8-array.js";
+function readData(bc) {
+  return readU8Array(bc).buffer;
+}
+function writeData(bc, x) {
+  writeU8Array(bc, new Uint8Array(x));
+}
+function readFixedData(bc, len) {
+  return readU8FixedArray(bc, len).buffer;
+}
+function writeFixedData(bc, x) {
+  writeU8FixedArray(bc, new Uint8Array(x));
+}
+export {
+  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

@@ -0,0 +1,85 @@
+// src/codec/float-array.ts
+import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
+import { readFixedData } from "./data.js";
+import {
+  readF32,
+  readF64,
+  readUintSafe,
+  writeF32,
+  writeF64,
+  writeUintSafe
+} from "./primitive.js";
+import { writeU8FixedArray } from "./u8-array.js";
+var readF32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readF32FixedArrayLE : readF32FixedArrayBE;
+function readF32FixedArrayLE(bc, len) {
+  const byteLen = len * 4;
+  const result = new Float32Array(readFixedData(bc, byteLen));
+  return result;
+}
+function readF32FixedArrayBE(bc, len) {
+  bc.check(len * 4);
+  const result = new Float32Array(len);
+  for (let i = 0; i < len; i++)
+    result[i] = readF32(bc);
+  return result;
+}
+var writeF32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeF32FixedArrayLE : writeF32FixedArrayBE;
+function writeF32FixedArrayLE(bc, x) {
+  writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+}
+function writeF32FixedArrayBE(bc, val) {
+  bc.reserve(val.length * 4);
+  for (let i = 0; i < val.length; i++)
+    writeF32(bc, val[i]);
+}
+function readF32Array(bc) {
+  return readF32FixedArray(bc, readUintSafe(bc));
+}
+function writeF32Array(bc, x) {
+  writeUintSafe(bc, x.length);
+  if (x.length !== 0) {
+    writeF32FixedArray(bc, x);
+  }
+}
+var readF64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readF64FixedArrayLE : readF64FixedArrayBE;
+function readF64FixedArrayLE(bc, len) {
+  const byteLen = len * 8;
+  const result = new Float64Array(readFixedData(bc, byteLen));
+  return result;
+}
+function readF64FixedArrayBE(bc, len) {
+  bc.check(len * 8);
+  const result = new Float64Array(len);
+  for (let i = 0; i < len; i++)
+    result[i] = readF64(bc);
+  return result;
+}
+var writeF64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeF64FixedArrayLE : writeF64FixedArrayBE;
+function writeF64FixedArrayLE(bc, x) {
+  writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+}
+function writeF64FixedArrayBE(bc, x) {
+  bc.reserve(x.length * 8);
+  for (let i = 0; i < x.length; i++)
+    writeF64(bc, x[i]);
+}
+function readF64Array(bc) {
+  return readF64FixedArray(bc, readUintSafe(bc));
+}
+function writeF64Array(bc, x) {
+  writeUintSafe(bc, x.length);
+  if (x.length !== 0) {
+    writeF64FixedArray(bc, x);
+  }
+}
+export {
+  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

@@ -0,0 +1,43 @@
+// src/codec/i16-array.ts
+import { I16_BYTE_COUNT } from "../util/constants.js";
+import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
+import { readFixedData } from "./data.js";
+import { readI16, readUintSafe, writeI16, writeUintSafe } from "./primitive.js";
+import { writeU8FixedArray } from "./u8-array.js";
+var readI16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readI16FixedArrayLE : readI16FixedArrayBE;
+function readI16Array(bc) {
+  return readI16FixedArray(bc, readUintSafe(bc));
+}
+function readI16FixedArrayLE(bc, len) {
+  const byteCount = len * I16_BYTE_COUNT;
+  return new Int16Array(readFixedData(bc, byteCount));
+}
+function readI16FixedArrayBE(bc, len) {
+  bc.check(len * I16_BYTE_COUNT);
+  const result = new Int16Array(len);
+  for (let i = 0; i < len; i++)
+    result[i] = readI16(bc);
+  return result;
+}
+var writeI16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeI16FixedArrayLE : writeI16FixedArrayBE;
+function writeI16Array(bc, x) {
+  writeUintSafe(bc, x.length);
+  if (x.length !== 0) {
+    writeI16FixedArray(bc, x);
+  }
+}
+function writeI16FixedArrayLE(bc, x) {
+  writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+}
+function writeI16FixedArrayBE(bc, x) {
+  bc.reserve(x.length * I16_BYTE_COUNT);
+  for (let i = 0; i < x.length; i++)
+    writeI16(bc, x[i]);
+}
+export {
+  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

@@ -0,0 +1,43 @@
+// src/codec/i32-array.ts
+import { I32_BYTE_COUNT } from "../util/constants.js";
+import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
+import { readFixedData } from "./data.js";
+import { readI32, readUintSafe, writeI32, writeUintSafe } from "./primitive.js";
+import { writeU8FixedArray } from "./u8-array.js";
+var readI32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readI32FixedArrayLE : readI32FixedArrayBE;
+function readI32Array(bc) {
+  return readI32FixedArray(bc, readUintSafe(bc));
+}
+function readI32FixedArrayLE(bc, len) {
+  const byteCount = len * I32_BYTE_COUNT;
+  return new Int32Array(readFixedData(bc, byteCount));
+}
+function readI32FixedArrayBE(bc, len) {
+  bc.check(len * I32_BYTE_COUNT);
+  const result = new Int32Array(len);
+  for (let i = 0; i < len; i++)
+    result[i] = readI32(bc);
+  return result;
+}
+var writeI32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeI32FixedArrayLE : writeI32FixedArrayBE;
+function writeI32Array(bc, x) {
+  writeUintSafe(bc, x.length);
+  if (x.length !== 0) {
+    writeI32FixedArray(bc, x);
+  }
+}
+function writeI32FixedArrayLE(bc, x) {
+  writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+}
+function writeI32FixedArrayBE(bc, x) {
+  bc.reserve(x.length * I32_BYTE_COUNT);
+  for (let i = 0; i < x.length; i++)
+    writeI32(bc, x[i]);
+}
+export {
+  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

@@ -0,0 +1,43 @@
+// src/codec/i64-array.ts
+import { I64_BYTE_COUNT } from "../util/constants.js";
+import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
+import { readFixedData } from "./data.js";
+import { readI64, readUintSafe, writeI64, writeUintSafe } from "./primitive.js";
+import { writeU8FixedArray } from "./u8-array.js";
+var readI64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readI64FixedArrayLE : readI64FixedArrayBE;
+function readI64Array(bc) {
+  return readI64FixedArray(bc, readUintSafe(bc));
+}
+function readI64FixedArrayLE(bc, len) {
+  const byteCount = len * I64_BYTE_COUNT;
+  return new BigInt64Array(readFixedData(bc, byteCount));
+}
+function readI64FixedArrayBE(bc, len) {
+  bc.check(len * I64_BYTE_COUNT);
+  const result = new BigInt64Array(len);
+  for (let i = 0; i < len; i++)
+    result[i] = readI64(bc);
+  return result;
+}
+var writeI64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeI64FixedArrayLE : writeI64FixedArrayBE;
+function writeI64Array(bc, x) {
+  writeUintSafe(bc, x.length);
+  if (x.length !== 0) {
+    writeI64FixedArray(bc, x);
+  }
+}
+function writeI64FixedArrayLE(bc, x) {
+  writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+}
+function writeI64FixedArrayBE(bc, x) {
+  bc.reserve(x.length * I64_BYTE_COUNT);
+  for (let i = 0; i < x.length; i++)
+    writeI64(bc, x[i]);
+}
+export {
+  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

@@ -0,0 +1,24 @@
+// src/codec/i8-array.ts
+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 writeI8Array(bc, x) {
+  writeUintSafe(bc, x.length);
+  writeI8FixedArray(bc, x);
+}
+function readI8FixedArray(bc, len) {
+  return new Int8Array(readFixedData(bc, len));
+}
+function writeI8FixedArray(bc, x) {
+  writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+}
+export {
+  readI8Array,
+  readI8FixedArray,
+  writeI8Array,
+  writeI8FixedArray
+};
+//# sourceMappingURL=i8-array.js.map

package/dist/codec/index.js

@@ -0,0 +1,15 @@
+// src/codec/index.ts
+export * from "./data.js";
+export * from "./float-array.js";
+export * from "./i16-array.js";
+export * from "./i32-array.js";
+export * from "./i64-array.js";
+export * from "./i8-array.js";
+export * from "./primitive.js";
+export * from "./string.js";
+export * from "./u16-array.js";
+export * from "./u32-array.js";
+export * from "./u64-array.js";
+export * from "./u8-array.js";
+export * from "./u8-clamped-array.js";
+//# sourceMappingURL=index.js.map

package/dist/codec/primitive.d.ts

@@ -1,37 +1,35 @@
 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;