@bare-ts/lib 0.5.0 → 0.6.1

package/dist/codec/i8-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 function readI8Array(bc: ByteCursor): Int8Array<ArrayBuffer>;
 export declare function writeI8Array(bc: ByteCursor, x: Int8Array): void;
 export declare function readI8FixedArray(bc: ByteCursor, len: number): Int8Array<ArrayBuffer>;

package/dist/codec/i8-array.js

@@ -1,22 +1,23 @@
-"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 { readFixedData } from "./data.js";
-import { readUintSafe, writeUintSafe32 } from "./primitive.js";
 import { writeU8FixedArray } from "./u8-array.js";
+import { readUintSafe, writeUintSafe32 } from "./uint.js";
 export function readI8Array(bc) {
-  return readI8FixedArray(bc, readUintSafe(bc));
+    return readI8FixedArray(bc, readUintSafe(bc));
 }
 export function writeI8Array(bc, x) {
-  writeUintSafe32(bc, x.length);
-  writeI8FixedArray(bc, x);
+    writeUintSafe32(bc, x.length);
+    writeI8FixedArray(bc, x);
 }
 export function readI8FixedArray(bc, len) {
-  if (DEV) {
-    assert(isU32(len));
-  }
-  return new Int8Array(readFixedData(bc, len));
+    if (DEV) {
+        assert(isU32(len));
+    }
+    return new Int8Array(readFixedData(bc, len));
 }
 export function writeI8FixedArray(bc, x) {
-  writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+    writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
 }

package/dist/codec/int.d.ts

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

package/dist/codec/int.js

@@ -0,0 +1,78 @@
+import { BareError } from "../core/bare-error.js";
+import { assert, DEV } from "../util/assert.js";
+import { INT_SAFE_MAX_BYTE_COUNT, TOO_LARGE_NUMBER } from "../util/constants.js";
+import { readU8, writeU8 } from "./fixed-primitive.js";
+import { readUint, writeUintSafe, writeUintTruncated } from "./uint.js";
+export function readInt(bc) {
+    const zigZag = readUint(bc);
+    return (zigZag >> BigInt(1)) ^ -(zigZag & BigInt(1));
+}
+export function writeInt(bc, x) {
+    // truncate to mimic DataView#setBigInt64
+    // this is useful when assertions are skipped
+    const truncated = BigInt.asIntN(64, x);
+    if (DEV) {
+        assert(truncated === x, TOO_LARGE_NUMBER);
+    }
+    const zigZag = (truncated >> BigInt(63)) ^ (truncated << BigInt(1));
+    writeUintTruncated(bc, zigZag);
+}
+export function readIntSafe(bc) {
+    const firstByte = readU8(bc);
+    let result = (firstByte & 0x7f) >> 1;
+    if (firstByte >= 0x80) {
+        let shiftMul = /* 2**6 */ 0x40;
+        let byteCount = 1;
+        let byte;
+        do {
+            byte = readU8(bc);
+            result += (byte & 0x7f) * shiftMul;
+            shiftMul *= /* 2**7 */ 0x80;
+            byteCount++;
+        } while (byte >= 0x80 && byteCount < INT_SAFE_MAX_BYTE_COUNT);
+        if (byte === 0) {
+            bc.offset -= byteCount - 1;
+            throw new BareError(bc.offset, "must be canonical");
+        }
+        if (byteCount === INT_SAFE_MAX_BYTE_COUNT &&
+            (byte > 0x1f || firstByte === 0xff)) {
+            // First byte must not be equal to 0xff in order to exclude -2**53
+            // Number.MIN_SAFE_INTEGER equals to -(2**53 - 1)
+            bc.offset -= byteCount - 1;
+            throw new BareError(bc.offset, TOO_LARGE_NUMBER);
+        }
+    }
+    const isNeg = (firstByte & 1) === 1;
+    if (isNeg) {
+        result = -result - 1;
+    }
+    return result;
+}
+export function writeIntSafe(bc, x) {
+    const sign = x < 0 ? 1 : 0;
+    let zigZag = x < 0 ? -(x + 1) : x;
+    let first7Bits = ((zigZag & 0x3f) << 1) | sign;
+    zigZag = Math.floor(zigZag / /* 2**6 */ 0x40);
+    if (zigZag > 0) {
+        if (!Number.isSafeInteger(x)) {
+            if (DEV) {
+                assert(false, TOO_LARGE_NUMBER);
+            }
+            // keep only the remaining 53 - 6 = 47 bits
+            // this is useful when assertions are skipped
+            const low = zigZag & 0x7fff;
+            const high = ((zigZag / 0x8000) >>> 0) * 0x8000;
+            if (first7Bits === 0x7f && low === 0x7fff && high === 4294967295) {
+                // maps -2**53 to Number.MIN_SAFE_INTEGER
+                // this is useful when assertions are skipped
+                first7Bits &= ~0b10;
+            }
+            zigZag = high + low;
+        }
+        writeU8(bc, 0x80 | first7Bits);
+        writeUintSafe(bc, zigZag);
+    }
+    else {
+        writeU8(bc, first7Bits);
+    }
+}

