@bare-ts/lib 0.5.0 → 0.6.1

package/README.md

@@ -1,7 +1,7 @@
 # bare-ts library
 
 [![NPM version][npm-img]][npm-url]
-[![minified and gzipped size][bundlephobia-img]][bundlephobia-url]
+[![bundle size - minified and gzipped][bundlejs-img]][bundlejs]
 [![Coverage percentage][coveralls-img]][coveralls-url]
 
 [BARE][bare] (Binary Application Record Encoding) is a schema-based binary format that favors compactness and simplicity.
@@ -20,5 +20,5 @@ The binary format is fairly stable.
 [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
+[bundlejs-img]: https://img.shields.io/badge/dynamic/json?style=flat-square&label=minzipped&query=$.size.compressedSize&url=https://deno.bundlejs.com/?q=@bare-ts/lib
+[bundlejs]: https://bundlejs.com/?q=%40bare-ts%2Flib

package/dist/codec/data.d.ts

@@ -1,4 +1,4 @@
-import type { ByteCursor } from "../core/byte-cursor.js";
+import type { ByteCursor } from "../core/byte-cursor.ts";
 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;

package/dist/codec/data.js

@@ -1,24 +1,20 @@
-"use strict";
+//! Copyright (c) 2022 Victorien Elvinger
+//! Licensed under the MIT License (https://mit-license.org/)
 import { assert, DEV } from "../util/assert.js";
 import { isU32 } from "../util/validator.js";
-import {
-  readU8Array,
-  readU8FixedArray,
-  writeU8Array,
-  writeU8FixedArray
-} from "./u8-array.js";
+import { readU8Array, readU8FixedArray, writeU8Array, writeU8FixedArray, } from "./u8-array.js";
 export function readData(bc) {
-  return readU8Array(bc).buffer;
+    return readU8Array(bc).buffer;
 }
 export function writeData(bc, x) {
-  writeU8Array(bc, new Uint8Array(x));
+    writeU8Array(bc, new Uint8Array(x));
 }
 export function readFixedData(bc, len) {
-  if (DEV) {
-    assert(isU32(len));
-  }
-  return readU8FixedArray(bc, len).buffer;
+    if (DEV) {
+        assert(isU32(len));
+    }
+    return readU8FixedArray(bc, len).buffer;
 }
 export function writeFixedData(bc, x) {
-  writeU8FixedArray(bc, new Uint8Array(x));
+    writeU8FixedArray(bc, new Uint8Array(x));
 }

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

@@ -0,0 +1,5 @@
+import { type ByteCursor } from "../core/byte-cursor.ts";
+export declare const readF32FixedArray: (bc: ByteCursor, len: number) => Float32Array<ArrayBuffer>;
+export declare const writeF32FixedArray: (bc: ByteCursor, x: Float32Array) => void;
+export declare function readF32Array(bc: ByteCursor): Float32Array<ArrayBuffer>;
+export declare function writeF32Array(bc: ByteCursor, x: Float32Array): void;

package/dist/codec/f32-array.js

@@ -0,0 +1,51 @@
+//! Copyright (c) 2022 Victorien Elvinger
+//! Licensed under the MIT License (https://mit-license.org/)
+import { check, reserve } from "../core/byte-cursor.js";
+import { assert, DEV } 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 { readF32, writeF32 } from "./fixed-primitive.js";
+import { writeU8FixedArray } from "./u8-array.js";
+import { readUintSafe32, writeUintSafe32 } from "./uint.js";
+export const readF32FixedArray = IS_LITTLE_ENDIAN_PLATFORM
+    ? readF32FixedArrayLe
+    : readF32FixedArrayBe;
+function readF32FixedArrayLe(bc, len) {
+    if (DEV) {
+        assert(isU32(len));
+    }
+    const byteLen = len * 4;
+    const result = new Float32Array(readFixedData(bc, byteLen));
+    return result;
+}
+function readF32FixedArrayBe(bc, len) {
+    if (DEV) {
+        assert(isU32(len));
+    }
+    check(bc, len * 4);
+    const result = new Float32Array(len);
+    for (let i = 0; i < len; i++) {
+        result[i] = readF32(bc);
+    }
+    return result;
+}
+export const 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) {
+    reserve(bc, val.length * 4);
+    for (let i = 0; i < val.length; i++) {
+        writeF32(bc, val[i]);
+    }
+}
+export function readF32Array(bc) {
+    return readF32FixedArray(bc, readUintSafe32(bc));
+}
+export function writeF32Array(bc, x) {
+    writeUintSafe32(bc, x.length);
+    if (x.length > 0) {
+        writeF32FixedArray(bc, x);
+    }
+}

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

