@bare-ts/lib 0.1.0 → 0.1.1

package/dist/codec/primitive.js

@@ -0,0 +1,352 @@
+// src/codec/primitive.ts
+import { ok as assert } from "assert";
+import { BareError } from "../core/index.js";
+import {
+  isI16,
+  isI32,
+  isI64,
+  isI8,
+  isSafeU64,
+  isU16,
+  isU32,
+  isU64,
+  isU8
+} from "../util/validator.js";
+var NAN_NOT_ALLOWED = "NaN is not allowed";
+var NON_CANONICAL_REPRESENTATION = "must be canonical";
+var TOO_LARGE_NUMBER = "too large number";
+function decodeBool(bc) {
+  const val = decodeU8(bc);
+  if (val > 1) {
+    bc.offset--;
+    throw new BareError(bc.offset, "a bool must be equal to 0 or 1");
+  }
+  return val !== 0;
+}
+function encodeBool(bc, x) {
+  encodeU8(bc, x ? 1 : 0);
+}
+function decodeF32(bc) {
+  bc.check(4);
+  const result = bc.view.getFloat32(bc.offset, true);
+  if (Number.isNaN(result)) {
+    throw new BareError(bc.offset, NAN_NOT_ALLOWED);
+  }
+  bc.offset += 4;
+  return result;
+}
+function encodeF32(bc, x) {
+  assert(!Number.isNaN(x), NAN_NOT_ALLOWED);
+  bc.reserve(4);
+  bc.view.setFloat32(bc.offset, x, true);
+  assert(Math.abs(bc.view.getFloat32(bc.offset, true) - x) <= Number.EPSILON, TOO_LARGE_NUMBER);
+  bc.offset += 4;
+}
+function decodeF64(bc) {
+  bc.check(8);
+  const result = bc.view.getFloat64(bc.offset, true);
+  if (Number.isNaN(result)) {
+    throw new BareError(bc.offset, NAN_NOT_ALLOWED);
+  }
+  bc.offset += 8;
+  return result;
+}
+function encodeF64(bc, x) {
+  assert(!Number.isNaN(x), NAN_NOT_ALLOWED);
+  bc.reserve(8);
+  bc.view.setFloat64(bc.offset, x, true);
+  bc.offset += 8;
+}
+function decodeI8(bc) {
+  bc.check(1);
+  return bc.view.getInt8(bc.offset++);
+}
+function encodeI8(bc, x) {
+  assert(isI8(x), TOO_LARGE_NUMBER);
+  bc.reserve(1);
+  bc.view.setInt8(bc.offset++, x);
+}
+function decodeI16(bc) {
+  bc.check(2);
+  const result = bc.view.getInt16(bc.offset, true);
+  bc.offset += 2;
+  return result;
+}
+function encodeI16(bc, x) {
+  assert(isI16(x), TOO_LARGE_NUMBER);
+  bc.reserve(2);
+  bc.view.setInt16(bc.offset, x, true);
+  bc.offset += 2;
+}
+function decodeI32(bc) {
+  bc.check(4);
+  const result = bc.view.getInt32(bc.offset, true);
+  bc.offset += 4;
+  return result;
+}
+function encodeI32(bc, x) {
+  assert(isI32(x), TOO_LARGE_NUMBER);
+  bc.reserve(4);
+  bc.view.setInt32(bc.offset, x, true);
+  bc.offset += 4;
+}
+function decodeI64(bc) {
+  bc.check(8);
+  const result = bc.view.getBigInt64(bc.offset, true);
+  bc.offset += 8;
+  return result;
+}
+function encodeI64(bc, x) {
+  assert(isI64(x), TOO_LARGE_NUMBER);
+  bc.reserve(8);
+  bc.view.setBigInt64(bc.offset, x, true);
+  bc.offset += 8;
+}
+function decodeI64Safe(bc) {
+  const result = decodeU32(bc) + decodeI32(bc) * 4294967296;
+  if (!Number.isSafeInteger(result)) {
+    bc.offset -= 8;
+    throw new BareError(bc.offset, TOO_LARGE_NUMBER);
+  }
+  return result;
+}
+function encodeI64Safe(bc, x) {
+  assert(Number.isSafeInteger(x), TOO_LARGE_NUMBER);
+  const lowest32 = x >>> 0;
+  encodeU32(bc, lowest32);
+  let highest32 = x / 4294967296 | 0;
+  if (x < 0) {
+    highest32 = ~Math.abs(highest32) >>> 0;
+    if (lowest32 === 0) {
+      highest32++;
+    }
+  }
+  encodeU32(bc, highest32);
+}
+function decodeInt(bc) {
+  const zigZag = decodeUint(bc);
+  return zigZag >> BigInt(1) ^ -(zigZag & BigInt(1));
+}
+function encodeInt(bc, x) {
+  assert(isI64(x), TOO_LARGE_NUMBER);
+  const zigZag = x >> BigInt(63) ^ x << BigInt(1);
+  encodeUint(bc, zigZag);
+}
+var INT_SAFE_MAX_BYTE_COUNT = 8;
+function decodeIntSafe(bc) {
+  const firstByte = decodeU8(bc);
+  let result = (firstByte & 127) >> 1;
+  if (firstByte >= 128) {
+    let shiftMul = 64;
+    let byteCount = 1;
+    let byte;
+    do {
+      byte = decodeU8(bc);
+      result += (byte & 127) * shiftMul;
+      shiftMul *= 128;
+      byteCount++;
+    } while (byte >= 128 && 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 > 31 || firstByte === 255)) {
+      bc.offset -= byteCount - 1;
+      throw new BareError(bc.offset, TOO_LARGE_NUMBER);
+    }
+  }
+  const isNeg = (firstByte & 1) === 1;
+  if (isNeg) {
+    result = -result - 1;
+  }
+  return result;
+}
+function encodeIntSafe(bc, x) {
+  assert(Number.isSafeInteger(x), TOO_LARGE_NUMBER);
+  const sign = x < 0 ? 1 : 0;
+  if (x < 0) {
+    x = -(x + 1);
+  }
+  const firstByte = (x & 63) << 1 | sign;
+  x = Math.floor(x / 64);
+  if (x > 0) {
+    encodeU8(bc, 128 | firstByte);
+    encodeUintSafe(bc, x);
+  } else {
+    encodeU8(bc, firstByte);
+  }
+}
+function decodeU8(bc) {
+  bc.check(1);
+  return bc.view.getUint8(bc.offset++);
+}
+function encodeU8(bc, x) {
+  assert(isU8(x), TOO_LARGE_NUMBER);
+  bc.reserve(1);
+  bc.view.setUint8(bc.offset++, x);
+}
+function decodeU16(bc) {
+  bc.check(2);
+  const result = bc.view.getUint16(bc.offset, true);
+  bc.offset += 2;
+  return result;
+}
+function encodeU16(bc, x) {
+  assert(isU16(x), TOO_LARGE_NUMBER);
+  bc.reserve(2);
+  bc.view.setUint16(bc.offset, x, true);
+  bc.offset += 2;
+}
+function decodeU32(bc) {
+  bc.check(4);
+  const result = bc.view.getUint32(bc.offset, true);
+  bc.offset += 4;
+  return result;
+}
+function encodeU32(bc, x) {
+  assert(isU32(x), TOO_LARGE_NUMBER);
+  bc.reserve(4);
+  bc.view.setUint32(bc.offset, x, true);
+  bc.offset += 4;
+}
+function decodeU64(bc) {
+  bc.check(8);
+  const result = bc.view.getBigUint64(bc.offset, true);
+  bc.offset += 8;
+  return result;
+}
+function encodeU64(bc, x) {
+  assert(isU64(x), TOO_LARGE_NUMBER);
+  bc.reserve(8);
+  bc.view.setBigUint64(bc.offset, x, true);
+  bc.offset += 8;
+}
+function decodeU64Safe(bc) {
+  const result = decodeU32(bc) + decodeU32(bc) * 4294967296;
+  if (!isSafeU64(result)) {
+    bc.offset -= 8;
+    throw new BareError(bc.offset, TOO_LARGE_NUMBER);
+  }
+  return result;
+}
+function encodeU64Safe(bc, x) {
+  assert(isSafeU64(x), TOO_LARGE_NUMBER);
+  encodeU32(bc, x >>> 0);
+  encodeU32(bc, x / 4294967296 >>> 0);
+}
+var UINT_MAX_BYTE_COUNT = 10;
+function decodeUint(bc) {
+  let byteCount = 0;
+  let byte;
+  let low = 0;
+  let shiftMul = 1;
+  do {
+    byte = decodeU8(bc);
+    low += (byte & 127) * shiftMul;
+    shiftMul *= 128;
+    byteCount++;
+  } while (byte >= 128 && byteCount < 7);
+  let height = 0;
+  shiftMul = 1;
+  while (byte >= 128 && byteCount < UINT_MAX_BYTE_COUNT) {
+    byte = decodeU8(bc);
+    height += (byte & 127) * shiftMul;
+    shiftMul *= 128;
+    byteCount++;
+  }
+  if (byteCount !== 1 && byte === 0 || byteCount === UINT_MAX_BYTE_COUNT && byte > 1) {
+    bc.offset -= byteCount;
+    throw new BareError(bc.offset, NON_CANONICAL_REPRESENTATION);
+  }
+  return BigInt(low) + (BigInt(height) << BigInt(7 * 7));
+}
+function encodeUint(bc, x) {
+  assert(isU64(x), TOO_LARGE_NUMBER);
+  let tmp = Number(BigInt.asUintN(7 * 7, x));
+  let rest = Number(x >> BigInt(7 * 7));
+  let byteCount = 0;
+  while (tmp >= 128 || rest !== 0) {
+    encodeU8(bc, 128 | tmp & 127);
+    tmp = Math.floor(tmp / 128);
+    byteCount++;
+    if (byteCount === 7) {
+      tmp = rest;
+      rest = 0;
+    }
+  }
+  encodeU8(bc, tmp);
+}
+var UINT_SAFE_MAX_BYTE_COUNT = 8;
+function decodeUintSafe(bc) {
+  let result = 0;
+  let shiftMul = 1;
+  let byteCount = 0;
+  let byte;
+  do {
+    byte = decodeU8(bc);
+    result += (byte & 127) * shiftMul;
+    shiftMul *= 128;
+    byteCount++;
+  } while (byte >= 128 && byteCount < UINT_SAFE_MAX_BYTE_COUNT);
+  if (byteCount !== 1 && byte === 0) {
+    bc.offset -= byteCount - 1;
+    throw new BareError(bc.offset - byteCount + 1, NON_CANONICAL_REPRESENTATION);
+  }
+  if (byteCount === UINT_SAFE_MAX_BYTE_COUNT && byte > 15) {
+    bc.offset -= byteCount - 1;
+    throw new BareError(bc.offset, TOO_LARGE_NUMBER);
+  }
+  return result;
+}
+function encodeUintSafe(bc, x) {
+  assert(isSafeU64(x), TOO_LARGE_NUMBER);
+  while (x >= 128) {
+    encodeU8(bc, 128 | x & 127);
+    x = Math.floor(x / 128);
+  }
+  encodeU8(bc, x);
+}
+function decodeVoid(_dc) {
+  return void 0;
+}
+function encodeVoid(_dc, _x) {
+}
+export {
+  decodeBool,
+  decodeF32,
+  decodeF64,
+  decodeI16,
+  decodeI32,
+  decodeI64,
+  decodeI64Safe,
+  decodeI8,
+  decodeInt,
+  decodeIntSafe,
+  decodeU16,
+  decodeU32,
+  decodeU64,
+  decodeU64Safe,
+  decodeU8,
+  decodeUint,
+  decodeUintSafe,
+  decodeVoid,
+  encodeBool,
+  encodeF32,
+  encodeF64,
+  encodeI16,
+  encodeI32,
+  encodeI64,
+  encodeI64Safe,
+  encodeI8,
+  encodeInt,
+  encodeIntSafe,
+  encodeU16,
+  encodeU32,
+  encodeU64,
+  encodeU64Safe,
+  encodeU8,
+  encodeUint,
+  encodeUintSafe,
+  encodeVoid
+};
+//# sourceMappingURL=primitive.js.map