package/dist/codec/string.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 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,140 +1,169 @@
-"use strict";
+//! 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 {
-  INVALID_UTF8_STRING,
-  TEXT_DECODER_THRESHOLD,
-  TEXT_ENCODER_THRESHOLD
-} from "../util/constants.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";
+import { readUintSafe32, writeUintSafe32 } from "./uint.js";
 export function readString(bc) {
-  return readFixedString(bc, readUintSafe32(bc));
+    return readFixedString(bc, readUintSafe32(bc));
 }
 export function writeString(bc, x) {
-  if (x.length < TEXT_ENCODER_THRESHOLD) {
-    const byteLen = utf8ByteLength(x);
-    writeUintSafe32(bc, byteLen);
-    reserve(bc, byteLen);
-    writeUtf8Js(bc, x);
-  } else {
-    const strBytes = UTF8_ENCODER.encode(x);
-    writeUintSafe32(bc, strBytes.length);
-    writeU8FixedArray(bc, strBytes);
-  }
+    if (x.length < TEXT_ENCODER_THRESHOLD) {
+        const byteLen = utf8ByteLength(x);
+        writeUintSafe32(bc, byteLen);
+        reserve(bc, byteLen);
+        writeUtf8Js(bc, x);
+    }
+    else {
+        const strBytes = UTF8_ENCODER.encode(x);
+        writeUintSafe32(bc, strBytes.length);
+        writeU8FixedArray(bc, strBytes);
+    }
 }
 export function readFixedString(bc, byteLen) {
-  if (DEV) {
-    assert(isU32(byteLen));
-  }
-  if (byteLen < TEXT_DECODER_THRESHOLD) {
-    return readUtf8Js(bc, byteLen);
-  }
-  try {
-    return UTF8_DECODER.decode(readUnsafeU8FixedArray(bc, byteLen));
-  } catch (_cause) {
-    throw new BareError(bc.offset, INVALID_UTF8_STRING);
-  }
+    if (DEV) {
+        assert(isU32(byteLen));
+    }
+    if (byteLen < TEXT_DECODER_THRESHOLD) {
+        return readUtf8Js(bc, byteLen);
+    }
+    try {
+        return UTF8_DECODER.decode(readUnsafeU8FixedArray(bc, byteLen));
+    }
+    catch (_cause) {
+        throw new BareError(bc.offset, INVALID_UTF8_STRING);
+    }
 }
 export function writeFixedString(bc, x) {
-  if (x.length < TEXT_ENCODER_THRESHOLD) {
-    const byteLen = utf8ByteLength(x);
-    reserve(bc, byteLen);
-    writeUtf8Js(bc, x);
-  } else {
-    writeU8FixedArray(bc, UTF8_ENCODER.encode(x));
-  }
+    if (x.length < TEXT_ENCODER_THRESHOLD) {
+        const byteLen = utf8ByteLength(x);
+        reserve(bc, byteLen);
+        writeUtf8Js(bc, x);
+    }
+    else {
+        writeU8FixedArray(bc, UTF8_ENCODER.encode(x));
+    }
 }
 function readUtf8Js(bc, byteLen) {
-  check(bc, byteLen);
-  let result = "";
-  const bytes = bc.bytes;
-  let offset = bc.offset;
-  const upperOffset = offset + byteLen;
-  while (offset < upperOffset) {
-    let codePoint = bytes[offset++];
-    if (codePoint > 127) {
-      let malformed = true;
-      const byte1 = codePoint;
-      if (offset < upperOffset && codePoint < 224) {
-        const byte2 = bytes[offset++];
-        codePoint = (byte1 & 31) << 6 | byte2 & 63;
-        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 || // 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 || // 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);
-      }
+    // `check` asserts that `byteLen` is a `u32`
+    check(bc, byteLen);
+    let result = "";
+    const bytes = bc.bytes;
+    let offset = bc.offset;
+    const upperOffset = offset + byteLen;
+    while (offset < upperOffset) {
+        let codePoint = bytes[offset++];
+        if (codePoint > 0x7f) {
+            let malformed = true;
+            const byte1 = codePoint;
+            if (offset < upperOffset && codePoint < 0xe0) {
+                // 110x_xxxx 10xx_xxxx
+                const byte2 = bytes[offset++];
+                codePoint = ((byte1 & 0x1f) << 6) | (byte2 & 0x3f);
+                malformed =
+                    codePoint >> 7 === 0 || // non-canonical char
+                        byte1 >> 5 !== 0b110 || // invalid tag
+                        byte2 >> 6 !== 0b10; // invalid tag
+            }
+            else if (offset + 1 < upperOffset && codePoint < 0xf0) {
+                // 1110_xxxx 10xx_xxxx 10xx_xxxx
+                const byte2 = bytes[offset++];
+                const byte3 = bytes[offset++];
+                codePoint =
+                    ((byte1 & 0xf) << 12) |
+                        ((byte2 & 0x3f) << 6) |
+                        (byte3 & 0x3f);
+                malformed =
+                    codePoint >> 11 === 0 || // non-canonical char or missing data
+                        codePoint >> 11 === 0x1b || // surrogate char (0xD800 <= codePoint <= 0xDFFF)
+                        byte1 >> 4 !== 0b1110 || // invalid tag
+                        byte2 >> 6 !== 0b10 || // invalid tag
+                        byte3 >> 6 !== 0b10; // invalid tag
+            }
+            else if (offset + 2 < upperOffset) {
+                // 1110_xxxx 10xx_xxxx 10xx_xxxx 10xx_xxxx
+                const byte2 = bytes[offset++];
+                const byte3 = bytes[offset++];
+                const byte4 = bytes[offset++];
+                codePoint =
+                    ((byte1 & 0x7) << 18) |
+                        ((byte2 & 0x3f) << 12) |
+                        ((byte3 & 0x3f) << 6) |
+                        (byte4 & 0x3f);
+                malformed =
+                    codePoint >> 16 === 0 || // non-canonical char or missing data
+                        codePoint > 0x10ffff || // too large code point
+                        byte1 >> 3 !== 0b11110 || // invalid tag
+                        byte2 >> 6 !== 0b10 || // invalid tag
+                        byte3 >> 6 !== 0b10 || // invalid tag
+                        byte4 >> 6 !== 0b10; // invalid tag
+            }
+            if (malformed) {
+                throw new BareError(bc.offset, INVALID_UTF8_STRING);
+            }
+        }
+        result += String.fromCodePoint(codePoint);
     }
-    result += String.fromCodePoint(codePoint);
-  }
-  bc.offset = offset;
-  return result;
+    bc.offset = offset;
+    return result;
 }
 function writeUtf8Js(bc, s) {
-  const bytes = bc.bytes;
-  let offset = bc.offset;
-  let i = 0;
-  while (i < s.length) {
-    const codePoint = s.codePointAt(i++);
-    if (codePoint < 128) {
-      bytes[offset++] = codePoint;
-    } else {
-      if (codePoint < 2048) {
-        bytes[offset++] = 192 | codePoint >> 6;
-      } else {
-        if (codePoint < 65536) {
-          bytes[offset++] = 224 | codePoint >> 12;
-        } else {
-          bytes[offset++] = 240 | codePoint >> 18;
-          bytes[offset++] = 128 | codePoint >> 12 & 63;
-          i++;
+    const bytes = bc.bytes;
+    let offset = bc.offset;
+    let i = 0;
+    while (i < s.length) {
+        const codePoint = s.codePointAt(i++); // i is a valid index
+        if (codePoint < 0x80) {
+            bytes[offset++] = codePoint;
+        }
+        else {
+            if (codePoint < 0x800) {
+                bytes[offset++] = 0xc0 | (codePoint >> 6);
+            }
+            else {
+                if (codePoint < 65536) {
+                    bytes[offset++] = 0xe0 | (codePoint >> 12);
+                }
+                else {
+                    bytes[offset++] = 0xf0 | (codePoint >> 18);
+                    bytes[offset++] = 0x80 | ((codePoint >> 12) & 0x3f);
+                    i++; // surrogate pair encoded as two ucs2 chars
+                }
+                bytes[offset++] = 0x80 | ((codePoint >> 6) & 0x3f);
+            }
+            bytes[offset++] = 0x80 | (codePoint & 0x3f);
         }
-        bytes[offset++] = 128 | codePoint >> 6 & 63;
-      }
-      bytes[offset++] = 128 | codePoint & 63;
     }
-  }
-  bc.offset = offset;
+    bc.offset = offset;
 }
 function utf8ByteLength(s) {
-  let result = s.length;
-  for (let i = 0; i < s.length; i++) {
-    const codePoint = s.codePointAt(i);
-    if (codePoint > 127) {
-      result++;
-      if (codePoint > 2047) {
-        result++;
-        if (codePoint > 65535) {
-          i++;
+    let result = s.length;
+    for (let i = 0; i < s.length; i++) {
+        const codePoint = s.codePointAt(i); // i is a valid index
+        if (codePoint > 0x7f) {
+            result++;
+            if (codePoint > 0x7ff) {
+                result++;
+                if (codePoint > 65535) {
+                    i++; // surrogate pair encoded as two ucs2 chars
+                }
+            }
         }
-      }
     }
-  }
-  return result;
+    return result;
 }
+/**
+ * UTF-8 decoding and encoding using API that is supported in Node >= 12 and
+ * modern browsers:
+ * https://developer.mozilla.org/en-US/docs/Web/API/TextEncoder/write
+ * https://developer.mozilla.org/en-US/docs/Web/API/TextDecoder/read
+ *
+ * If you're running in an environment where it's not available,
+ * please use a polyfill, such as:
+ * https://github.com/anonyco/FastestSmallestTextEncoderDecoder
+ */
 const UTF8_DECODER = /* @__PURE__ */ new TextDecoder("utf-8", { fatal: true });
 const UTF8_ENCODER = /* @__PURE__ */ new TextEncoder();

package/dist/codec/u16-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 readU16FixedArray: (bc: ByteCursor, len: number) => Uint16Array<ArrayBuffer>;
 export declare function readU16Array(bc: ByteCursor): Uint16Array<ArrayBuffer>;
 export declare const writeU16FixedArray: (bc: ByteCursor, x: Uint16Array) => void;

package/dist/codec/u16-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 {
-  readU16,
-  readUintSafe32,
-  writeU16,
-  writeUintSafe32
-} from "./primitive.js";
+import { readU16, writeU16 } from "./fixed-primitive.js";
 import { writeU8FixedArray } from "./u8-array.js";
-export const readU16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readU16FixedArrayLe : readU16FixedArrayBe;
+import { readUintSafe32, writeUintSafe32 } from "./uint.js";
+export const readU16FixedArray = IS_LITTLE_ENDIAN_PLATFORM
+    ? readU16FixedArrayLe
+    : readU16FixedArrayBe;
 export function readU16Array(bc) {
-  return readU16FixedArray(bc, readUintSafe32(bc));
+    return readU16FixedArray(bc, readUintSafe32(bc));
 }
 function readU16FixedArrayLe(bc, len) {
-  if (DEV) {
-    assert(isU32(len));
-  }
-  const byteCount = len * 2;
-  return new Uint16Array(readFixedData(bc, byteCount));
+    if (DEV) {
+        assert(isU32(len));
+    }
+    const byteCount = len * 2;
+    return new Uint16Array(readFixedData(bc, byteCount));
 }
 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++) {
-    result[i] = readU16(bc);
-  }
-  return result;
+    if (DEV) {
+        assert(isU32(len));
+    }
+    check(bc, len * 2);
+    const result = new Uint16Array(len);
+    for (let i = 0; i < len; i++) {
+        result[i] = readU16(bc);
+    }
+    return result;
 }
 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);
-  }
+    writeUintSafe32(bc, x.length);
+    if (x.length > 0) {
+        writeU16FixedArray(bc, x);
+    }
 }
 function writeU16FixedArrayLe(bc, x) {
-  writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+    writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
 }
 function writeU16FixedArrayBe(bc, x) {
-  reserve(bc, x.length * 2);
-  for (let i = 0; i < x.length; i++) {
-    writeU16(bc, x[i]);
-  }
+    reserve(bc, x.length * 2);
+    for (let i = 0; i < x.length; i++) {
+        writeU16(bc, x[i]);
+    }
 }