@@ -0,0 +1,5 @@
+import { type ByteCursor } from "../core/byte-cursor.ts";
+export declare const readF64FixedArray: (bc: ByteCursor, len: number) => Float64Array<ArrayBuffer>;
+export declare const writeF64FixedArray: (bc: ByteCursor, x: Float64Array) => void;
+export declare function readF64Array(bc: ByteCursor): Float64Array<ArrayBuffer>;
+export declare function writeF64Array(bc: ByteCursor, x: Float64Array): void;

package/dist/codec/f64-array.js

@@ -0,0 +1,51 @@
+//! Copyright (c) 2022 Victorien Elvinger
+//! Licensed under the MIT License (https://mit-license.org/)
+import { check, reserve } from "../core/byte-cursor.js";
+import { assert, DEV } 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 { readF64, writeF64 } from "./fixed-primitive.js";
+import { writeU8FixedArray } from "./u8-array.js";
+import { readUintSafe32, writeUintSafe32 } from "./uint.js";
+export const readF64FixedArray = IS_LITTLE_ENDIAN_PLATFORM
+    ? readF64FixedArrayLe
+    : readF64FixedArrayBe;
+function readF64FixedArrayLe(bc, len) {
+    if (DEV) {
+        assert(isU32(len));
+    }
+    const byteLen = len * 8;
+    const result = new Float64Array(readFixedData(bc, byteLen));
+    return result;
+}
+function readF64FixedArrayBe(bc, len) {
+    if (DEV) {
+        assert(isU32(len));
+    }
+    check(bc, len * 8);
+    const result = new Float64Array(len);
+    for (let i = 0; i < len; i++) {
+        result[i] = readF64(bc);
+    }
+    return result;
+}
+export const 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) {
+    reserve(bc, x.length * 8);
+    for (let i = 0; i < x.length; i++) {
+        writeF64(bc, x[i]);
+    }
+}
+export function readF64Array(bc) {
+    return readF64FixedArray(bc, readUintSafe32(bc));
+}
+export function writeF64Array(bc, x) {
+    writeUintSafe32(bc, x.length);
+    if (x.length > 0) {
+        writeF64FixedArray(bc, x);
+    }
+}

package/dist/codec/{primitive.d.ts → fixed-primitive.d.ts}

@@ -1,4 +1,4 @@
-import { type ByteCursor } from "../core/byte-cursor.js";
+import { type ByteCursor } from "../core/byte-cursor.ts";
 export declare function readBool(bc: ByteCursor): boolean;
 export declare function writeBool(bc: ByteCursor, x: boolean): void;
 export declare function readF32(bc: ByteCursor): number;
@@ -15,10 +15,6 @@ 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;
@@ -29,9 +25,3 @@ 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 readUintSafe32(bc: ByteCursor): number;
-export declare function writeUintSafe32(bc: ByteCursor, x: number): void;
-export declare function readUintSafe(bc: ByteCursor): number;
-export declare function writeUintSafe(bc: ByteCursor, x: number): void;

package/dist/codec/fixed-primitive.js