package/dist/codec/string.js

@@ -0,0 +1,122 @@
+// src/codec/string.ts
+import { BareError } from "../core/bare-error.js";
+import { decodeUintSafe, encodeUintSafe } from "./primitive.js";
+function decodeString(bc) {
+  const strBytesLen = decodeUintSafe(bc);
+  const strBytes = bc.read(strBytesLen);
+  try {
+    return strBytesLen < bc.config.textDecoderThreshold ? decodeUtf8Js(strBytes) : UTF8_DECODER.decode(strBytes);
+  } catch (cause) {
+    throw new BareError(bc.offset - strBytesLen, "invalid UTF-8 string", {
+      cause
+    });
+  }
+}
+function encodeString(bc, x) {
+  if (x.length < bc.config.textEncoderThreshold) {
+    const byteLen = utf8ByteLength(x);
+    encodeUintSafe(bc, byteLen);
+    bc.reserve(byteLen);
+    encodeUtf8Js(bc, x);
+  } else {
+    const strBytes = UTF8_ENCODER.encode(x);
+    encodeUintSafe(bc, strBytes.length);
+    bc.write(strBytes);
+  }
+}
+function decodeUtf8Js(bytes) {
+  const bytesLen = bytes.length;
+  let result = "";
+  let i = 0;
+  while (i < bytesLen) {
+    let codePoint = bytes[i++] | 0;
+    switch (Math.clz32(~codePoint << 24)) {
+      case 0:
+        break;
+      case 2: {
+        if (i < bytesLen) {
+          codePoint = (codePoint & 31) << 6 | bytes[i] & 63;
+        }
+        if (codePoint >> 7 === 0 || bytes[i] >> 6 !== 2) {
+          throw TypeError("Decoding failed");
+        }
+        i += 1;
+        break;
+      }
+      case 3: {
+        if (i + 1 < bytesLen) {
+          codePoint = (codePoint & 15) << 12 | (bytes[i] & 63) << 6 | bytes[i + 1] & 63;
+        }
+        if (codePoint >> 11 === 0 || bytes[i] >> 6 !== 2 || bytes[i + 1] >> 6 !== 2 || codePoint >> 11 === 27) {
+          throw TypeError("Decoding failed");
+        }
+        i += 2;
+        break;
+      }
+      case 4: {
+        if (i + 2 < bytesLen) {
+          codePoint = (codePoint & 7) << 18 | (bytes[i] & 63) << 12 | (bytes[i + 1] & 63) << 6 | bytes[i + 2] & 63;
+        }
+        if (codePoint >> 16 === 0 || codePoint > 1114111 || bytes[i] >> 6 !== 2 || bytes[i + 1] >> 6 !== 2 || bytes[i + 2] >> 6 !== 2) {
+          throw TypeError("Decoding failed");
+        }
+        i += 3;
+        break;
+      }
+      default:
+        throw TypeError("Decoding failed");
+    }
+    result += String.fromCodePoint(codePoint);
+  }
+  return result;
+}
+function encodeUtf8Js(bc, s) {
+  const sLen = s.length;
+  let offset = bc.offset;
+  const view = bc.view;
+  let i = 0;
+  while (i < sLen) {
+    const codePoint = s.codePointAt(i++);
+    if (codePoint < 128) {
+      view.setUint8(offset++, codePoint);
+    } else if (codePoint < 2048) {
+      view.setUint8(offset++, 192 | codePoint >> 6);
+      view.setUint8(offset++, 128 | codePoint & 63);
+    } else if (codePoint < 65536) {
+      view.setUint8(offset++, 224 | codePoint >> 12);
+      view.setUint8(offset++, 128 | codePoint >> 6 & 63);
+      view.setUint8(offset++, 128 | codePoint & 63);
+    } else {
+      view.setUint8(offset++, 240 | codePoint >> 18);
+      view.setUint8(offset++, 128 | codePoint >> 12 & 63);
+      view.setUint8(offset++, 128 | codePoint >> 6 & 63);
+      view.setUint8(offset++, 128 | codePoint & 63);
+      i++;
+    }
+  }
+  bc.offset = offset;
+}
+function utf8ByteLength(s) {
+  const sLen = s.length;
+  let result = sLen;
+  for (let i = 0; i < sLen; i++) {
+    const codePoint = s.codePointAt(i);
+    if (codePoint >= 128) {
+      result++;
+      if (codePoint >= 2048) {
+        result++;
+        if (codePoint >= 65536) {
+          i++;
+        }
+      }
+    }
+  }
+  return result;
+}
+var UTF8_DECODER = new TextDecoder("utf-8", { fatal: true });
+var UTF8_ENCODER = new TextEncoder();
+export {
+  decodeString,
+  encodeString
+};
+//# sourceMappingURL=string.js.map

