@atproto/lex-cbor 0.0.16 → 0.1.0-next.0

package/dist/index.cjs

@@ -1,1723 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const lexData = require("@atproto/lex-data");
-const objectTypeNames = [
-  "Object",
-  // for Object.create(null) and other non-plain objects
-  "RegExp",
-  "Date",
-  "Error",
-  "Map",
-  "Set",
-  "WeakMap",
-  "WeakSet",
-  "ArrayBuffer",
-  "SharedArrayBuffer",
-  "DataView",
-  "Promise",
-  "URL",
-  "HTMLElement",
-  "Int8Array",
-  "Uint8ClampedArray",
-  "Int16Array",
-  "Uint16Array",
-  "Int32Array",
-  "Uint32Array",
-  "Float32Array",
-  "Float64Array",
-  "BigInt64Array",
-  "BigUint64Array"
-];
-function is(value) {
-  if (value === null) {
-    return "null";
-  }
-  if (value === void 0) {
-    return "undefined";
-  }
-  if (value === true || value === false) {
-    return "boolean";
-  }
-  const typeOf = typeof value;
-  if (typeOf === "string" || typeOf === "number" || typeOf === "bigint" || typeOf === "symbol") {
-    return typeOf;
-  }
-  if (typeOf === "function") {
-    return "Function";
-  }
-  if (Array.isArray(value)) {
-    return "Array";
-  }
-  if (value instanceof Uint8Array) {
-    return "Uint8Array";
-  }
-  if (value.constructor === Object) {
-    return "Object";
-  }
-  const objectType = getObjectType(value);
-  if (objectType) {
-    return objectType;
-  }
-  return "Object";
-}
-function getObjectType(value) {
-  const objectTypeName = Object.prototype.toString.call(value).slice(8, -1);
-  if (objectTypeNames.includes(objectTypeName)) {
-    return objectTypeName;
-  }
-  return void 0;
-}
-class Type {
-  /**
-   * @param {number} major
-   * @param {string} name
-   * @param {boolean} terminal
-   */
-  constructor(major, name, terminal) {
-    this.major = major;
-    this.majorEncoded = major << 5;
-    this.name = name;
-    this.terminal = terminal;
-  }
-  /* c8 ignore next 3 */
-  toString() {
-    return `Type[${this.major}].${this.name}`;
-  }
-  /**
-   * @param {Type} typ
-   * @returns {number}
-   */
-  compare(typ) {
-    return this.major < typ.major ? -1 : this.major > typ.major ? 1 : 0;
-  }
-  /**
-   * Check equality between two Type instances. Safe to use across different
-   * copies of the Type class (e.g., when bundlers duplicate the module).
-   * (major, name) uniquely identifies a Type; terminal is implied by these.
-   * @param {Type} a
-   * @param {Type} b
-   * @returns {boolean}
-   */
-  static equals(a, b) {
-    return a === b || a.major === b.major && a.name === b.name;
-  }
-}
-Type.uint = new Type(0, "uint", true);
-Type.negint = new Type(1, "negint", true);
-Type.bytes = new Type(2, "bytes", true);
-Type.string = new Type(3, "string", true);
-Type.array = new Type(4, "array", false);
-Type.map = new Type(5, "map", false);
-Type.tag = new Type(6, "tag", false);
-Type.float = new Type(7, "float", true);
-Type.false = new Type(7, "false", true);
-Type.true = new Type(7, "true", true);
-Type.null = new Type(7, "null", true);
-Type.undefined = new Type(7, "undefined", true);
-Type.break = new Type(7, "break", true);
-class Token {
-  /**
-   * @param {Type} type
-   * @param {any} [value]
-   * @param {number} [encodedLength]
-   */
-  constructor(type, value, encodedLength) {
-    this.type = type;
-    this.value = value;
-    this.encodedLength = encodedLength;
-    this.encodedBytes = void 0;
-    this.byteValue = void 0;
-  }
-  /* c8 ignore next 3 */
-  toString() {
-    return `Token[${this.type}].${this.value}`;
-  }
-}
-const useBuffer = globalThis.process && // @ts-ignore
-!globalThis.process.browser && // @ts-ignore
-globalThis.Buffer && // @ts-ignore
-typeof globalThis.Buffer.isBuffer === "function";
-const textEncoder = new TextEncoder();
-function isBuffer(buf) {
-  return useBuffer && globalThis.Buffer.isBuffer(buf);
-}
-function asU8A(buf) {
-  if (!(buf instanceof Uint8Array)) {
-    return Uint8Array.from(buf);
-  }
-  return isBuffer(buf) ? new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength) : buf;
-}
-const FROM_STRING_THRESHOLD_BUFFER = 24;
-const FROM_STRING_THRESHOLD_TEXTENCODER = 200;
-const fromString = useBuffer ? (
-  // eslint-disable-line operator-linebreak
-  /**
-   * @param {string} string
-   */
-  (string) => {
-    return string.length >= FROM_STRING_THRESHOLD_BUFFER ? (
-      // eslint-disable-line operator-linebreak
-      // @ts-ignore
-      globalThis.Buffer.from(string)
-    ) : utf8ToBytes(string);
-  }
-) : (
-  // eslint-disable-line operator-linebreak
-  /**
-   * @param {string} string
-   */
-  (string) => {
-    return string.length >= FROM_STRING_THRESHOLD_TEXTENCODER ? textEncoder.encode(string) : utf8ToBytes(string);
-  }
-);
-const fromArray = (arr) => {
-  return Uint8Array.from(arr);
-};
-const slice = useBuffer ? (
-  // eslint-disable-line operator-linebreak
-  /**
-   * @param {Uint8Array} bytes
-   * @param {number} start
-   * @param {number} end
-   */
-  // Buffer.slice() returns a view, not a copy, so we need special handling
-  (bytes, start, end) => {
-    if (isBuffer(bytes)) {
-      return new Uint8Array(bytes.subarray(start, end));
-    }
-    return bytes.slice(start, end);
-  }
-) : (
-  // eslint-disable-line operator-linebreak
-  /**
-   * @param {Uint8Array} bytes
-   * @param {number} start
-   * @param {number} end
-   */
-  (bytes, start, end) => {
-    return bytes.slice(start, end);
-  }
-);
-const concat = useBuffer ? (
-  // eslint-disable-line operator-linebreak
-  /**
-   * @param {Uint8Array[]} chunks
-   * @param {number} length
-   * @returns {Uint8Array}
-   */
-  (chunks, length) => {
-    chunks = chunks.map((c) => c instanceof Uint8Array ? c : (
-      // eslint-disable-line operator-linebreak
-      // @ts-ignore
-      globalThis.Buffer.from(c)
-    ));
-    return asU8A(globalThis.Buffer.concat(chunks, length));
-  }
-) : (
-  // eslint-disable-line operator-linebreak
-  /**
-   * @param {Uint8Array[]} chunks
-   * @param {number} length
-   * @returns {Uint8Array}
-   */
-  (chunks, length) => {
-    const out = new Uint8Array(length);
-    let off = 0;
-    for (let b of chunks) {
-      if (off + b.length > out.length) {
-        b = b.subarray(0, out.length - off);
-      }
-      out.set(b, off);
-      off += b.length;
-    }
-    return out;
-  }
-);
-const alloc = useBuffer ? (
-  // eslint-disable-line operator-linebreak
-  /**
-   * @param {number} size
-   * @returns {Uint8Array}
-   */
-  (size) => {
-    return globalThis.Buffer.allocUnsafe(size);
-  }
-) : (
-  // eslint-disable-line operator-linebreak
-  /**
-   * @param {number} size
-   * @returns {Uint8Array}
-   */
-  (size) => {
-    return new Uint8Array(size);
-  }
-);
-function compare(b1, b2) {
-  if (isBuffer(b1) && isBuffer(b2)) {
-    return b1.compare(b2);
-  }
-  for (let i = 0; i < b1.length; i++) {
-    if (b1[i] === b2[i]) {
-      continue;
-    }
-    return b1[i] < b2[i] ? -1 : 1;
-  }
-  return 0;
-}
-function utf8ToBytes(str) {
-  const out = [];
-  let p = 0;
-  for (let i = 0; i < str.length; i++) {
-    let c = str.charCodeAt(i);
-    if (c < 128) {
-      out[p++] = c;
-    } else if (c < 2048) {
-      out[p++] = c >> 6 | 192;
-      out[p++] = c & 63 | 128;
-    } else if ((c & 64512) === 55296 && i + 1 < str.length && (str.charCodeAt(i + 1) & 64512) === 56320) {
-      c = 65536 + ((c & 1023) << 10) + (str.charCodeAt(++i) & 1023);
-      out[p++] = c >> 18 | 240;
-      out[p++] = c >> 12 & 63 | 128;
-      out[p++] = c >> 6 & 63 | 128;
-      out[p++] = c & 63 | 128;
-    } else {
-      if (c >= 55296 && c <= 57343) {
-        c = 65533;
-      }
-      out[p++] = c >> 12 | 224;
-      out[p++] = c >> 6 & 63 | 128;
-      out[p++] = c & 63 | 128;
-    }
-  }
-  return out;
-}
-const defaultChunkSize = 256;
-class Bl {
-  /**
-   * @param {number} [chunkSize]
-   */
-  constructor(chunkSize = defaultChunkSize) {
-    this.chunkSize = chunkSize;
-    this.cursor = 0;
-    this.maxCursor = -1;
-    this.chunks = [];
-    this._initReuseChunk = null;
-  }
-  reset() {
-    this.cursor = 0;
-    this.maxCursor = -1;
-    if (this.chunks.length) {
-      this.chunks = [];
-    }
-    if (this._initReuseChunk !== null) {
-      this.chunks.push(this._initReuseChunk);
-      this.maxCursor = this._initReuseChunk.length - 1;
-    }
-  }
-  /**
-   * @param {Uint8Array|number[]} bytes
-   */
-  push(bytes) {
-    let topChunk = this.chunks[this.chunks.length - 1];
-    const newMax = this.cursor + bytes.length;
-    if (newMax <= this.maxCursor + 1) {
-      const chunkPos = topChunk.length - (this.maxCursor - this.cursor) - 1;
-      topChunk.set(bytes, chunkPos);
-    } else {
-      if (topChunk) {
-        const chunkPos = topChunk.length - (this.maxCursor - this.cursor) - 1;
-        if (chunkPos < topChunk.length) {
-          this.chunks[this.chunks.length - 1] = topChunk.subarray(0, chunkPos);
-          this.maxCursor = this.cursor - 1;
-        }
-      }
-      if (bytes.length < 64 && bytes.length < this.chunkSize) {
-        topChunk = alloc(this.chunkSize);
-        this.chunks.push(topChunk);
-        this.maxCursor += topChunk.length;
-        if (this._initReuseChunk === null) {
-          this._initReuseChunk = topChunk;
-        }
-        topChunk.set(bytes, 0);
-      } else {
-        this.chunks.push(bytes);
-        this.maxCursor += bytes.length;
-      }
-    }
-    this.cursor += bytes.length;
-  }
-  /**
-   * @param {boolean} [reset]
-   * @returns {Uint8Array}
-   */
-  toBytes(reset = false) {
-    let byts;
-    if (this.chunks.length === 1) {
-      const chunk = this.chunks[0];
-      if (reset && this.cursor > chunk.length / 2) {
-        byts = this.cursor === chunk.length ? chunk : chunk.subarray(0, this.cursor);
-        this._initReuseChunk = null;
-        this.chunks = [];
-      } else {
-        byts = slice(chunk, 0, this.cursor);
-      }
-    } else {
-      byts = concat(this.chunks, this.cursor);
-    }
-    if (reset) {
-      this.reset();
-    }
-    return byts;
-  }
-}
-class U8Bl {
-  /**
-   * @param {Uint8Array} dest
-   */
-  constructor(dest) {
-    this.dest = dest;
-    this.cursor = 0;
-    this.chunks = [dest];
-  }
-  reset() {
-    this.cursor = 0;
-  }
-  /**
-   * @param {Uint8Array|number[]} bytes
-   */
-  push(bytes) {
-    if (this.cursor + bytes.length > this.dest.length) {
-      throw new Error("write out of bounds, destination buffer is too small");
-    }
-    this.dest.set(bytes, this.cursor);
-    this.cursor += bytes.length;
-  }
-  /**
-   * @param {boolean} [reset]
-   * @returns {Uint8Array}
-   */
-  toBytes(reset = false) {
-    const byts = this.dest.subarray(0, this.cursor);
-    if (reset) {
-      this.reset();
-    }
-    return byts;
-  }
-}
-const decodeErrPrefix = "CBOR decode error:";
-const encodeErrPrefix = "CBOR encode error:";
-function assertEnoughData(data, pos, need) {
-  if (data.length - pos < need) {
-    throw new Error(`${decodeErrPrefix} not enough data for type`);
-  }
-}
-const uintBoundaries = [24, 256, 65536, 4294967296, BigInt("18446744073709551616")];
-function readUint8(data, offset, options) {
-  assertEnoughData(data, offset, 1);
-  const value = data[offset];
-  if (options.strict === true && value < uintBoundaries[0]) {
-    throw new Error(`${decodeErrPrefix} integer encoded in more bytes than necessary (strict decode)`);
-  }
-  return value;
-}
-function readUint16(data, offset, options) {
-  assertEnoughData(data, offset, 2);
-  const value = data[offset] << 8 | data[offset + 1];
-  if (options.strict === true && value < uintBoundaries[1]) {
-    throw new Error(`${decodeErrPrefix} integer encoded in more bytes than necessary (strict decode)`);
-  }
-  return value;
-}
-function readUint32(data, offset, options) {
-  assertEnoughData(data, offset, 4);
-  const value = data[offset] * 16777216 + (data[offset + 1] << 16) + (data[offset + 2] << 8) + data[offset + 3];
-  if (options.strict === true && value < uintBoundaries[2]) {
-    throw new Error(`${decodeErrPrefix} integer encoded in more bytes than necessary (strict decode)`);
-  }
-  return value;
-}
-function readUint64(data, offset, options) {
-  assertEnoughData(data, offset, 8);
-  const hi = data[offset] * 16777216 + (data[offset + 1] << 16) + (data[offset + 2] << 8) + data[offset + 3];
-  const lo = data[offset + 4] * 16777216 + (data[offset + 5] << 16) + (data[offset + 6] << 8) + data[offset + 7];
-  const value = (BigInt(hi) << BigInt(32)) + BigInt(lo);
-  if (options.strict === true && value < uintBoundaries[3]) {
-    throw new Error(`${decodeErrPrefix} integer encoded in more bytes than necessary (strict decode)`);
-  }
-  if (value <= Number.MAX_SAFE_INTEGER) {
-    return Number(value);
-  }
-  if (options.allowBigInt === true) {
-    return value;
-  }
-  throw new Error(`${decodeErrPrefix} integers outside of the safe integer range are not supported`);
-}
-function decodeUint8(data, pos, _minor, options) {
-  return new Token(Type.uint, readUint8(data, pos + 1, options), 2);
-}
-function decodeUint16(data, pos, _minor, options) {
-  return new Token(Type.uint, readUint16(data, pos + 1, options), 3);
-}
-function decodeUint32(data, pos, _minor, options) {
-  return new Token(Type.uint, readUint32(data, pos + 1, options), 5);
-}
-function decodeUint64(data, pos, _minor, options) {
-  return new Token(Type.uint, readUint64(data, pos + 1, options), 9);
-}
-function encodeUint(writer, token) {
-  return encodeUintValue(writer, 0, token.value);
-}
-function encodeUintValue(writer, major, uint) {
-  if (uint < uintBoundaries[0]) {
-    const nuint = Number(uint);
-    writer.push([major | nuint]);
-  } else if (uint < uintBoundaries[1]) {
-    const nuint = Number(uint);
-    writer.push([major | 24, nuint]);
-  } else if (uint < uintBoundaries[2]) {
-    const nuint = Number(uint);
-    writer.push([major | 25, nuint >>> 8, nuint & 255]);
-  } else if (uint < uintBoundaries[3]) {
-    const nuint = Number(uint);
-    writer.push([major | 26, nuint >>> 24 & 255, nuint >>> 16 & 255, nuint >>> 8 & 255, nuint & 255]);
-  } else {
-    const buint = BigInt(uint);
-    if (buint < uintBoundaries[4]) {
-      const set = [major | 27, 0, 0, 0, 0, 0, 0, 0];
-      let lo = Number(buint & BigInt(4294967295));
-      let hi = Number(buint >> BigInt(32) & BigInt(4294967295));
-      set[8] = lo & 255;
-      lo = lo >> 8;
-      set[7] = lo & 255;
-      lo = lo >> 8;
-      set[6] = lo & 255;
-      lo = lo >> 8;
-      set[5] = lo & 255;
-      set[4] = hi & 255;
-      hi = hi >> 8;
-      set[3] = hi & 255;
-      hi = hi >> 8;
-      set[2] = hi & 255;
-      hi = hi >> 8;
-      set[1] = hi & 255;
-      writer.push(set);
-    } else {
-      throw new Error(`${decodeErrPrefix} encountered BigInt larger than allowable range`);
-    }
-  }
-}
-encodeUint.encodedSize = function encodedSize(token) {
-  return encodeUintValue.encodedSize(token.value);
-};
-encodeUintValue.encodedSize = function encodedSize2(uint) {
-  if (uint < uintBoundaries[0]) {
-    return 1;
-  }
-  if (uint < uintBoundaries[1]) {
-    return 2;
-  }
-  if (uint < uintBoundaries[2]) {
-    return 3;
-  }
-  if (uint < uintBoundaries[3]) {
-    return 5;
-  }
-  return 9;
-};
-encodeUint.compareTokens = function compareTokens(tok1, tok2) {
-  return tok1.value < tok2.value ? -1 : tok1.value > tok2.value ? 1 : (
-    /* c8 ignore next */
-    0
-  );
-};
-function decodeNegint8(data, pos, _minor, options) {
-  return new Token(Type.negint, -1 - readUint8(data, pos + 1, options), 2);
-}
-function decodeNegint16(data, pos, _minor, options) {
-  return new Token(Type.negint, -1 - readUint16(data, pos + 1, options), 3);
-}
-function decodeNegint32(data, pos, _minor, options) {
-  return new Token(Type.negint, -1 - readUint32(data, pos + 1, options), 5);
-}
-const neg1b$1 = BigInt(-1);
-const pos1b$1 = BigInt(1);
-function decodeNegint64(data, pos, _minor, options) {
-  const int = readUint64(data, pos + 1, options);
-  if (typeof int !== "bigint") {
-    const value = -1 - int;
-    if (value >= Number.MIN_SAFE_INTEGER) {
-      return new Token(Type.negint, value, 9);
-    }
-  }
-  if (options.allowBigInt !== true) {
-    throw new Error(`${decodeErrPrefix} integers outside of the safe integer range are not supported`);
-  }
-  return new Token(Type.negint, neg1b$1 - BigInt(int), 9);
-}
-function encodeNegint(writer, token) {
-  const negint = token.value;
-  const unsigned = typeof negint === "bigint" ? negint * neg1b$1 - pos1b$1 : negint * -1 - 1;
-  encodeUintValue(writer, token.type.majorEncoded, unsigned);
-}
-encodeNegint.encodedSize = function encodedSize3(token) {
-  const negint = token.value;
-  const unsigned = typeof negint === "bigint" ? negint * neg1b$1 - pos1b$1 : negint * -1 - 1;
-  if (unsigned < uintBoundaries[0]) {
-    return 1;
-  }
-  if (unsigned < uintBoundaries[1]) {
-    return 2;
-  }
-  if (unsigned < uintBoundaries[2]) {
-    return 3;
-  }
-  if (unsigned < uintBoundaries[3]) {
-    return 5;
-  }
-  return 9;
-};
-encodeNegint.compareTokens = function compareTokens2(tok1, tok2) {
-  return tok1.value < tok2.value ? 1 : tok1.value > tok2.value ? -1 : (
-    /* c8 ignore next */
-    0
-  );
-};
-function toToken$3(data, pos, prefix, length) {
-  assertEnoughData(data, pos, prefix + length);
-  const buf = data.slice(pos + prefix, pos + prefix + length);
-  return new Token(Type.bytes, buf, prefix + length);
-}
-function decodeBytesCompact(data, pos, minor, _options) {
-  return toToken$3(data, pos, 1, minor);
-}
-function decodeBytes8(data, pos, _minor, options) {
-  return toToken$3(data, pos, 2, readUint8(data, pos + 1, options));
-}
-function decodeBytes16(data, pos, _minor, options) {
-  return toToken$3(data, pos, 3, readUint16(data, pos + 1, options));
-}
-function decodeBytes32(data, pos, _minor, options) {
-  return toToken$3(data, pos, 5, readUint32(data, pos + 1, options));
-}
-function decodeBytes64(data, pos, _minor, options) {
-  const l = readUint64(data, pos + 1, options);
-  if (typeof l === "bigint") {
-    throw new Error(`${decodeErrPrefix} 64-bit integer bytes lengths not supported`);
-  }
-  return toToken$3(data, pos, 9, l);
-}
-function tokenBytes(token) {
-  if (token.encodedBytes === void 0) {
-    token.encodedBytes = Type.equals(token.type, Type.string) ? fromString(token.value) : token.value;
-  }
-  return token.encodedBytes;
-}
-function encodeBytes(writer, token) {
-  const bytes = tokenBytes(token);
-  encodeUintValue(writer, token.type.majorEncoded, bytes.length);
-  writer.push(bytes);
-}
-encodeBytes.encodedSize = function encodedSize4(token) {
-  const bytes = tokenBytes(token);
-  return encodeUintValue.encodedSize(bytes.length) + bytes.length;
-};
-encodeBytes.compareTokens = function compareTokens3(tok1, tok2) {
-  return compareBytes(tokenBytes(tok1), tokenBytes(tok2));
-};
-function compareBytes(b1, b2) {
-  return b1.length < b2.length ? -1 : b1.length > b2.length ? 1 : compare(b1, b2);
-}
-const textDecoder = new TextDecoder();
-const ASCII_THRESHOLD = 32;
-function toStr(bytes, start, end) {
-  const len = end - start;
-  if (len < ASCII_THRESHOLD) {
-    let str = "";
-    for (let i = start; i < end; i++) {
-      const c = bytes[i];
-      if (c & 128) {
-        return textDecoder.decode(bytes.subarray(start, end));
-      }
-      str += String.fromCharCode(c);
-    }
-    return str;
-  }
-  return textDecoder.decode(bytes.subarray(start, end));
-}
-function toToken$2(data, pos, prefix, length, options) {
-  const totLength = prefix + length;
-  assertEnoughData(data, pos, totLength);
-  const tok = new Token(Type.string, toStr(data, pos + prefix, pos + totLength), totLength);
-  if (options.retainStringBytes === true) {
-    tok.byteValue = data.slice(pos + prefix, pos + totLength);
-  }
-  return tok;
-}
-function decodeStringCompact(data, pos, minor, options) {
-  return toToken$2(data, pos, 1, minor, options);
-}
-function decodeString8(data, pos, _minor, options) {
-  return toToken$2(data, pos, 2, readUint8(data, pos + 1, options), options);
-}
-function decodeString16(data, pos, _minor, options) {
-  return toToken$2(data, pos, 3, readUint16(data, pos + 1, options), options);
-}
-function decodeString32(data, pos, _minor, options) {
-  return toToken$2(data, pos, 5, readUint32(data, pos + 1, options), options);
-}
-function decodeString64(data, pos, _minor, options) {
-  const l = readUint64(data, pos + 1, options);
-  if (typeof l === "bigint") {
-    throw new Error(`${decodeErrPrefix} 64-bit integer string lengths not supported`);
-  }
-  return toToken$2(data, pos, 9, l, options);
-}
-const encodeString = encodeBytes;
-function toToken$1(_data, _pos, prefix, length) {
-  return new Token(Type.array, length, prefix);
-}
-function decodeArrayCompact(data, pos, minor, _options) {
-  return toToken$1(data, pos, 1, minor);
-}
-function decodeArray8(data, pos, _minor, options) {
-  return toToken$1(data, pos, 2, readUint8(data, pos + 1, options));
-}
-function decodeArray16(data, pos, _minor, options) {
-  return toToken$1(data, pos, 3, readUint16(data, pos + 1, options));
-}
-function decodeArray32(data, pos, _minor, options) {
-  return toToken$1(data, pos, 5, readUint32(data, pos + 1, options));
-}
-function decodeArray64(data, pos, _minor, options) {
-  const l = readUint64(data, pos + 1, options);
-  if (typeof l === "bigint") {
-    throw new Error(`${decodeErrPrefix} 64-bit integer array lengths not supported`);
-  }
-  return toToken$1(data, pos, 9, l);
-}
-function decodeArrayIndefinite(data, pos, _minor, options) {
-  if (options.allowIndefinite === false) {
-    throw new Error(`${decodeErrPrefix} indefinite length items not allowed`);
-  }
-  return toToken$1(data, pos, 1, Infinity);
-}
-function encodeArray(writer, token) {
-  encodeUintValue(writer, Type.array.majorEncoded, token.value);
-}
-encodeArray.compareTokens = encodeUint.compareTokens;
-encodeArray.encodedSize = function encodedSize5(token) {
-  return encodeUintValue.encodedSize(token.value);
-};
-function toToken(_data, _pos, prefix, length) {
-  return new Token(Type.map, length, prefix);
-}
-function decodeMapCompact(data, pos, minor, _options) {
-  return toToken(data, pos, 1, minor);
-}
-function decodeMap8(data, pos, _minor, options) {
-  return toToken(data, pos, 2, readUint8(data, pos + 1, options));
-}
-function decodeMap16(data, pos, _minor, options) {
-  return toToken(data, pos, 3, readUint16(data, pos + 1, options));
-}
-function decodeMap32(data, pos, _minor, options) {
-  return toToken(data, pos, 5, readUint32(data, pos + 1, options));
-}
-function decodeMap64(data, pos, _minor, options) {
-  const l = readUint64(data, pos + 1, options);
-  if (typeof l === "bigint") {
-    throw new Error(`${decodeErrPrefix} 64-bit integer map lengths not supported`);
-  }
-  return toToken(data, pos, 9, l);
-}
-function decodeMapIndefinite(data, pos, _minor, options) {
-  if (options.allowIndefinite === false) {
-    throw new Error(`${decodeErrPrefix} indefinite length items not allowed`);
-  }
-  return toToken(data, pos, 1, Infinity);
-}
-function encodeMap(writer, token) {
-  encodeUintValue(writer, Type.map.majorEncoded, token.value);
-}
-encodeMap.compareTokens = encodeUint.compareTokens;
-encodeMap.encodedSize = function encodedSize6(token) {
-  return encodeUintValue.encodedSize(token.value);
-};
-function decodeTagCompact(_data, _pos, minor, _options) {
-  return new Token(Type.tag, minor, 1);
-}
-function decodeTag8(data, pos, _minor, options) {
-  return new Token(Type.tag, readUint8(data, pos + 1, options), 2);
-}
-function decodeTag16(data, pos, _minor, options) {
-  return new Token(Type.tag, readUint16(data, pos + 1, options), 3);
-}
-function decodeTag32(data, pos, _minor, options) {
-  return new Token(Type.tag, readUint32(data, pos + 1, options), 5);
-}
-function decodeTag64(data, pos, _minor, options) {
-  return new Token(Type.tag, readUint64(data, pos + 1, options), 9);
-}
-function encodeTag(writer, token) {
-  encodeUintValue(writer, Type.tag.majorEncoded, token.value);
-}
-encodeTag.compareTokens = encodeUint.compareTokens;
-encodeTag.encodedSize = function encodedSize7(token) {
-  return encodeUintValue.encodedSize(token.value);
-};
-const MINOR_FALSE = 20;
-const MINOR_TRUE = 21;
-const MINOR_NULL = 22;
-const MINOR_UNDEFINED = 23;
-function decodeUndefined(_data, _pos, _minor, options) {
-  if (options.allowUndefined === false) {
-    throw new Error(`${decodeErrPrefix} undefined values are not supported`);
-  } else if (options.coerceUndefinedToNull === true) {
-    return new Token(Type.null, null, 1);
-  }
-  return new Token(Type.undefined, void 0, 1);
-}
-function decodeBreak(_data, _pos, _minor, options) {
-  if (options.allowIndefinite === false) {
-    throw new Error(`${decodeErrPrefix} indefinite length items not allowed`);
-  }
-  return new Token(Type.break, void 0, 1);
-}
-function createToken(value, bytes, options) {
-  if (options) {
-    if (options.allowNaN === false && Number.isNaN(value)) {
-      throw new Error(`${decodeErrPrefix} NaN values are not supported`);
-    }
-    if (options.allowInfinity === false && (value === Infinity || value === -Infinity)) {
-      throw new Error(`${decodeErrPrefix} Infinity values are not supported`);
-    }
-  }
-  return new Token(Type.float, value, bytes);
-}
-function decodeFloat16(data, pos, _minor, options) {
-  return createToken(readFloat16(data, pos + 1), 3, options);
-}
-function decodeFloat32(data, pos, _minor, options) {
-  return createToken(readFloat32(data, pos + 1), 5, options);
-}
-function decodeFloat64(data, pos, _minor, options) {
-  return createToken(readFloat64(data, pos + 1), 9, options);
-}
-function encodeFloat(writer, token, options) {
-  const float = token.value;
-  if (float === false) {
-    writer.push([Type.float.majorEncoded | MINOR_FALSE]);
-  } else if (float === true) {
-    writer.push([Type.float.majorEncoded | MINOR_TRUE]);
-  } else if (float === null) {
-    writer.push([Type.float.majorEncoded | MINOR_NULL]);
-  } else if (float === void 0) {
-    writer.push([Type.float.majorEncoded | MINOR_UNDEFINED]);
-  } else {
-    let decoded;
-    let success = false;
-    if (!options || options.float64 !== true) {
-      encodeFloat16(float);
-      decoded = readFloat16(ui8a, 1);
-      if (float === decoded || Number.isNaN(float)) {
-        ui8a[0] = 249;
-        writer.push(ui8a.slice(0, 3));
-        success = true;
-      } else {
-        encodeFloat32(float);
-        decoded = readFloat32(ui8a, 1);
-        if (float === decoded) {
-          ui8a[0] = 250;
-          writer.push(ui8a.slice(0, 5));
-          success = true;
-        }
-      }
-    }
-    if (!success) {
-      encodeFloat64(float);
-      decoded = readFloat64(ui8a, 1);
-      ui8a[0] = 251;
-      writer.push(ui8a.slice(0, 9));
-    }
-  }
-}
-encodeFloat.encodedSize = function encodedSize8(token, options) {
-  const float = token.value;
-  if (float === false || float === true || float === null || float === void 0) {
-    return 1;
-  }
-  if (!options || options.float64 !== true) {
-    encodeFloat16(float);
-    let decoded = readFloat16(ui8a, 1);
-    if (float === decoded || Number.isNaN(float)) {
-      return 3;
-    }
-    encodeFloat32(float);
-    decoded = readFloat32(ui8a, 1);
-    if (float === decoded) {
-      return 5;
-    }
-  }
-  return 9;
-};
-const buffer = new ArrayBuffer(9);
-const dataView = new DataView(buffer, 1);
-const ui8a = new Uint8Array(buffer, 0);
-function encodeFloat16(inp) {
-  if (inp === Infinity) {
-    dataView.setUint16(0, 31744, false);
-  } else if (inp === -Infinity) {
-    dataView.setUint16(0, 64512, false);
-  } else if (Number.isNaN(inp)) {
-    dataView.setUint16(0, 32256, false);
-  } else {
-    dataView.setFloat32(0, inp);
-    const valu32 = dataView.getUint32(0);
-    const exponent = (valu32 & 2139095040) >> 23;
-    const mantissa = valu32 & 8388607;
-    if (exponent === 255) {
-      dataView.setUint16(0, 31744, false);
-    } else if (exponent === 0) {
-      dataView.setUint16(0, (inp & 2147483648) >> 16 | mantissa >> 13, false);
-    } else {
-      const logicalExponent = exponent - 127;
-      if (logicalExponent < -24) {
-        dataView.setUint16(0, 0);
-      } else if (logicalExponent < -14) {
-        dataView.setUint16(0, (valu32 & 2147483648) >> 16 | /* sign bit */
-        1 << 24 + logicalExponent, false);
-      } else {
-        dataView.setUint16(0, (valu32 & 2147483648) >> 16 | logicalExponent + 15 << 10 | mantissa >> 13, false);
-      }
-    }
-  }
-}
-function readFloat16(ui8a2, pos) {
-  if (ui8a2.length - pos < 2) {
-    throw new Error(`${decodeErrPrefix} not enough data for float16`);
-  }
-  const half = (ui8a2[pos] << 8) + ui8a2[pos + 1];
-  if (half === 31744) {
-    return Infinity;
-  }
-  if (half === 64512) {
-    return -Infinity;
-  }
-  if (half === 32256) {
-    return NaN;
-  }
-  const exp = half >> 10 & 31;
-  const mant = half & 1023;
-  let val;
-  if (exp === 0) {
-    val = mant * 2 ** -24;
-  } else if (exp !== 31) {
-    val = (mant + 1024) * 2 ** (exp - 25);
-  } else {
-    val = mant === 0 ? Infinity : NaN;
-  }
-  return half & 32768 ? -val : val;
-}
-function encodeFloat32(inp) {
-  dataView.setFloat32(0, inp, false);
-}
-function readFloat32(ui8a2, pos) {
-  if (ui8a2.length - pos < 4) {
-    throw new Error(`${decodeErrPrefix} not enough data for float32`);
-  }
-  const offset = (ui8a2.byteOffset || 0) + pos;
-  return new DataView(ui8a2.buffer, offset, 4).getFloat32(0, false);
-}
-function encodeFloat64(inp) {
-  dataView.setFloat64(0, inp, false);
-}
-function readFloat64(ui8a2, pos) {
-  if (ui8a2.length - pos < 8) {
-    throw new Error(`${decodeErrPrefix} not enough data for float64`);
-  }
-  const offset = (ui8a2.byteOffset || 0) + pos;
-  return new DataView(ui8a2.buffer, offset, 8).getFloat64(0, false);
-}
-encodeFloat.compareTokens = encodeUint.compareTokens;
-function invalidMinor(data, pos, minor) {
-  throw new Error(`${decodeErrPrefix} encountered invalid minor (${minor}) for major ${data[pos] >>> 5}`);
-}
-function errorer(msg) {
-  return () => {
-    throw new Error(`${decodeErrPrefix} ${msg}`);
-  };
-}
-const jump = [];
-for (let i = 0; i <= 23; i++) {
-  jump[i] = invalidMinor;
-}
-jump[24] = decodeUint8;
-jump[25] = decodeUint16;
-jump[26] = decodeUint32;
-jump[27] = decodeUint64;
-jump[28] = invalidMinor;
-jump[29] = invalidMinor;
-jump[30] = invalidMinor;
-jump[31] = invalidMinor;
-for (let i = 32; i <= 55; i++) {
-  jump[i] = invalidMinor;
-}
-jump[56] = decodeNegint8;
-jump[57] = decodeNegint16;
-jump[58] = decodeNegint32;
-jump[59] = decodeNegint64;
-jump[60] = invalidMinor;
-jump[61] = invalidMinor;
-jump[62] = invalidMinor;
-jump[63] = invalidMinor;
-for (let i = 64; i <= 87; i++) {
-  jump[i] = decodeBytesCompact;
-}
-jump[88] = decodeBytes8;
-jump[89] = decodeBytes16;
-jump[90] = decodeBytes32;
-jump[91] = decodeBytes64;
-jump[92] = invalidMinor;
-jump[93] = invalidMinor;
-jump[94] = invalidMinor;
-jump[95] = errorer("indefinite length bytes/strings are not supported");
-for (let i = 96; i <= 119; i++) {
-  jump[i] = decodeStringCompact;
-}
-jump[120] = decodeString8;
-jump[121] = decodeString16;
-jump[122] = decodeString32;
-jump[123] = decodeString64;
-jump[124] = invalidMinor;
-jump[125] = invalidMinor;
-jump[126] = invalidMinor;
-jump[127] = errorer("indefinite length bytes/strings are not supported");
-for (let i = 128; i <= 151; i++) {
-  jump[i] = decodeArrayCompact;
-}
-jump[152] = decodeArray8;
-jump[153] = decodeArray16;
-jump[154] = decodeArray32;
-jump[155] = decodeArray64;
-jump[156] = invalidMinor;
-jump[157] = invalidMinor;
-jump[158] = invalidMinor;
-jump[159] = decodeArrayIndefinite;
-for (let i = 160; i <= 183; i++) {
-  jump[i] = decodeMapCompact;
-}
-jump[184] = decodeMap8;
-jump[185] = decodeMap16;
-jump[186] = decodeMap32;
-jump[187] = decodeMap64;
-jump[188] = invalidMinor;
-jump[189] = invalidMinor;
-jump[190] = invalidMinor;
-jump[191] = decodeMapIndefinite;
-for (let i = 192; i <= 215; i++) {
-  jump[i] = decodeTagCompact;
-}
-jump[216] = decodeTag8;
-jump[217] = decodeTag16;
-jump[218] = decodeTag32;
-jump[219] = decodeTag64;
-jump[220] = invalidMinor;
-jump[221] = invalidMinor;
-jump[222] = invalidMinor;
-jump[223] = invalidMinor;
-for (let i = 224; i <= 243; i++) {
-  jump[i] = errorer("simple values are not supported");
-}
-jump[244] = invalidMinor;
-jump[245] = invalidMinor;
-jump[246] = invalidMinor;
-jump[247] = decodeUndefined;
-jump[248] = errorer("simple values are not supported");
-jump[249] = decodeFloat16;
-jump[250] = decodeFloat32;
-jump[251] = decodeFloat64;
-jump[252] = invalidMinor;
-jump[253] = invalidMinor;
-jump[254] = invalidMinor;
-jump[255] = decodeBreak;
-const quick = [];
-for (let i = 0; i < 24; i++) {
-  quick[i] = new Token(Type.uint, i, 1);
-}
-for (let i = -1; i >= -24; i--) {
-  quick[31 - i] = new Token(Type.negint, i, 1);
-}
-quick[64] = new Token(Type.bytes, new Uint8Array(0), 1);
-quick[96] = new Token(Type.string, "", 1);
-quick[128] = new Token(Type.array, 0, 1);
-quick[160] = new Token(Type.map, 0, 1);
-quick[244] = new Token(Type.false, false, 1);
-quick[245] = new Token(Type.true, true, 1);
-quick[246] = new Token(Type.null, null, 1);
-function quickEncodeToken(token) {
-  switch (token.type) {
-    case Type.false:
-      return fromArray([244]);
-    case Type.true:
-      return fromArray([245]);
-    case Type.null:
-      return fromArray([246]);
-    case Type.bytes:
-      if (!token.value.length) {
-        return fromArray([64]);
-      }
-      return;
-    case Type.string:
-      if (token.value === "") {
-        return fromArray([96]);
-      }
-      return;
-    case Type.array:
-      if (token.value === 0) {
-        return fromArray([128]);
-      }
-      return;
-    case Type.map:
-      if (token.value === 0) {
-        return fromArray([160]);
-      }
-      return;
-    case Type.uint:
-      if (token.value < 24) {
-        return fromArray([Number(token.value)]);
-      }
-      return;
-    case Type.negint:
-      if (token.value >= -24) {
-        return fromArray([31 - Number(token.value)]);
-      }
-  }
-}
-const defaultEncodeOptions = {
-  float64: false,
-  mapSorter,
-  quickEncodeToken
-};
-function makeCborEncoders() {
-  const encoders = [];
-  encoders[Type.uint.major] = encodeUint;
-  encoders[Type.negint.major] = encodeNegint;
-  encoders[Type.bytes.major] = encodeBytes;
-  encoders[Type.string.major] = encodeString;
-  encoders[Type.array.major] = encodeArray;
-  encoders[Type.map.major] = encodeMap;
-  encoders[Type.tag.major] = encodeTag;
-  encoders[Type.float.major] = encodeFloat;
-  return encoders;
-}
-const cborEncoders = makeCborEncoders();
-const defaultWriter = new Bl();
-class Ref {
-  /**
-   * @param {object|any[]} obj
-   * @param {Reference|undefined} parent
-   */
-  constructor(obj, parent) {
-    this.obj = obj;
-    this.parent = parent;
-  }
-  /**
-   * @param {object|any[]} obj
-   * @returns {boolean}
-   */
-  includes(obj) {
-    let p = this;
-    do {
-      if (p.obj === obj) {
-        return true;
-      }
-    } while (p = p.parent);
-    return false;
-  }
-  /**
-   * @param {Reference|undefined} stack
-   * @param {object|any[]} obj
-   * @returns {Reference}
-   */
-  static createCheck(stack, obj) {
-    if (stack && stack.includes(obj)) {
-      throw new Error(`${encodeErrPrefix} object contains circular references`);
-    }
-    return new Ref(obj, stack);
-  }
-}
-const simpleTokens = {
-  null: new Token(Type.null, null),
-  undefined: new Token(Type.undefined, void 0),
-  true: new Token(Type.true, true),
-  false: new Token(Type.false, false),
-  emptyArray: new Token(Type.array, 0),
-  emptyMap: new Token(Type.map, 0)
-};
-const typeEncoders = {
-  /**
-   * @param {any} obj
-   * @param {string} _typ
-   * @param {EncodeOptions} _options
-   * @param {Reference} [_refStack]
-   * @returns {TokenOrNestedTokens}
-   */
-  number(obj, _typ, _options, _refStack) {
-    if (!Number.isInteger(obj) || !Number.isSafeInteger(obj)) {
-      return new Token(Type.float, obj);
-    } else if (obj >= 0) {
-      return new Token(Type.uint, obj);
-    } else {
-      return new Token(Type.negint, obj);
-    }
-  },
-  /**
-   * @param {any} obj
-   * @param {string} _typ
-   * @param {EncodeOptions} _options
-   * @param {Reference} [_refStack]
-   * @returns {TokenOrNestedTokens}
-   */
-  bigint(obj, _typ, _options, _refStack) {
-    if (obj >= BigInt(0)) {
-      return new Token(Type.uint, obj);
-    } else {
-      return new Token(Type.negint, obj);
-    }
-  },
-  /**
-   * @param {any} obj
-   * @param {string} _typ
-   * @param {EncodeOptions} _options
-   * @param {Reference} [_refStack]
-   * @returns {TokenOrNestedTokens}
-   */
-  Uint8Array(obj, _typ, _options, _refStack) {
-    return new Token(Type.bytes, obj);
-  },
-  /**
-   * @param {any} obj
-   * @param {string} _typ
-   * @param {EncodeOptions} _options
-   * @param {Reference} [_refStack]
-   * @returns {TokenOrNestedTokens}
-   */
-  string(obj, _typ, _options, _refStack) {
-    return new Token(Type.string, obj);
-  },
-  /**
-   * @param {any} obj
-   * @param {string} _typ
-   * @param {EncodeOptions} _options
-   * @param {Reference} [_refStack]
-   * @returns {TokenOrNestedTokens}
-   */
-  boolean(obj, _typ, _options, _refStack) {
-    return obj ? simpleTokens.true : simpleTokens.false;
-  },
-  /**
-   * @param {any} _obj
-   * @param {string} _typ
-   * @param {EncodeOptions} _options
-   * @param {Reference} [_refStack]
-   * @returns {TokenOrNestedTokens}
-   */
-  null(_obj, _typ, _options, _refStack) {
-    return simpleTokens.null;
-  },
-  /**
-   * @param {any} _obj
-   * @param {string} _typ
-   * @param {EncodeOptions} _options
-   * @param {Reference} [_refStack]
-   * @returns {TokenOrNestedTokens}
-   */
-  undefined(_obj, _typ, _options, _refStack) {
-    return simpleTokens.undefined;
-  },
-  /**
-   * @param {any} obj
-   * @param {string} _typ
-   * @param {EncodeOptions} _options
-   * @param {Reference} [_refStack]
-   * @returns {TokenOrNestedTokens}
-   */
-  ArrayBuffer(obj, _typ, _options, _refStack) {
-    return new Token(Type.bytes, new Uint8Array(obj));
-  },
-  /**
-   * @param {any} obj
-   * @param {string} _typ
-   * @param {EncodeOptions} _options
-   * @param {Reference} [_refStack]
-   * @returns {TokenOrNestedTokens}
-   */
-  DataView(obj, _typ, _options, _refStack) {
-    return new Token(Type.bytes, new Uint8Array(obj.buffer, obj.byteOffset, obj.byteLength));
-  },
-  /**
-   * @param {any} obj
-   * @param {string} _typ
-   * @param {EncodeOptions} options
-   * @param {Reference} [refStack]
-   * @returns {TokenOrNestedTokens}
-   */
-  Array(obj, _typ, options, refStack) {
-    if (!obj.length) {
-      if (options.addBreakTokens === true) {
-        return [simpleTokens.emptyArray, new Token(Type.break)];
-      }
-      return simpleTokens.emptyArray;
-    }
-    refStack = Ref.createCheck(refStack, obj);
-    const entries = [];
-    let i = 0;
-    for (const e of obj) {
-      entries[i++] = objectToTokens(e, options, refStack);
-    }
-    if (options.addBreakTokens) {
-      return [new Token(Type.array, obj.length), entries, new Token(Type.break)];
-    }
-    return [new Token(Type.array, obj.length), entries];
-  },
-  /**
-   * @param {any} obj
-   * @param {string} typ
-   * @param {EncodeOptions} options
-   * @param {Reference} [refStack]
-   * @returns {TokenOrNestedTokens}
-   */
-  Object(obj, typ, options, refStack) {
-    const isMap = typ !== "Object";
-    const keys = isMap ? obj.keys() : Object.keys(obj);
-    const maxLength = isMap ? obj.size : keys.length;
-    let entries;
-    if (maxLength) {
-      entries = new Array(maxLength);
-      refStack = Ref.createCheck(refStack, obj);
-      const skipUndefined = !isMap && options.ignoreUndefinedProperties;
-      let i = 0;
-      for (const key of keys) {
-        const value = isMap ? obj.get(key) : obj[key];
-        if (skipUndefined && value === void 0) {
-          continue;
-        }
-        entries[i++] = [
-          objectToTokens(key, options, refStack),
-          objectToTokens(value, options, refStack)
-        ];
-      }
-      if (i < maxLength) {
-        entries.length = i;
-      }
-    }
-    if (!(entries == null ? void 0 : entries.length)) {
-      if (options.addBreakTokens === true) {
-        return [simpleTokens.emptyMap, new Token(Type.break)];
-      }
-      return simpleTokens.emptyMap;
-    }
-    sortMapEntries(entries, options);
-    if (options.addBreakTokens) {
-      return [new Token(Type.map, entries.length), entries, new Token(Type.break)];
-    }
-    return [new Token(Type.map, entries.length), entries];
-  }
-};
-typeEncoders.Map = typeEncoders.Object;
-typeEncoders.Buffer = typeEncoders.Uint8Array;
-for (const typ of "Uint8Clamped Uint16 Uint32 Int8 Int16 Int32 BigUint64 BigInt64 Float32 Float64".split(" ")) {
-  typeEncoders[`${typ}Array`] = typeEncoders.DataView;
-}
-function objectToTokens(obj, options = {}, refStack) {
-  const typ = is(obj);
-  const customTypeEncoder = options && options.typeEncoders && /** @type {OptionalTypeEncoder} */
-  options.typeEncoders[typ] || typeEncoders[typ];
-  if (typeof customTypeEncoder === "function") {
-    const tokens = customTypeEncoder(obj, typ, options, refStack);
-    if (tokens != null) {
-      return tokens;
-    }
-  }
-  const typeEncoder = typeEncoders[typ];
-  if (!typeEncoder) {
-    throw new Error(`${encodeErrPrefix} unsupported type: ${typ}`);
-  }
-  return typeEncoder(obj, typ, options, refStack);
-}
-function sortMapEntries(entries, options) {
-  if (options.mapSorter) {
-    entries.sort(options.mapSorter);
-  }
-}
-function mapSorter(e1, e2) {
-  const keyToken1 = Array.isArray(e1[0]) ? e1[0][0] : e1[0];
-  const keyToken2 = Array.isArray(e2[0]) ? e2[0][0] : e2[0];
-  if (keyToken1.type !== keyToken2.type) {
-    return keyToken1.type.compare(keyToken2.type);
-  }
-  const major = keyToken1.type.major;
-  const tcmp = cborEncoders[major].compareTokens(keyToken1, keyToken2);
-  if (tcmp === 0) {
-    console.warn("WARNING: complex key types used, CBOR key sorting guarantees are gone");
-  }
-  return tcmp;
-}
-function tokensToEncoded(writer, tokens, encoders, options) {
-  if (Array.isArray(tokens)) {
-    for (const token of tokens) {
-      tokensToEncoded(writer, token, encoders, options);
-    }
-  } else {
-    encoders[tokens.type.major](writer, tokens, options);
-  }
-}
-const MAJOR_UINT = Type.uint.majorEncoded;
-const MAJOR_NEGINT = Type.negint.majorEncoded;
-const MAJOR_BYTES = Type.bytes.majorEncoded;
-const MAJOR_STRING = Type.string.majorEncoded;
-const MAJOR_ARRAY = Type.array.majorEncoded;
-const SIMPLE_FALSE = Type.float.majorEncoded | MINOR_FALSE;
-const SIMPLE_TRUE = Type.float.majorEncoded | MINOR_TRUE;
-const SIMPLE_NULL = Type.float.majorEncoded | MINOR_NULL;
-const SIMPLE_UNDEFINED = Type.float.majorEncoded | MINOR_UNDEFINED;
-const neg1b = BigInt(-1);
-const pos1b = BigInt(1);
-function canDirectEncode(options) {
-  return options.addBreakTokens !== true;
-}
-function directEncode(writer, data, options, refStack) {
-  const typ = is(data);
-  const customEncoder = options.typeEncoders && options.typeEncoders[typ];
-  if (customEncoder) {
-    const tokens = customEncoder(data, typ, options, refStack);
-    if (tokens != null) {
-      tokensToEncoded(writer, tokens, cborEncoders, options);
-      return;
-    }
-  }
-  switch (typ) {
-    case "null":
-      writer.push([SIMPLE_NULL]);
-      return;
-    case "undefined":
-      writer.push([SIMPLE_UNDEFINED]);
-      return;
-    case "boolean":
-      writer.push([data ? SIMPLE_TRUE : SIMPLE_FALSE]);
-      return;
-    case "number":
-      if (!Number.isInteger(data) || !Number.isSafeInteger(data)) {
-        encodeFloat(writer, new Token(Type.float, data), options);
-      } else if (data >= 0) {
-        encodeUintValue(writer, MAJOR_UINT, data);
-      } else {
-        encodeUintValue(writer, MAJOR_NEGINT, data * -1 - 1);
-      }
-      return;
-    case "bigint":
-      if (data >= BigInt(0)) {
-        encodeUintValue(writer, MAJOR_UINT, data);
-      } else {
-        encodeUintValue(writer, MAJOR_NEGINT, data * neg1b - pos1b);
-      }
-      return;
-    case "string": {
-      const bytes = fromString(data);
-      encodeUintValue(writer, MAJOR_STRING, bytes.length);
-      writer.push(bytes);
-      return;
-    }
-    case "Uint8Array":
-      encodeUintValue(writer, MAJOR_BYTES, data.length);
-      writer.push(data);
-      return;
-    case "Array":
-      if (!data.length) {
-        writer.push([MAJOR_ARRAY]);
-        return;
-      }
-      refStack = Ref.createCheck(refStack, data);
-      encodeUintValue(writer, MAJOR_ARRAY, data.length);
-      for (const elem of data) {
-        directEncode(writer, elem, options, refStack);
-      }
-      return;
-    case "Object":
-    case "Map":
-      {
-        const tokens = typeEncoders.Object(data, typ, options, refStack);
-        tokensToEncoded(writer, tokens, cborEncoders, options);
-      }
-      return;
-    default: {
-      const typeEncoder = typeEncoders[typ];
-      if (!typeEncoder) {
-        throw new Error(`${encodeErrPrefix} unsupported type: ${typ}`);
-      }
-      const tokens = typeEncoder(data, typ, options, refStack);
-      tokensToEncoded(writer, tokens, cborEncoders, options);
-    }
-  }
-}
-function encodeCustom(data, encoders, options, destination) {
-  const hasDest = destination instanceof Uint8Array;
-  let writeTo = hasDest ? new U8Bl(destination) : defaultWriter;
-  const tokens = objectToTokens(data, options);
-  if (!Array.isArray(tokens) && options.quickEncodeToken) {
-    const quickBytes = options.quickEncodeToken(tokens);
-    if (quickBytes) {
-      if (hasDest) {
-        writeTo.push(quickBytes);
-        return writeTo.toBytes();
-      }
-      return quickBytes;
-    }
-    const encoder = encoders[tokens.type.major];
-    if (encoder.encodedSize) {
-      const size = encoder.encodedSize(tokens, options);
-      if (!hasDest) {
-        writeTo = new Bl(size);
-      }
-      encoder(writeTo, tokens, options);
-      if (writeTo.chunks.length !== 1) {
-        throw new Error(`Unexpected error: pre-calculated length for ${tokens} was wrong`);
-      }
-      return hasDest ? writeTo.toBytes() : asU8A(writeTo.chunks[0]);
-    }
-  }
-  writeTo.reset();
-  tokensToEncoded(writeTo, tokens, encoders, options);
-  return writeTo.toBytes(true);
-}
-function encode$1(data, options) {
-  options = Object.assign({}, defaultEncodeOptions, options);
-  if (canDirectEncode(options)) {
-    defaultWriter.reset();
-    directEncode(defaultWriter, data, options, void 0);
-    return defaultWriter.toBytes(true);
-  }
-  return encodeCustom(data, cborEncoders, options);
-}
-const defaultDecodeOptions = {
-  strict: false,
-  allowIndefinite: true,
-  allowUndefined: true,
-  allowBigInt: true
-};
-class Tokeniser {
-  /**
-   * @param {Uint8Array} data
-   * @param {DecodeOptions} options
-   */
-  constructor(data, options = {}) {
-    this._pos = 0;
-    this.data = data;
-    this.options = options;
-  }
-  pos() {
-    return this._pos;
-  }
-  done() {
-    return this._pos >= this.data.length;
-  }
-  next() {
-    const byt = this.data[this._pos];
-    let token = quick[byt];
-    if (token === void 0) {
-      const decoder = jump[byt];
-      if (!decoder) {
-        throw new Error(`${decodeErrPrefix} no decoder for major type ${byt >>> 5} (byte 0x${byt.toString(16).padStart(2, "0")})`);
-      }
-      const minor = byt & 31;
-      token = decoder(this.data, this._pos, minor, this.options);
-    }
-    this._pos += token.encodedLength;
-    return token;
-  }
-}
-const DONE = Symbol.for("DONE");
-const BREAK = Symbol.for("BREAK");
-function tokenToArray(token, tokeniser, options) {
-  const arr = [];
-  for (let i = 0; i < token.value; i++) {
-    const value = tokensToObject(tokeniser, options);
-    if (value === BREAK) {
-      if (token.value === Infinity) {
-        break;
-      }
-      throw new Error(`${decodeErrPrefix} got unexpected break to lengthed array`);
-    }
-    if (value === DONE) {
-      throw new Error(`${decodeErrPrefix} found array but not enough entries (got ${i}, expected ${token.value})`);
-    }
-    arr[i] = value;
-  }
-  return arr;
-}
-function tokenToMap(token, tokeniser, options) {
-  const useMaps = options.useMaps === true;
-  const rejectDuplicateMapKeys = options.rejectDuplicateMapKeys === true;
-  const obj = useMaps ? void 0 : {};
-  const m = useMaps ? /* @__PURE__ */ new Map() : void 0;
-  for (let i = 0; i < token.value; i++) {
-    const key = tokensToObject(tokeniser, options);
-    if (key === BREAK) {
-      if (token.value === Infinity) {
-        break;
-      }
-      throw new Error(`${decodeErrPrefix} got unexpected break to lengthed map`);
-    }
-    if (key === DONE) {
-      throw new Error(`${decodeErrPrefix} found map but not enough entries (got ${i} [no key], expected ${token.value})`);
-    }
-    if (!useMaps && typeof key !== "string") {
-      throw new Error(`${decodeErrPrefix} non-string keys not supported (got ${typeof key})`);
-    }
-    if (rejectDuplicateMapKeys) {
-      if (useMaps && m.has(key) || !useMaps && Object.hasOwn(obj, key)) {
-        throw new Error(`${decodeErrPrefix} found repeat map key "${key}"`);
-      }
-    }
-    const value = tokensToObject(tokeniser, options);
-    if (value === DONE) {
-      throw new Error(`${decodeErrPrefix} found map but not enough entries (got ${i} [no value], expected ${token.value})`);
-    }
-    if (useMaps) {
-      m.set(key, value);
-    } else {
-      obj[key] = value;
-    }
-  }
-  return useMaps ? m : obj;
-}
-function tokensToObject(tokeniser, options) {
-  if (tokeniser.done()) {
-    return DONE;
-  }
-  const token = tokeniser.next();
-  if (Type.equals(token.type, Type.break)) {
-    return BREAK;
-  }
-  if (token.type.terminal) {
-    return token.value;
-  }
-  if (Type.equals(token.type, Type.array)) {
-    return tokenToArray(token, tokeniser, options);
-  }
-  if (Type.equals(token.type, Type.map)) {
-    return tokenToMap(token, tokeniser, options);
-  }
-  if (Type.equals(token.type, Type.tag)) {
-    if (options.tags && typeof options.tags[token.value] === "function") {
-      const tagged = tokensToObject(tokeniser, options);
-      return options.tags[token.value](tagged);
-    }
-    throw new Error(`${decodeErrPrefix} tag not supported (${token.value})`);
-  }
-  throw new Error("unsupported");
-}
-function decodeFirst(data, options) {
-  if (!(data instanceof Uint8Array)) {
-    throw new Error(`${decodeErrPrefix} data to decode must be a Uint8Array`);
-  }
-  options = Object.assign({}, defaultDecodeOptions, options);
-  const u8aData = asU8A(data);
-  const tokeniser = options.tokenizer || new Tokeniser(u8aData, options);
-  const decoded = tokensToObject(tokeniser, options);
-  if (decoded === DONE) {
-    throw new Error(`${decodeErrPrefix} did not find any content to decode`);
-  }
-  if (decoded === BREAK) {
-    throw new Error(`${decodeErrPrefix} got unexpected break`);
-  }
-  return [decoded, data.subarray(tokeniser.pos())];
-}
-function decode$1(data, options) {
-  const [decoded, remainder] = decodeFirst(data, options);
-  if (remainder.length > 0) {
-    throw new Error(`${decodeErrPrefix} too many terminals, data makes no sense`);
-  }
-  return decoded;
-}
-const CID_CBOR_TAG = 42;
-const encodeOptions = Object.freeze({
-  float64: true,
-  ignoreUndefinedProperties: true,
-  typeEncoders: Object.freeze({
-    Map: (map) => {
-      for (const key of map.keys()) {
-        if (typeof key !== "string") {
-          throw new Error(
-            'Only string keys are allowed in CBOR "map" by the AT Data Model'
-          );
-        }
-      }
-      return null;
-    },
-    Object: (obj) => {
-      const cid = lexData.ifCid(obj);
-      if (cid) {
-        const bytes = new Uint8Array(cid.bytes.byteLength + 1);
-        bytes.set(cid.bytes, 1);
-        return [new Token(Type.tag, CID_CBOR_TAG), new Token(Type.bytes, bytes)];
-      }
-      return null;
-    },
-    undefined: () => {
-      throw new Error("`undefined` is not supported by the AT Data Model");
-    },
-    number: (num) => {
-      if (Number.isSafeInteger(num)) return null;
-      throw new Error(
-        `Non-integer numbers (${num}) are not supported by the AT Data Model`
-      );
-    }
-  })
-});
-const decodeOptions = /* @__PURE__ */ Object.freeze({
-  allowIndefinite: false,
-  coerceUndefinedToNull: true,
-  allowNaN: false,
-  allowInfinity: false,
-  allowBigInt: true,
-  strict: true,
-  useMaps: false,
-  rejectDuplicateMapKeys: true,
-  tags: /* @__PURE__ */ Object.freeze(
-    /* @__PURE__ */ Object.assign([], {
-      [CID_CBOR_TAG]: (bytes) => {
-        if (bytes[0] !== 0) {
-          throw new Error("Invalid CID for CBOR tag 42; expected leading 0x00");
-        }
-        const cibBytes = bytes.subarray(1);
-        return lexData.decodeCid(cibBytes);
-      }
-    })
-  )
-});
-function encode(data) {
-  return encode$1(data, encodeOptions);
-}
-function decode(bytes) {
-  return decode$1(bytes, decodeOptions);
-}
-function* decodeAll(data) {
-  do {
-    const [result, remainingBytes] = decodeFirst(data, decodeOptions);
-    yield result;
-    data = remainingBytes;
-  } while (data.byteLength > 0);
-}
-async function cidForLex(value) {
-  return lexData.cidForCbor(encode(value));
-}
-exports.cborDecode = decode;
-exports.cborDecodeAll = decodeAll;
-exports.cborEncode = encode;
-exports.cidForLex = cidForLex;
-exports.decode = decode;
-exports.decodeAll = decodeAll;
-exports.decodeOptions = decodeOptions;
-exports.encode = encode;
-exports.encodeOptions = encodeOptions;