@@ -0,0 +1,197 @@
+//! Copyright (c) 2022 Victorien Elvinger
+//! Licensed under the MIT License (https://mit-license.org/)
+import { BareError } from "../core/bare-error.js";
+import { check, reserve } from "../core/byte-cursor.js";
+import { assert, DEV } from "../util/assert.js";
+import { TOO_LARGE_NUMBER } from "../util/constants.js";
+import { isI8, isI16, isI32, isI64, isU8, isU16, isU32, isU64, isU64Safe, } from "../util/validator.js";
+export 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;
+}
+export function writeBool(bc, x) {
+    writeU8(bc, x ? 1 : 0);
+}
+export function readF32(bc) {
+    check(bc, 4);
+    const result = bc.view.getFloat32(bc.offset, true);
+    bc.offset += 4;
+    return result;
+}
+export function writeF32(bc, x) {
+    reserve(bc, 4);
+    bc.view.setFloat32(bc.offset, x, true);
+    if (DEV) {
+        assert(Number.isNaN(x) ||
+            Math.abs(bc.view.getFloat32(bc.offset, true) - x) <=
+                Number.EPSILON, TOO_LARGE_NUMBER);
+    }
+    bc.offset += 4;
+}
+export function readF64(bc) {
+    check(bc, 8);
+    const result = bc.view.getFloat64(bc.offset, true);
+    bc.offset += 8;
+    return result;
+}
+export function writeF64(bc, x) {
+    reserve(bc, 8);
+    bc.view.setFloat64(bc.offset, x, true);
+    bc.offset += 8;
+}
+export function readI8(bc) {
+    check(bc, 1);
+    return bc.view.getInt8(bc.offset++);
+}
+export function writeI8(bc, x) {
+    if (DEV) {
+        assert(isI8(x), TOO_LARGE_NUMBER);
+    }
+    reserve(bc, 1);
+    bc.view.setInt8(bc.offset++, x);
+}
+export function readI16(bc) {
+    check(bc, 2);
+    const result = bc.view.getInt16(bc.offset, true);
+    bc.offset += 2;
+    return result;
+}
+export function writeI16(bc, x) {
+    if (DEV) {
+        assert(isI16(x), TOO_LARGE_NUMBER);
+    }
+    reserve(bc, 2);
+    bc.view.setInt16(bc.offset, x, true);
+    bc.offset += 2;
+}
+export function readI32(bc) {
+    check(bc, 4);
+    const result = bc.view.getInt32(bc.offset, true);
+    bc.offset += 4;
+    return result;
+}
+export function writeI32(bc, x) {
+    if (DEV) {
+        assert(isI32(x), TOO_LARGE_NUMBER);
+    }
+    reserve(bc, 4);
+    bc.view.setInt32(bc.offset, x, true);
+    bc.offset += 4;
+}
+export function readI64(bc) {
+    check(bc, 8);
+    const result = bc.view.getBigInt64(bc.offset, true);
+    bc.offset += 8;
+    return result;
+}
+export function writeI64(bc, x) {
+    if (DEV) {
+        assert(isI64(x), TOO_LARGE_NUMBER);
+    }
+    reserve(bc, 8);
+    bc.view.setBigInt64(bc.offset, x, true);
+    bc.offset += 8;
+}
+export function readI64Safe(bc) {
+    const result = readU32(bc) + readI32(bc) * /* 2**32 */ 4294967296;
+    if (!Number.isSafeInteger(result)) {
+        bc.offset -= 8;
+        throw new BareError(bc.offset, TOO_LARGE_NUMBER);
+    }
+    return result;
+}
+export function writeI64Safe(bc, x) {
+    if (DEV) {
+        assert(Number.isSafeInteger(x), TOO_LARGE_NUMBER);
+    }
+    let lowest32 = x >>> 0;
+    writeU32(bc, lowest32);
+    let highest32 = (x / /* 2**32 */ 4294967296) | 0;
+    if (x < 0) {
+        // get two's complement representation of the highest 21bits
+        highest32 = ~(Math.abs(highest32) & /* 2**21-1 */ 2097151) >>> 0;
+        if (lowest32 === 0) {
+            if (highest32 === 2097151) {
+                // maps -2**53 to Number.MIN_SAFE_INTEGER
+                // this is useful when assertions are skipped
+                lowest32 = 1;
+            }
+            else {
+                highest32++;
+            }
+        }
+    }
+    writeU32(bc, highest32);
+}
+export function readU8(bc) {
+    check(bc, 1);
+    return bc.bytes[bc.offset++];
+}
+export function writeU8(bc, x) {
+    if (DEV) {
+        assert(isU8(x), TOO_LARGE_NUMBER);
+    }
+    reserve(bc, 1);
+    bc.bytes[bc.offset++] = x;
+}
+export function readU16(bc) {
+    check(bc, 2);
+    const result = bc.view.getUint16(bc.offset, true);
+    bc.offset += 2;
+    return result;
+}
+export function writeU16(bc, x) {
+    if (DEV) {
+        assert(isU16(x), TOO_LARGE_NUMBER);
+    }
+    reserve(bc, 2);
+    bc.view.setUint16(bc.offset, x, true);
+    bc.offset += 2;
+}
+export function readU32(bc) {
+    check(bc, 4);
+    const result = bc.view.getUint32(bc.offset, true);
+    bc.offset += 4;
+    return result;
+}
+export function writeU32(bc, x) {
+    if (DEV) {
+        assert(isU32(x), TOO_LARGE_NUMBER);
+    }
+    reserve(bc, 4);
+    bc.view.setUint32(bc.offset, x, true);
+    bc.offset += 4;
+}
+export function readU64(bc) {
+    check(bc, 8);
+    const result = bc.view.getBigUint64(bc.offset, true);
+    bc.offset += 8;
+    return result;
+}
+export function writeU64(bc, x) {
+    if (DEV) {
+        assert(isU64(x), TOO_LARGE_NUMBER);
+    }
+    reserve(bc, 8);
+    bc.view.setBigUint64(bc.offset, x, true);
+    bc.offset += 8;
+}
+export function readU64Safe(bc) {
+    const result = readU32(bc) + readU32(bc) * /* 2**32 */ 4294967296;
+    if (!isU64Safe(result)) {
+        bc.offset -= 8;
+        throw new BareError(bc.offset, TOO_LARGE_NUMBER);
+    }
+    return result;
+}
+export function writeU64Safe(bc, x) {
+    if (DEV) {
+        assert(isU64Safe(x), TOO_LARGE_NUMBER);
+    }
+    writeU32(bc, x >>> 0);
+    writeU32(bc, (x / /* 2**32 */ 4294967296) & /* 2**21-1 */ 2097151);
+}

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