package/dist/codec/u16-array.js

@@ -0,0 +1,50 @@
+// src/codec/u16-array.ts
+import { ok as assert } from "assert";
+import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
+import { decodeFixedData } from "./data.js";
+import {
+  decodeU16,
+  decodeUintSafe,
+  encodeU16,
+  encodeUintSafe
+} from "./primitive.js";
+var U16_BYTE_COUNT = 2;
+var decodeU16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeU16FixedArrayLE : decodeU16FixedArrayBE;
+function decodeU16Array(bc) {
+  return decodeU16FixedArray(bc, decodeUintSafe(bc));
+}
+function decodeU16FixedArrayLE(bc, len) {
+  const byteCount = len * U16_BYTE_COUNT;
+  return new Uint16Array(decodeFixedData(bc, byteCount));
+}
+function decodeU16FixedArrayBE(bc, len) {
+  bc.check(len * U16_BYTE_COUNT);
+  const result = new Uint16Array(len);
+  for (let i = 0; i < len; i++)
+    result[i] = decodeU16(bc);
+  return result;
+}
+var encodeU16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? encodeU16FixedArrayLE : encodeU16FixedArrayBE;
+function encodeU16Array(bc, x) {
+  encodeUintSafe(bc, x.length);
+  if (x.length !== 0) {
+    encodeU16FixedArray(bc, x, x.length);
+  }
+}
+function encodeU16FixedArrayLE(bc, x, len) {
+  assert(x.length === len);
+  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+}
+function encodeU16FixedArrayBE(bc, x, len) {
+  assert(x.length === len);
+  bc.reserve(x.length * U16_BYTE_COUNT);
+  for (let i = 0; i < x.length; i++)
+    encodeU16(bc, x[i]);
+}
+export {
+  decodeU16Array,
+  decodeU16FixedArray,
+  encodeU16Array,
+  encodeU16FixedArray
+};
+//# sourceMappingURL=u16-array.js.map