package/dist/codec/u32-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 readU32FixedArray: (bc: ByteCursor, len: number) => Uint32Array<ArrayBuffer>;
 export declare function readU32Array(bc: ByteCursor): Uint32Array<ArrayBuffer>;
 export declare const writeU32FixedArray: (bc: ByteCursor, x: Uint32Array) => void;

package/dist/codec/u32-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 {
-  readU32,
-  readUintSafe32,
-  writeU32,
-  writeUintSafe32
-} from "./primitive.js";
+import { readU32, writeU32 } from "./fixed-primitive.js";
 import { writeU8FixedArray } from "./u8-array.js";
-export const readU32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readU32FixedArrayLe : readU32FixedArrayBe;
+import { readUintSafe32, writeUintSafe32 } from "./uint.js";
+export const readU32FixedArray = IS_LITTLE_ENDIAN_PLATFORM
+    ? readU32FixedArrayLe
+    : readU32FixedArrayBe;
 export function readU32Array(bc) {
-  return readU32FixedArray(bc, readUintSafe32(bc));
+    return readU32FixedArray(bc, readUintSafe32(bc));
 }
 function readU32FixedArrayLe(bc, len) {
-  if (DEV) {
-    assert(isU32(len));
-  }
-  const byteCount = len * 4;
-  return new Uint32Array(readFixedData(bc, byteCount));
+    if (DEV) {
+        assert(isU32(len));
+    }
+    const byteCount = len * 4;
+    return new Uint32Array(readFixedData(bc, byteCount));
 }
 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++) {
-    result[i] = readU32(bc);
-  }
-  return result;
+    if (DEV) {
+        assert(isU32(len));
+    }
+    check(bc, len * 4);
+    const result = new Uint32Array(len);
+    for (let i = 0; i < len; i++) {
+        result[i] = readU32(bc);
+    }
+    return result;
 }
 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);
-  }
+    writeUintSafe32(bc, x.length);
+    if (x.length > 0) {
+        writeU32FixedArray(bc, x);
+    }
 }
 function writeU32FixedArrayLe(bc, x) {
-  writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+    writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
 }
 function writeU32FixedArrayBe(bc, x) {
-  reserve(bc, x.length * 4);
-  for (let i = 0; i < x.length; i++) {
-    writeU32(bc, x[i]);
-  }
+    reserve(bc, x.length * 4);
+    for (let i = 0; i < x.length; i++) {
+        writeU32(bc, x[i]);
+    }
 }

package/dist/codec/u64-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 readU64FixedArray: (bc: ByteCursor, len: number) => BigUint64Array<ArrayBuffer>;
 export declare function readU64Array(bc: ByteCursor): BigUint64Array<ArrayBuffer>;
 export declare const writeU64FixedArray: (bc: ByteCursor, x: BigUint64Array) => void;