@@ -1,4 +1,4 @@
-import { type ByteCursor } from "../core/byte-cursor.js";
+import { type ByteCursor } from "../core/byte-cursor.ts";
 export declare const readI16FixedArray: (bc: ByteCursor, len: number) => Int16Array<ArrayBuffer>;
 export declare function readI16Array(bc: ByteCursor): Int16Array<ArrayBuffer>;
 export declare const writeI16FixedArray: (bc: ByteCursor, x: Int16Array) => void;

package/dist/codec/i16-array.js

@@ -1,51 +1,50 @@
-"use strict";
+//! Copyright (c) 2022 Victorien Elvinger
+//! Licensed under the MIT License (https://mit-license.org/)
 import { check, reserve } from "../core/byte-cursor.js";
 import { assert, DEV } 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 {
-  readI16,
-  readUintSafe32,
-  writeI16,
-  writeUintSafe32
-} from "./primitive.js";
+import { readI16, writeI16 } from "./fixed-primitive.js";
 import { writeU8FixedArray } from "./u8-array.js";
-export const readI16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readI16FixedArrayLe : readI16FixedArrayBe;
+import { readUintSafe32, writeUintSafe32 } from "./uint.js";
+export const readI16FixedArray = IS_LITTLE_ENDIAN_PLATFORM
+    ? readI16FixedArrayLe
+    : readI16FixedArrayBe;
 export function readI16Array(bc) {
-  return readI16FixedArray(bc, readUintSafe32(bc));
+    return readI16FixedArray(bc, readUintSafe32(bc));
 }
 function readI16FixedArrayLe(bc, len) {
-  if (DEV) {
-    assert(isU32(len));
-  }
-  const byteCount = len * 2;
-  return new Int16Array(readFixedData(bc, byteCount));
+    if (DEV) {
+        assert(isU32(len));
+    }
+    const byteCount = len * 2;
+    return new Int16Array(readFixedData(bc, byteCount));
 }
 function readI16FixedArrayBe(bc, len) {
-  if (DEV) {
-    assert(isU32(len));
-  }
-  check(bc, len * 2);
-  const result = new Int16Array(len);
-  for (let i = 0; i < len; i++) {
-    result[i] = readI16(bc);
-  }
-  return result;
+    if (DEV) {
+        assert(isU32(len));
+    }
+    check(bc, len * 2);
+    const result = new Int16Array(len);
+    for (let i = 0; i < len; i++) {
+        result[i] = readI16(bc);
+    }
+    return result;
 }
 export const writeI16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeI16FixedArrayLe : writeI16FixedArrayBe;
 export function writeI16Array(bc, x) {
-  writeUintSafe32(bc, x.length);
-  if (x.length > 0) {
-    writeI16FixedArray(bc, x);
-  }
+    writeUintSafe32(bc, x.length);
+    if (x.length > 0) {
+        writeI16FixedArray(bc, x);
+    }
 }
 function writeI16FixedArrayLe(bc, x) {
-  writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+    writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
 }
 function writeI16FixedArrayBe(bc, x) {
-  reserve(bc, x.length * 2);
-  for (let i = 0; i < x.length; i++) {
-    writeI16(bc, x[i]);
-  }
+    reserve(bc, x.length * 2);
+    for (let i = 0; i < x.length; i++) {
+        writeI16(bc, x[i]);
+    }
 }

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