package/dist/codec/u32-array.js

@@ -0,0 +1,50 @@
+// src/codec/u32-array.ts
+import { ok as assert } from "assert";
+import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
+import { decodeFixedData } from "./data.js";
+import {
+  decodeU32,
+  decodeUintSafe,
+  encodeU32,
+  encodeUintSafe
+} from "./primitive.js";
+var U32_BYTE_COUNT = 4;
+var decodeU32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeU32FixedArrayLE : decodeU32FixedArrayBE;
+function decodeU32Array(bc) {
+  return decodeU32FixedArray(bc, decodeUintSafe(bc));
+}
+function decodeU32FixedArrayLE(bc, len) {
+  const byteCount = len * U32_BYTE_COUNT;
+  return new Uint32Array(decodeFixedData(bc, byteCount));
+}
+function decodeU32FixedArrayBE(bc, len) {
+  bc.check(len * U32_BYTE_COUNT);
+  const result = new Uint32Array(len);
+  for (let i = 0; i < len; i++)
+    result[i] = decodeU32(bc);
+  return result;
+}
+var encodeU32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? encodeU32FixedArrayLE : encodeU32FixedArrayBE;
+function encodeU32Array(bc, x) {
+  encodeUintSafe(bc, x.length);
+  if (x.length !== 0) {
+    encodeU32FixedArray(bc, x, x.length);
+  }
+}
+function encodeU32FixedArrayLE(bc, x, len) {
+  assert(x.length === len);
+  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+}
+function encodeU32FixedArrayBE(bc, x, len) {
+  assert(x.length === len);
+  bc.reserve(x.length * U32_BYTE_COUNT);
+  for (let i = 0; i < x.length; i++)
+    encodeU32(bc, x[i]);
+}
+export {
+  decodeU32Array,
+  decodeU32FixedArray,
+  encodeU32Array,
+  encodeU32FixedArray
+};
+//# sourceMappingURL=u32-array.js.map

