@bare-ts/lib 0.1.0 → 0.1.1

package/dist/index.js

@@ -1,988 +1,4 @@
-// src/codec/u8-array.ts
-import assert4 from "assert";
-
-// src/codec/primitive.ts
-import assert3 from "assert";
-
-// 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;
-  }
-};
-
-// src/core/config.ts
-import assert from "assert";
-
-// src/util/validator.ts
-function isI8(val) {
-  return val === val << 24 >> 24;
-}
-function isI16(val) {
-  return val === val << 16 >> 16;
-}
-function isI32(val) {
-  return val === (val | 0);
-}
-function isI64(val) {
-  return val === BigInt.asIntN(64, val);
-}
-function isSafeU64(val) {
-  return Number.isSafeInteger(val) && val >= 0;
-}
-function isU8(val) {
-  return val === (val & 255);
-}
-function isU16(val) {
-  return val === (val & 65535);
-}
-function isU32(val) {
-  return val === val >>> 0;
-}
-function isU64(val) {
-  return val === BigInt.asUintN(64, val);
-}
-
-// src/core/config.ts
-var TOO_LARGE_NUMBER = "too large number";
-var initialBufferLength = 1024;
-var maxBufferLength = 1024 * 1024 * 32;
-var textDecoderThreshold = 256;
-var textEncoderThreshold = 256;
-function Config(part) {
-  const config = Object.assign({
-    initialBufferLength,
-    maxBufferLength,
-    textDecoderThreshold,
-    textEncoderThreshold
-  }, part);
-  assert(isU32(config.initialBufferLength), TOO_LARGE_NUMBER);
-  assert(isU32(config.maxBufferLength), TOO_LARGE_NUMBER);
-  assert(isU32(config.textDecoderThreshold), TOO_LARGE_NUMBER);
-  assert(isU32(config.textEncoderThreshold), TOO_LARGE_NUMBER);
-  assert(config.initialBufferLength <= config.maxBufferLength, "initialBufferLength must be lower than or equal to maxBufferLength");
-  return config;
-}
-
-// src/core/byte-cursor.ts
-import assert2 from "assert";
-var TOO_LARGE_BUFFER = "too large buffer";
-var ByteCursor = class {
-  constructor(bytes, config) {
-    this.config = config;
-    this.offset = 0;
-    this.view = bytes instanceof Uint8Array ? new DataView(bytes.buffer, bytes.byteOffset, bytes.length) : new DataView(bytes);
-    if (this.view.byteLength > config.maxBufferLength) {
-      throw new BareError(0, TOO_LARGE_BUFFER);
-    }
-  }
-  check(min) {
-    if (this.offset + min > this.view.byteLength) {
-      throw new BareError(this.offset, "missing bytes");
-    }
-  }
-  reserve(min) {
-    const { config, offset, view } = this;
-    if (offset + min > view.byteLength) {
-      const bytes = new Uint8Array(view.buffer);
-      const minExtraLength = min + offset - view.byteLength;
-      assert2(bytes.length === view.byteOffset + view.byteLength, "un-growable buffer");
-      assert2(bytes.length + minExtraLength <= config.maxBufferLength, TOO_LARGE_BUFFER);
-      const newLen = Math.min(bytes.length + Math.max(minExtraLength, bytes.length), config.maxBufferLength);
-      const newBytes = new Uint8Array(newLen);
-      newBytes.set(bytes);
-      this.view = new DataView(newBytes.buffer, view.byteOffset);
-    }
-  }
-  read(len) {
-    this.check(len);
-    const bufferOffset = this.view.byteOffset + this.offset;
-    this.offset += len;
-    return new Uint8Array(this.view.buffer, bufferOffset, len);
-  }
-  write(bytes) {
-    const len = bytes.length;
-    if (len !== 0) {
-      this.reserve(len);
-      const writableArea = new Uint8Array(this.view.buffer, this.offset, len);
-      writableArea.set(bytes);
-      this.offset += len;
-    }
-  }
-};
-
-// src/codec/primitive.ts
-var NAN_NOT_ALLOWED = "NaN is not allowed";
-var NON_CANONICAL_REPRESENTATION = "must be canonical";
-var TOO_LARGE_NUMBER2 = "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) {
-  assert3(!Number.isNaN(x), NAN_NOT_ALLOWED);
-  bc.reserve(4);
-  bc.view.setFloat32(bc.offset, x, true);
-  assert3(Math.abs(bc.view.getFloat32(bc.offset, true) - x) <= Number.EPSILON, TOO_LARGE_NUMBER2);
-  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) {
-  assert3(!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) {
-  assert3(isI8(x), TOO_LARGE_NUMBER2);
-  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) {
-  assert3(isI16(x), TOO_LARGE_NUMBER2);
-  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) {
-  assert3(isI32(x), TOO_LARGE_NUMBER2);
-  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) {
-  assert3(isI64(x), TOO_LARGE_NUMBER2);
-  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_NUMBER2);
-  }
-  return result;
-}
-function encodeI64Safe(bc, x) {
-  assert3(Number.isSafeInteger(x), TOO_LARGE_NUMBER2);
-  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) {
-  assert3(isI64(x), TOO_LARGE_NUMBER2);
-  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_NUMBER2);
-    }
-  }
-  const isNeg = (firstByte & 1) === 1;
-  if (isNeg) {
-    result = -result - 1;
-  }
-  return result;
-}
-function encodeIntSafe(bc, x) {
-  assert3(Number.isSafeInteger(x), TOO_LARGE_NUMBER2);
-  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) {
-  assert3(isU8(x), TOO_LARGE_NUMBER2);
-  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) {
-  assert3(isU16(x), TOO_LARGE_NUMBER2);
-  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) {
-  assert3(isU32(x), TOO_LARGE_NUMBER2);
-  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) {
-  assert3(isU64(x), TOO_LARGE_NUMBER2);
-  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_NUMBER2);
-  }
-  return result;
-}
-function encodeU64Safe(bc, x) {
-  assert3(isSafeU64(x), TOO_LARGE_NUMBER2);
-  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) {
-  assert3(isU64(x), TOO_LARGE_NUMBER2);
-  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_NUMBER2);
-  }
-  return result;
-}
-function encodeUintSafe(bc, x) {
-  assert3(isSafeU64(x), TOO_LARGE_NUMBER2);
-  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) {
-}
-
-// src/codec/u8-array.ts
-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) {
-  assert4(x.length === len);
-  bc.write(x);
-}
-
-// src/codec/data.ts
-function decodeData(bc) {
-  return decodeU8Array(bc).buffer;
-}
-function encodeData(bc, x) {
-  encodeU8Array(bc, new Uint8Array(x));
-}
-function decodeFixedData(bc, len) {
-  return decodeU8FixedArray(bc, len).buffer;
-}
-function encodeFixedData(bc, x, len) {
-  encodeU8FixedArray(bc, new Uint8Array(x), len);
-}
-
-// src/codec/float-array.ts
-import assert5 from "assert";
-
-// src/util/util.ts
-var IS_LITTLE_ENDIAN_PLATFORM = new DataView(Uint16Array.of(1).buffer).getUint8(0) === 1;
-
-// src/codec/float-array.ts
-var NAN_NOT_ALLOWED2 = "NaN is not allowed";
-var decodeF32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeF32FixedArrayLE : decodeF32FixedArrayBE;
-function decodeF32FixedArrayLE(bc, len) {
-  const byteLen = len * 4;
-  const result = new Float32Array(decodeFixedData(bc, byteLen));
-  if (result.some(Number.isNaN)) {
-    throw new BareError(bc.offset, NAN_NOT_ALLOWED2);
-  }
-  return result;
-}
-function decodeF32FixedArrayBE(bc, len) {
-  bc.check(len * 4);
-  const result = new Float32Array(len);
-  for (let i = 0; i < len; i++)
-    result[i] = decodeF32(bc);
-  return result;
-}
-var encodeF32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? encodeF32FixedArrayLE : encodeF32FixedArrayBE;
-function encodeF32FixedArrayLE(bc, x, len) {
-  assert5(x.length === len);
-  assert5(!x.every(Number.isNaN), NAN_NOT_ALLOWED2);
-  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
-}
-function encodeF32FixedArrayBE(bc, val, len) {
-  assert5(val.length === len);
-  bc.reserve(val.length * 4);
-  for (let i = 0; i < val.length; i++)
-    encodeF32(bc, val[i]);
-}
-function decodeF32Array(bc) {
-  return decodeF32FixedArray(bc, decodeUintSafe(bc));
-}
-function encodeF32Array(bc, x) {
-  encodeUintSafe(bc, x.length);
-  if (x.length !== 0) {
-    encodeF32FixedArray(bc, x, x.length);
-  }
-}
-var decodeF64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeF64FixedArrayLE : decodeF64FixedArrayBE;
-function decodeF64FixedArrayLE(bc, len) {
-  const byteLen = len * 8;
-  const result = new Float64Array(decodeFixedData(bc, byteLen));
-  if (result.some(Number.isNaN)) {
-    throw new BareError(bc.offset, NAN_NOT_ALLOWED2);
-  }
-  return result;
-}
-function decodeF64FixedArrayBE(bc, len) {
-  bc.check(len * 8);
-  const result = new Float64Array(len);
-  for (let i = 0; i < len; i++)
-    result[i] = decodeF64(bc);
-  return result;
-}
-var encodeF64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? encodeF64FixedArrayLE : encodeF64FixedArrayBE;
-function encodeF64FixedArrayLE(bc, x, len) {
-  assert5(x.length === len);
-  assert5(!x.every(Number.isNaN), NAN_NOT_ALLOWED2);
-  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
-}
-function encodeF64FixedArrayBE(bc, x, len) {
-  assert5(x.length === len);
-  bc.reserve(x.length * 8);
-  for (let i = 0; i < x.length; i++)
-    encodeF64(bc, x[i]);
-}
-function decodeF64Array(bc) {
-  return decodeF64FixedArray(bc, decodeUintSafe(bc));
-}
-function encodeF64Array(bc, x) {
-  encodeUintSafe(bc, x.length);
-  if (x.length !== 0) {
-    encodeF64FixedArray(bc, x, x.length);
-  }
-}
-
-// src/codec/i16-array.ts
-import assert6 from "assert";
-var I16_BYTE_COUNT = 2;
-var decodeI16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeI16FixedArrayLE : decodeI16FixedArrayBE;
-function decodeI16Array(bc) {
-  return decodeI16FixedArray(bc, decodeUintSafe(bc));
-}
-function decodeI16FixedArrayLE(bc, len) {
-  const byteCount = len * I16_BYTE_COUNT;
-  return new Int16Array(decodeFixedData(bc, byteCount));
-}
-function decodeI16FixedArrayBE(bc, len) {
-  bc.check(len * I16_BYTE_COUNT);
-  const result = new Int16Array(len);
-  for (let i = 0; i < len; i++)
-    result[i] = decodeI16(bc);
-  return result;
-}
-var encodeI16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? encodeI16FixedArrayLE : encodeI16FixedArrayBE;
-function encodeI16Array(bc, x) {
-  encodeUintSafe(bc, x.length);
-  if (x.length !== 0) {
-    encodeI16FixedArray(bc, x, x.length);
-  }
-}
-function encodeI16FixedArrayLE(bc, x, len) {
-  assert6(x.length === len);
-  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
-}
-function encodeI16FixedArrayBE(bc, x, len) {
-  assert6(x.length === len);
-  bc.reserve(x.length * I16_BYTE_COUNT);
-  for (let i = 0; i < x.length; i++)
-    encodeI16(bc, x[i]);
-}
-
-// src/codec/i32-array.ts
-import assert7 from "assert";
-var I32_BYTE_COUNT = 4;
-var decodeI32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeI32FixedArrayLE : decodeI32FixedArrayBE;
-function decodeI32Array(bc) {
-  return decodeI32FixedArray(bc, decodeUintSafe(bc));
-}
-function decodeI32FixedArrayLE(bc, len) {
-  const byteCount = len * I32_BYTE_COUNT;
-  return new Int32Array(decodeFixedData(bc, byteCount));
-}
-function decodeI32FixedArrayBE(bc, len) {
-  bc.check(len * I32_BYTE_COUNT);
-  const result = new Int32Array(len);
-  for (let i = 0; i < len; i++)
-    result[i] = decodeI32(bc);
-  return result;
-}
-var encodeI32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? encodeI32FixedArrayLE : encodeI32FixedArrayBE;
-function encodeI32Array(bc, x) {
-  encodeUintSafe(bc, x.length);
-  if (x.length !== 0) {
-    encodeI32FixedArray(bc, x, x.length);
-  }
-}
-function encodeI32FixedArrayLE(bc, x, len) {
-  assert7(x.length === len);
-  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
-}
-function encodeI32FixedArrayBE(bc, x, len) {
-  assert7(x.length === len);
-  bc.reserve(x.length * I32_BYTE_COUNT);
-  for (let i = 0; i < x.length; i++)
-    encodeI32(bc, x[i]);
-}
-
-// src/codec/i64-array.ts
-import assert8 from "assert";
-var I64_BYTE_COUNT = 8;
-var decodeI64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeI64FixedArrayLE : decodeI64FixedArrayBE;
-function decodeI64Array(bc) {
-  return decodeI64FixedArray(bc, decodeUintSafe(bc));
-}
-function decodeI64FixedArrayLE(bc, len) {
-  const byteCount = len * I64_BYTE_COUNT;
-  return new BigInt64Array(decodeFixedData(bc, byteCount));
-}
-function decodeI64FixedArrayBE(bc, len) {
-  bc.check(len * I64_BYTE_COUNT);
-  const result = new BigInt64Array(len);
-  for (let i = 0; i < len; i++)
-    result[i] = decodeI64(bc);
-  return result;
-}
-var encodeI64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? encodeI64FixedArrayLE : encodeI64FixedArrayBE;
-function encodeI64Array(bc, x) {
-  encodeUintSafe(bc, x.length);
-  if (x.length !== 0) {
-    encodeI64FixedArray(bc, x, x.length);
-  }
-}
-function encodeI64FixedArrayLE(bc, x, len) {
-  assert8(x.length === len);
-  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
-}
-function encodeI64FixedArrayBE(bc, x, len) {
-  assert8(x.length === len);
-  bc.reserve(x.length * I64_BYTE_COUNT);
-  for (let i = 0; i < x.length; i++)
-    encodeI64(bc, x[i]);
-}
-
-// src/codec/i8-array.ts
-function decodeI8Array(bc) {
-  return decodeI8FixedArray(bc, decodeUintSafe(bc));
-}
-function encodeI8Array(bc, x) {
-  encodeUintSafe(bc, x.length);
-  encodeI8FixedArray(bc, x, x.length);
-}
-function decodeI8FixedArray(bc, len) {
-  return new Int8Array(decodeFixedData(bc, len));
-}
-function encodeI8FixedArray(bc, x, len) {
-  encodeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength), len);
-}
-
-// src/codec/string.ts
-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 = 0;
-  let i = 0;
-  while (i < sLen) {
-    const codePoint = s.codePointAt(i);
-    i++;
-    if (codePoint < 128) {
-      result++;
-    } else if (codePoint < 2048) {
-      result += 2;
-    } else if (codePoint < 65536) {
-      result += 3;
-    } else {
-      result += 4;
-      i++;
-    }
-  }
-  return result;
-}
-var UTF8_DECODER = new TextDecoder("utf-8", { fatal: true });
-var UTF8_ENCODER = new TextEncoder();
-
-// src/codec/u16-array.ts
-import assert9 from "assert";
-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) {
-  assert9(x.length === len);
-  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
-}
-function encodeU16FixedArrayBE(bc, x, len) {
-  assert9(x.length === len);
-  bc.reserve(x.length * U16_BYTE_COUNT);
-  for (let i = 0; i < x.length; i++)
-    encodeU16(bc, x[i]);
-}
-
-// src/codec/u32-array.ts
-import assert10 from "assert";
-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) {
-  assert10(x.length === len);
-  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
-}
-function encodeU32FixedArrayBE(bc, x, len) {
-  assert10(x.length === len);
-  bc.reserve(x.length * U32_BYTE_COUNT);
-  for (let i = 0; i < x.length; i++)
-    encodeU32(bc, x[i]);
-}
-
-// src/codec/u64-array.ts
-import assert11 from "assert";
-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) {
-  assert11(x.length === len);
-  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
-}
-function encodeU64FixedArrayBE(bc, x, len) {
-  assert11(x.length === len);
-  bc.reserve(x.length * U64_BYTE_COUNT);
-  for (let i = 0; i < x.length; i++)
-    encodeU64(bc, x[i]);
-}
-
-// src/codec/u8-clamped-array.ts
-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 {
-  BareError,
-  ByteCursor,
-  Config,
-  decodeBool,
-  decodeData,
-  decodeF32,
-  decodeF32Array,
-  decodeF32FixedArray,
-  decodeF64,
-  decodeF64Array,
-  decodeF64FixedArray,
-  decodeFixedData,
-  decodeI16,
-  decodeI16Array,
-  decodeI16FixedArray,
-  decodeI32,
-  decodeI32Array,
-  decodeI32FixedArray,
-  decodeI64,
-  decodeI64Array,
-  decodeI64FixedArray,
-  decodeI64Safe,
-  decodeI8,
-  decodeI8Array,
-  decodeI8FixedArray,
-  decodeInt,
-  decodeIntSafe,
-  decodeString,
-  decodeU16,
-  decodeU16Array,
-  decodeU16FixedArray,
-  decodeU32,
-  decodeU32Array,
-  decodeU32FixedArray,
-  decodeU64,
-  decodeU64Array,
-  decodeU64FixedArray,
-  decodeU64Safe,
-  decodeU8,
-  decodeU8Array,
-  decodeU8ClampedArray,
-  decodeU8ClampedFixedArray,
-  decodeU8FixedArray,
-  decodeUint,
-  decodeUintSafe,
-  decodeVoid,
-  encodeBool,
-  encodeData,
-  encodeF32,
-  encodeF32Array,
-  encodeF32FixedArray,
-  encodeF64,
-  encodeF64Array,
-  encodeF64FixedArray,
-  encodeFixedData,
-  encodeI16,
-  encodeI16Array,
-  encodeI16FixedArray,
-  encodeI32,
-  encodeI32Array,
-  encodeI32FixedArray,
-  encodeI64,
-  encodeI64Array,
-  encodeI64FixedArray,
-  encodeI64Safe,
-  encodeI8,
-  encodeI8Array,
-  encodeI8FixedArray,
-  encodeInt,
-  encodeIntSafe,
-  encodeString,
-  encodeU16,
-  encodeU16Array,
-  encodeU16FixedArray,
-  encodeU32,
-  encodeU32Array,
-  encodeU32FixedArray,
-  encodeU64,
-  encodeU64Array,
-  encodeU64FixedArray,
-  encodeU64Safe,
-  encodeU8,
-  encodeU8Array,
-  encodeU8ClampedArray,
-  encodeU8ClampedFixedArray,
-  encodeU8FixedArray,
-  encodeUint,
-  encodeUintSafe,
-  encodeVoid
-};
+// src/index.ts
+export * from "./codec/index.js";
+export * from "./core/index.js";
 //# sourceMappingURL=index.js.map