@@ -1,4 +1,4 @@
-import { type ByteCursor } from "../core/byte-cursor.js";
+import { type ByteCursor } from "../core/byte-cursor.ts";
 export declare const readI32FixedArray: (bc: ByteCursor, len: number) => Int32Array<ArrayBuffer>;
 export declare function readI32Array(bc: ByteCursor): Int32Array<ArrayBuffer>;
 export declare const writeI32FixedArray: (bc: ByteCursor, x: Int32Array) => void;

package/dist/codec/i32-array.js

@@ -1,51 +1,50 @@
-"use strict";
+//! Copyright (c) 2022 Victorien Elvinger
+//! Licensed under the MIT License (https://mit-license.org/)
 import { check, reserve } from "../core/byte-cursor.js";
 import { assert, DEV } 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 {
-  readI32,
-  readUintSafe32,
-  writeI32,
-  writeUintSafe32
-} from "./primitive.js";
+import { readI32, writeI32 } from "./fixed-primitive.js";
 import { writeU8FixedArray } from "./u8-array.js";
-export const readI32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readI32FixedArrayLe : readI32FixedArrayBe;
+import { readUintSafe32, writeUintSafe32 } from "./uint.js";
+export const readI32FixedArray = IS_LITTLE_ENDIAN_PLATFORM
+    ? readI32FixedArrayLe
+    : readI32FixedArrayBe;
 export function readI32Array(bc) {
-  return readI32FixedArray(bc, readUintSafe32(bc));
+    return readI32FixedArray(bc, readUintSafe32(bc));
 }
 function readI32FixedArrayLe(bc, len) {
-  if (DEV) {
-    assert(isU32(len));
-  }
-  const byteCount = len * 4;
-  return new Int32Array(readFixedData(bc, byteCount));
+    if (DEV) {
+        assert(isU32(len));
+    }
+    const byteCount = len * 4;
+    return new Int32Array(readFixedData(bc, byteCount));
 }
 function readI32FixedArrayBe(bc, len) {
-  if (DEV) {
-    assert(isU32(len));
-  }
-  check(bc, len * 4);
-  const result = new Int32Array(len);
-  for (let i = 0; i < len; i++) {
-    result[i] = readI32(bc);
-  }
-  return result;
+    if (DEV) {
+        assert(isU32(len));
+    }
+    check(bc, len * 4);
+    const result = new Int32Array(len);
+    for (let i = 0; i < len; i++) {
+        result[i] = readI32(bc);
+    }
+    return result;
 }
 export const writeI32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeI32FixedArrayLe : writeI32FixedArrayBe;
 export function writeI32Array(bc, x) {
-  writeUintSafe32(bc, x.length);
-  if (x.length > 0) {
-    writeI32FixedArray(bc, x);
-  }
+    writeUintSafe32(bc, x.length);
+    if (x.length > 0) {
+        writeI32FixedArray(bc, x);
+    }
 }
 function writeI32FixedArrayLe(bc, x) {
-  writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+    writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
 }
 function writeI32FixedArrayBe(bc, x) {
-  reserve(bc, x.length * 4);
-  for (let i = 0; i < x.length; i++) {
-    writeI32(bc, x[i]);
-  }
+    reserve(bc, x.length * 4);
+    for (let i = 0; i < x.length; i++) {
+        writeI32(bc, x[i]);
+    }
 }

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