package/dist/codec/u64-array.js

@@ -0,0 +1,50 @@
+// src/codec/u64-array.ts
+import { ok as assert } from "assert";
+import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
+import { decodeFixedData } from "./data.js";
+import {
+  decodeU64,
+  decodeUintSafe,
+  encodeU64,
+  encodeUintSafe
+} from "./primitive.js";
+var U64_BYTE_COUNT = 8;
+var decodeU64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeU64FixedArrayLE : decodeU64FixedArrayBE;
+function decodeU64Array(bc) {
+  return decodeU64FixedArray(bc, decodeUintSafe(bc));
+}
+function decodeU64FixedArrayLE(bc, len) {
+  const byteCount = len * U64_BYTE_COUNT;
+  return new BigUint64Array(decodeFixedData(bc, byteCount));
+}
+function decodeU64FixedArrayBE(bc, len) {
+  bc.check(len * U64_BYTE_COUNT);
+  const result = new BigUint64Array(len);
+  for (let i = 0; i < len; i++)
+    result[i] = decodeU64(bc);
+  return result;
+}
+var encodeU64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? encodeU64FixedArrayLE : encodeU64FixedArrayBE;
+function encodeU64Array(bc, x) {
+  encodeUintSafe(bc, x.length);
+  if (x.length !== 0) {
+    encodeU64FixedArray(bc, x, x.length);
+  }
+}
+function encodeU64FixedArrayLE(bc, x, len) {
+  assert(x.length === len);
+  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+}
+function encodeU64FixedArrayBE(bc, x, len) {
+  assert(x.length === len);
+  bc.reserve(x.length * U64_BYTE_COUNT);
+  for (let i = 0; i < x.length; i++)
+    encodeU64(bc, x[i]);
+}
+export {
+  decodeU64Array,
+  decodeU64FixedArray,
+  encodeU64Array,
+  encodeU64FixedArray
+};
+//# sourceMappingURL=u64-array.js.map

package/dist/codec/u8-array.js

@@ -0,0 +1,25 @@
+// src/codec/u8-array.ts
+import { ok as assert } from "assert";
+import { decodeUintSafe, encodeUintSafe } from "./primitive.js";
+function decodeU8Array(bc) {
+  const len = decodeUintSafe(bc);
+  return bc.read(len).slice();
+}
+function encodeU8Array(bc, x) {
+  encodeUintSafe(bc, x.length);
+  bc.write(x);
+}
+function decodeU8FixedArray(bc, len) {
+  return bc.read(len).slice();
+}
+function encodeU8FixedArray(bc, x, len) {
+  assert(x.length === len);
+  bc.write(x);
+}
+export {
+  decodeU8Array,
+  decodeU8FixedArray,
+  encodeU8Array,
+  encodeU8FixedArray
+};
+//# sourceMappingURL=u8-array.js.map

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

@@ -0,0 +1,24 @@
+// src/codec/u8-clamped-array.ts
+import { decodeFixedData } from "./data.js";
+import { decodeUintSafe, encodeUintSafe } from "./primitive.js";
+import { encodeU8FixedArray } from "./u8-array.js";
+function decodeU8ClampedArray(bc) {
+  return decodeU8ClampedFixedArray(bc, decodeUintSafe(bc));
+}
+function encodeU8ClampedArray(bc, x) {
+  encodeUintSafe(bc, x.length);
+  encodeU8ClampedFixedArray(bc, x, x.length);
+}
+function decodeU8ClampedFixedArray(bc, len) {
+  return new Uint8ClampedArray(decodeFixedData(bc, len));
+}
+function encodeU8ClampedFixedArray(bc, x, len) {
+  encodeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength), len);
+}
+export {
+  decodeU8ClampedArray,
+  decodeU8ClampedFixedArray,
+  encodeU8ClampedArray,
+  encodeU8ClampedFixedArray
+};
+//# sourceMappingURL=u8-clamped-array.js.map

package/dist/core/bare-error.js

@@ -0,0 +1,14 @@
+// src/core/bare-error.ts
+var BareError = class extends Error {
+  constructor(offset, issue, opts) {
+    super(`(byte:${offset}) ${issue}`);
+    this.name = "BareError";
+    this.issue = issue;
+    this.offset = offset;
+    this.cause = opts == null ? void 0 : opts.cause;
+  }
+};
+export {
+  BareError
+};
+//# sourceMappingURL=bare-error.js.map