@@ -1,4 +1,4 @@
-import { type ByteCursor } from "../core/byte-cursor.js";
+import { type ByteCursor } from "../core/byte-cursor.ts";
 export declare const readI64FixedArray: (bc: ByteCursor, len: number) => BigInt64Array<ArrayBuffer>;
 export declare function readI64Array(bc: ByteCursor): BigInt64Array<ArrayBuffer>;
 export declare const writeI64FixedArray: (bc: ByteCursor, x: BigInt64Array) => void;

package/dist/codec/i64-array.js

@@ -1,51 +1,50 @@
-"use strict";
+//! Copyright (c) 2022 Victorien Elvinger
+//! Licensed under the MIT License (https://mit-license.org/)
 import { check, reserve } from "../core/byte-cursor.js";
 import { assert, DEV } 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 {
-  readI64,
-  readUintSafe32,
-  writeI64,
-  writeUintSafe32
-} from "./primitive.js";
+import { readI64, writeI64 } from "./fixed-primitive.js";
 import { writeU8FixedArray } from "./u8-array.js";
-export const readI64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readI64FixedArrayLe : readI64FixedArrayBe;
+import { readUintSafe32, writeUintSafe32 } from "./uint.js";
+export const readI64FixedArray = IS_LITTLE_ENDIAN_PLATFORM
+    ? readI64FixedArrayLe
+    : readI64FixedArrayBe;
 export function readI64Array(bc) {
-  return readI64FixedArray(bc, readUintSafe32(bc));
+    return readI64FixedArray(bc, readUintSafe32(bc));
 }
 function readI64FixedArrayLe(bc, len) {
-  if (DEV) {
-    assert(isU32(len));
-  }
-  const byteCount = len * 8;
-  return new BigInt64Array(readFixedData(bc, byteCount));
+    if (DEV) {
+        assert(isU32(len));
+    }
+    const byteCount = len * 8;
+    return new BigInt64Array(readFixedData(bc, byteCount));
 }
 function readI64FixedArrayBe(bc, len) {
-  if (DEV) {
-    assert(isU32(len));
-  }
-  check(bc, len * 8);
-  const result = new BigInt64Array(len);
-  for (let i = 0; i < len; i++) {
-    result[i] = readI64(bc);
-  }
-  return result;
+    if (DEV) {
+        assert(isU32(len));
+    }
+    check(bc, len * 8);
+    const result = new BigInt64Array(len);
+    for (let i = 0; i < len; i++) {
+        result[i] = readI64(bc);
+    }
+    return result;
 }
 export const writeI64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeI64FixedArrayLe : writeI64FixedArrayBe;
 export function writeI64Array(bc, x) {
-  writeUintSafe32(bc, x.length);
-  if (x.length > 0) {
-    writeI64FixedArray(bc, x);
-  }
+    writeUintSafe32(bc, x.length);
+    if (x.length > 0) {
+        writeI64FixedArray(bc, x);
+    }
 }
 function writeI64FixedArrayLe(bc, x) {
-  writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+    writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
 }
 function writeI64FixedArrayBe(bc, x) {
-  reserve(bc, x.length * 8);
-  for (let i = 0; i < x.length; i++) {
-    writeI64(bc, x[i]);
-  }
+    reserve(bc, x.length * 8);
+    for (let i = 0; i < x.length; i++) {
+        writeI64(bc, x[i]);
+    }
 }