@peerbit/indexer-sqlite3 3.0.4 → 3.0.6

package/dist/index.min.js

@@ -18431,158 +18431,461 @@ var resize = (arr, newSize, defaultValue) => {
   arr.length = newSize;
 };
 
-// ../../../../node_modules/.pnpm/multiformats@13.4.1/node_modules/multiformats/dist/src/bytes.js
-var empty = new Uint8Array(0);
-function coerce(o) {
-  if (o instanceof Uint8Array && o.constructor.name === "Uint8Array") {
-    return o;
-  }
-  if (o instanceof ArrayBuffer) {
-    return new Uint8Array(o);
-  }
-  if (ArrayBuffer.isView(o)) {
-    return new Uint8Array(o.buffer, o.byteOffset, o.byteLength);
+// ../../../../node_modules/.pnpm/@stablelib+int@2.0.1/node_modules/@stablelib/int/lib/int.js
+var isInteger = Number.isInteger;
+var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
+var isSafeInteger = Number.isSafeInteger;
+
+// ../../../../node_modules/.pnpm/@stablelib+binary@2.0.1/node_modules/@stablelib/binary/lib/binary.js
+function readUint32BE(array, offset = 0) {
+  return (array[offset] << 24 | array[offset + 1] << 16 | array[offset + 2] << 8 | array[offset + 3]) >>> 0;
+}
+function writeUint32BE(value, out = new Uint8Array(4), offset = 0) {
+  out[offset + 0] = value >>> 24;
+  out[offset + 1] = value >>> 16;
+  out[offset + 2] = value >>> 8;
+  out[offset + 3] = value >>> 0;
+  return out;
+}
+
+// ../../../../node_modules/.pnpm/@stablelib+wipe@2.0.1/node_modules/@stablelib/wipe/lib/wipe.js
+function wipe(array) {
+  for (let i = 0; i < array.length; i++) {
+    array[i] = 0;
   }
-  throw new Error("Unknown type, must be binary type");
+  return array;
 }
 
-// ../../../../node_modules/.pnpm/multiformats@13.4.1/node_modules/multiformats/dist/src/vendor/base-x.js
-function base(ALPHABET, name) {
-  if (ALPHABET.length >= 255) {
-    throw new TypeError("Alphabet too long");
+// ../../../../node_modules/.pnpm/@stablelib+sha256@2.0.1/node_modules/@stablelib/sha256/lib/sha256.js
+var DIGEST_LENGTH = 32;
+var BLOCK_SIZE = 64;
+var SHA256 = class {
+  /** Length of hash output */
+  digestLength = DIGEST_LENGTH;
+  /** Block size */
+  blockSize = BLOCK_SIZE;
+  // Note: Int32Array is used instead of Uint32Array for performance reasons.
+  _state = new Int32Array(8);
+  // hash state
+  _temp = new Int32Array(64);
+  // temporary state
+  _buffer = new Uint8Array(128);
+  // buffer for data to hash
+  _bufferLength = 0;
+  // number of bytes in buffer
+  _bytesHashed = 0;
+  // number of total bytes hashed
+  _finished = false;
+  // indicates whether the hash was finalized
+  constructor() {
+    this.reset();
   }
-  var BASE_MAP = new Uint8Array(256);
-  for (var j = 0; j < BASE_MAP.length; j++) {
-    BASE_MAP[j] = 255;
+  _initState() {
+    this._state[0] = 1779033703;
+    this._state[1] = 3144134277;
+    this._state[2] = 1013904242;
+    this._state[3] = 2773480762;
+    this._state[4] = 1359893119;
+    this._state[5] = 2600822924;
+    this._state[6] = 528734635;
+    this._state[7] = 1541459225;
   }
-  for (var i = 0; i < ALPHABET.length; i++) {
-    var x = ALPHABET.charAt(i);
-    var xc = x.charCodeAt(0);
-    if (BASE_MAP[xc] !== 255) {
-      throw new TypeError(x + " is ambiguous");
-    }
-    BASE_MAP[xc] = i;
+  /**
+   * Resets hash state making it possible
+   * to re-use this instance to hash other data.
+   */
+  reset() {
+    this._initState();
+    this._bufferLength = 0;
+    this._bytesHashed = 0;
+    this._finished = false;
+    return this;
   }
-  var BASE = ALPHABET.length;
-  var LEADER = ALPHABET.charAt(0);
-  var FACTOR = Math.log(BASE) / Math.log(256);
-  var iFACTOR = Math.log(256) / Math.log(BASE);
-  function encode(source) {
-    if (source instanceof Uint8Array)
-      ;
-    else if (ArrayBuffer.isView(source)) {
-      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
-    } else if (Array.isArray(source)) {
-      source = Uint8Array.from(source);
-    }
-    if (!(source instanceof Uint8Array)) {
-      throw new TypeError("Expected Uint8Array");
-    }
-    if (source.length === 0) {
-      return "";
-    }
-    var zeroes = 0;
-    var length = 0;
-    var pbegin = 0;
-    var pend = source.length;
-    while (pbegin !== pend && source[pbegin] === 0) {
-      pbegin++;
-      zeroes++;
+  /**
+   * Cleans internal buffers and resets hash state.
+   */
+  clean() {
+    wipe(this._buffer);
+    wipe(this._temp);
+    this.reset();
+  }
+  /**
+   * Updates hash state with the given data.
+   *
+   * Throws error when trying to update already finalized hash:
+   * instance must be reset to update it again.
+   */
+  update(data, dataLength = data.length) {
+    if (this._finished) {
+      throw new Error("SHA256: can't update because hash was finished.");
     }
-    var size = (pend - pbegin) * iFACTOR + 1 >>> 0;
-    var b58 = new Uint8Array(size);
-    while (pbegin !== pend) {
-      var carry = source[pbegin];
-      var i2 = 0;
-      for (var it1 = size - 1; (carry !== 0 || i2 < length) && it1 !== -1; it1--, i2++) {
-        carry += 256 * b58[it1] >>> 0;
-        b58[it1] = carry % BASE >>> 0;
-        carry = carry / BASE >>> 0;
+    let dataPos = 0;
+    this._bytesHashed += dataLength;
+    if (this._bufferLength > 0) {
+      while (this._bufferLength < this.blockSize && dataLength > 0) {
+        this._buffer[this._bufferLength++] = data[dataPos++];
+        dataLength--;
       }
-      if (carry !== 0) {
-        throw new Error("Non-zero carry");
+      if (this._bufferLength === this.blockSize) {
+        hashBlocks(this._temp, this._state, this._buffer, 0, this.blockSize);
+        this._bufferLength = 0;
       }
-      length = i2;
-      pbegin++;
     }
-    var it2 = size - length;
-    while (it2 !== size && b58[it2] === 0) {
-      it2++;
+    if (dataLength >= this.blockSize) {
+      dataPos = hashBlocks(this._temp, this._state, data, dataPos, dataLength);
+      dataLength %= this.blockSize;
     }
-    var str = LEADER.repeat(zeroes);
-    for (; it2 < size; ++it2) {
-      str += ALPHABET.charAt(b58[it2]);
+    while (dataLength > 0) {
+      this._buffer[this._bufferLength++] = data[dataPos++];
+      dataLength--;
     }
-    return str;
+    return this;
   }
-  function decodeUnsafe(source) {
-    if (typeof source !== "string") {
-      throw new TypeError("Expected String");
-    }
-    if (source.length === 0) {
-      return new Uint8Array();
-    }
-    var psz = 0;
-    if (source[psz] === " ") {
-      return;
-    }
-    var zeroes = 0;
-    var length = 0;
-    while (source[psz] === LEADER) {
-      zeroes++;
-      psz++;
-    }
-    var size = (source.length - psz) * FACTOR + 1 >>> 0;
-    var b256 = new Uint8Array(size);
-    while (source[psz]) {
-      var carry = BASE_MAP[source.charCodeAt(psz)];
-      if (carry === 255) {
-        return;
-      }
-      var i2 = 0;
-      for (var it3 = size - 1; (carry !== 0 || i2 < length) && it3 !== -1; it3--, i2++) {
-        carry += BASE * b256[it3] >>> 0;
-        b256[it3] = carry % 256 >>> 0;
-        carry = carry / 256 >>> 0;
-      }
-      if (carry !== 0) {
-        throw new Error("Non-zero carry");
+  /**
+   * Finalizes hash state and puts hash into out.
+   * If hash was already finalized, puts the same value.
+   */
+  finish(out) {
+    if (!this._finished) {
+      const bytesHashed = this._bytesHashed;
+      const left = this._bufferLength;
+      const bitLenHi = bytesHashed / 536870912 | 0;
+      const bitLenLo = bytesHashed << 3;
+      const padLength = bytesHashed % 64 < 56 ? 64 : 128;
+      this._buffer[left] = 128;
+      for (let i = left + 1; i < padLength - 8; i++) {
+        this._buffer[i] = 0;
       }
-      length = i2;
-      psz++;
-    }
-    if (source[psz] === " ") {
-      return;
-    }
-    var it4 = size - length;
-    while (it4 !== size && b256[it4] === 0) {
-      it4++;
+      writeUint32BE(bitLenHi, this._buffer, padLength - 8);
+      writeUint32BE(bitLenLo, this._buffer, padLength - 4);
+      hashBlocks(this._temp, this._state, this._buffer, 0, padLength);
+      this._finished = true;
     }
-    var vch = new Uint8Array(zeroes + (size - it4));
-    var j2 = zeroes;
-    while (it4 !== size) {
-      vch[j2++] = b256[it4++];
+    for (let i = 0; i < this.digestLength / 4; i++) {
+      writeUint32BE(this._state[i], out, i * 4);
     }
-    return vch;
+    return this;
   }
-  function decode(string) {
-    var buffer = decodeUnsafe(string);
-    if (buffer) {
-      return buffer;
-    }
-    throw new Error(`Non-${name} character`);
+  /**
+   * Returns the final hash digest.
+   */
+  digest() {
+    const out = new Uint8Array(this.digestLength);
+    this.finish(out);
+    return out;
   }
-  return {
-    encode,
-    decodeUnsafe,
-    decode
-  };
-}
-var src = base;
-var _brrp__multiformats_scope_baseX = src;
-var base_x_default = _brrp__multiformats_scope_baseX;
-
-// ../../../../node_modules/.pnpm/multiformats@13.4.1/node_modules/multiformats/dist/src/bases/base.js
+  /**
+   * Function useful for HMAC/PBKDF2 optimization.
+   * Returns hash state to be used with restoreState().
+   * Only chain value is saved, not buffers or other
+   * state variables.
+   */
+  saveState() {
+    if (this._finished) {
+      throw new Error("SHA256: cannot save finished state");
+    }
+    return {
+      state: new Int32Array(this._state),
+      buffer: this._bufferLength > 0 ? new Uint8Array(this._buffer) : void 0,
+      bufferLength: this._bufferLength,
+      bytesHashed: this._bytesHashed
+    };
+  }
+  /**
+   * Function useful for HMAC/PBKDF2 optimization.
+   * Restores state saved by saveState() and sets bytesHashed
+   * to the given value.
+   */
+  restoreState(savedState) {
+    this._state.set(savedState.state);
+    this._bufferLength = savedState.bufferLength;
+    if (savedState.buffer) {
+      this._buffer.set(savedState.buffer);
+    }
+    this._bytesHashed = savedState.bytesHashed;
+    this._finished = false;
+    return this;
+  }
+  /**
+   * Cleans state returned by saveState().
+   */
+  cleanSavedState(savedState) {
+    wipe(savedState.state);
+    if (savedState.buffer) {
+      wipe(savedState.buffer);
+    }
+    savedState.bufferLength = 0;
+    savedState.bytesHashed = 0;
+  }
+};
+var K = new Int32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+function hashBlocks(w, v2, p, pos, len) {
+  while (len >= 64) {
+    let a = v2[0];
+    let b = v2[1];
+    let c = v2[2];
+    let d = v2[3];
+    let e = v2[4];
+    let f = v2[5];
+    let g = v2[6];
+    let h = v2[7];
+    for (let i = 0; i < 16; i++) {
+      let j = pos + i * 4;
+      w[i] = readUint32BE(p, j);
+    }
+    for (let i = 16; i < 64; i++) {
+      let u = w[i - 2];
+      let t1 = (u >>> 17 | u << 32 - 17) ^ (u >>> 19 | u << 32 - 19) ^ u >>> 10;
+      u = w[i - 15];
+      let t2 = (u >>> 7 | u << 32 - 7) ^ (u >>> 18 | u << 32 - 18) ^ u >>> 3;
+      w[i] = (t1 + w[i - 7] | 0) + (t2 + w[i - 16] | 0);
+    }
+    for (let i = 0; i < 64; i++) {
+      let t1 = (((e >>> 6 | e << 32 - 6) ^ (e >>> 11 | e << 32 - 11) ^ (e >>> 25 | e << 32 - 25)) + (e & f ^ ~e & g) | 0) + (h + (K[i] + w[i] | 0) | 0) | 0;
+      let t2 = ((a >>> 2 | a << 32 - 2) ^ (a >>> 13 | a << 32 - 13) ^ (a >>> 22 | a << 32 - 22)) + (a & b ^ a & c ^ b & c) | 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + t1 | 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 | 0;
+    }
+    v2[0] += a;
+    v2[1] += b;
+    v2[2] += c;
+    v2[3] += d;
+    v2[4] += e;
+    v2[5] += f;
+    v2[6] += g;
+    v2[7] += h;
+    pos += 64;
+    len -= 64;
+  }
+  return pos;
+}
+
+// ../../crypto/dist/src/utils.js
+var import_libsodium_wrappers = __toESM(require_libsodium_wrappers(), 1);
+
+// ../../../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/bytes.js
+var empty = new Uint8Array(0);
+function coerce(o) {
+  if (o instanceof Uint8Array && o.constructor.name === "Uint8Array") {
+    return o;
+  }
+  if (o instanceof ArrayBuffer) {
+    return new Uint8Array(o);
+  }
+  if (ArrayBuffer.isView(o)) {
+    return new Uint8Array(o.buffer, o.byteOffset, o.byteLength);
+  }
+  throw new Error("Unknown type, must be binary type");
+}
+
+// ../../../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/vendor/base-x.js
+function base(ALPHABET, name) {
+  if (ALPHABET.length >= 255) {
+    throw new TypeError("Alphabet too long");
+  }
+  var BASE_MAP = new Uint8Array(256);
+  for (var j = 0; j < BASE_MAP.length; j++) {
+    BASE_MAP[j] = 255;
+  }
+  for (var i = 0; i < ALPHABET.length; i++) {
+    var x = ALPHABET.charAt(i);
+    var xc = x.charCodeAt(0);
+    if (BASE_MAP[xc] !== 255) {
+      throw new TypeError(x + " is ambiguous");
+    }
+    BASE_MAP[xc] = i;
+  }
+  var BASE = ALPHABET.length;
+  var LEADER = ALPHABET.charAt(0);
+  var FACTOR = Math.log(BASE) / Math.log(256);
+  var iFACTOR = Math.log(256) / Math.log(BASE);
+  function encode(source) {
+    if (source instanceof Uint8Array)
+      ;
+    else if (ArrayBuffer.isView(source)) {
+      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+    } else if (Array.isArray(source)) {
+      source = Uint8Array.from(source);
+    }
+    if (!(source instanceof Uint8Array)) {
+      throw new TypeError("Expected Uint8Array");
+    }
+    if (source.length === 0) {
+      return "";
+    }
+    var zeroes = 0;
+    var length = 0;
+    var pbegin = 0;
+    var pend = source.length;
+    while (pbegin !== pend && source[pbegin] === 0) {
+      pbegin++;
+      zeroes++;
+    }
+    var size = (pend - pbegin) * iFACTOR + 1 >>> 0;
+    var b58 = new Uint8Array(size);
+    while (pbegin !== pend) {
+      var carry = source[pbegin];
+      var i2 = 0;
+      for (var it1 = size - 1; (carry !== 0 || i2 < length) && it1 !== -1; it1--, i2++) {
+        carry += 256 * b58[it1] >>> 0;
+        b58[it1] = carry % BASE >>> 0;
+        carry = carry / BASE >>> 0;
+      }
+      if (carry !== 0) {
+        throw new Error("Non-zero carry");
+      }
+      length = i2;
+      pbegin++;
+    }
+    var it2 = size - length;
+    while (it2 !== size && b58[it2] === 0) {
+      it2++;
+    }
+    var str = LEADER.repeat(zeroes);
+    for (; it2 < size; ++it2) {
+      str += ALPHABET.charAt(b58[it2]);
+    }
+    return str;
+  }
+  function decodeUnsafe(source) {
+    if (typeof source !== "string") {
+      throw new TypeError("Expected String");
+    }
+    if (source.length === 0) {
+      return new Uint8Array();
+    }
+    var psz = 0;
+    if (source[psz] === " ") {
+      return;
+    }
+    var zeroes = 0;
+    var length = 0;
+    while (source[psz] === LEADER) {
+      zeroes++;
+      psz++;
+    }
+    var size = (source.length - psz) * FACTOR + 1 >>> 0;
+    var b256 = new Uint8Array(size);
+    while (source[psz]) {
+      var carry = BASE_MAP[source.charCodeAt(psz)];
+      if (carry === 255) {
+        return;
+      }
+      var i2 = 0;
+      for (var it3 = size - 1; (carry !== 0 || i2 < length) && it3 !== -1; it3--, i2++) {
+        carry += BASE * b256[it3] >>> 0;
+        b256[it3] = carry % 256 >>> 0;
+        carry = carry / 256 >>> 0;
+      }
+      if (carry !== 0) {
+        throw new Error("Non-zero carry");
+      }
+      length = i2;
+      psz++;
+    }
+    if (source[psz] === " ") {
+      return;
+    }
+    var it4 = size - length;
+    while (it4 !== size && b256[it4] === 0) {
+      it4++;
+    }
+    var vch = new Uint8Array(zeroes + (size - it4));
+    var j2 = zeroes;
+    while (it4 !== size) {
+      vch[j2++] = b256[it4++];
+    }
+    return vch;
+  }
+  function decode(string) {
+    var buffer = decodeUnsafe(string);
+    if (buffer) {
+      return buffer;
+    }
+    throw new Error(`Non-${name} character`);
+  }
+  return {
+    encode,
+    decodeUnsafe,
+    decode
+  };
+}
+var src = base;
+var _brrp__multiformats_scope_baseX = src;
+var base_x_default = _brrp__multiformats_scope_baseX;
+
+// ../../../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/bases/base.js
 var Encoder = class {
   name;
   prefix;
@@ -18609,399 +18912,98 @@ var Decoder = class {
     this.name = name;
     this.prefix = prefix;
     const prefixCodePoint = prefix.codePointAt(0);
-    if (prefixCodePoint === void 0) {
-      throw new Error("Invalid prefix character");
-    }
-    this.prefixCodePoint = prefixCodePoint;
-    this.baseDecode = baseDecode;
-  }
-  decode(text) {
-    if (typeof text === "string") {
-      if (text.codePointAt(0) !== this.prefixCodePoint) {
-        throw Error(`Unable to decode multibase string ${JSON.stringify(text)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`);
-      }
-      return this.baseDecode(text.slice(this.prefix.length));
-    } else {
-      throw Error("Can only multibase decode strings");
-    }
-  }
-  or(decoder) {
-    return or(this, decoder);
-  }
-};
-var ComposedDecoder = class {
-  decoders;
-  constructor(decoders) {
-    this.decoders = decoders;
-  }
-  or(decoder) {
-    return or(this, decoder);
-  }
-  decode(input) {
-    const prefix = input[0];
-    const decoder = this.decoders[prefix];
-    if (decoder != null) {
-      return decoder.decode(input);
-    } else {
-      throw RangeError(`Unable to decode multibase string ${JSON.stringify(input)}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`);
-    }
-  }
-};
-function or(left, right) {
-  return new ComposedDecoder({
-    ...left.decoders ?? { [left.prefix]: left },
-    ...right.decoders ?? { [right.prefix]: right }
-  });
-}
-var Codec = class {
-  name;
-  prefix;
-  baseEncode;
-  baseDecode;
-  encoder;
-  decoder;
-  constructor(name, prefix, baseEncode, baseDecode) {
-    this.name = name;
-    this.prefix = prefix;
-    this.baseEncode = baseEncode;
-    this.baseDecode = baseDecode;
-    this.encoder = new Encoder(name, prefix, baseEncode);
-    this.decoder = new Decoder(name, prefix, baseDecode);
-  }
-  encode(input) {
-    return this.encoder.encode(input);
-  }
-  decode(input) {
-    return this.decoder.decode(input);
-  }
-};
-function from({ name, prefix, encode, decode }) {
-  return new Codec(name, prefix, encode, decode);
-}
-function baseX({ name, prefix, alphabet }) {
-  const { encode, decode } = base_x_default(alphabet, name);
-  return from({
-    prefix,
-    name,
-    encode,
-    decode: (text) => coerce(decode(text))
-  });
-}
-
-// ../../../../node_modules/.pnpm/multiformats@13.4.1/node_modules/multiformats/dist/src/bases/base58.js
-var base58btc = baseX({
-  name: "base58btc",
-  prefix: "z",
-  alphabet: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
-});
-var base58flickr = baseX({
-  name: "base58flickr",
-  prefix: "Z",
-  alphabet: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
-});
-
-// ../../../../node_modules/.pnpm/@stablelib+int@2.0.1/node_modules/@stablelib/int/lib/int.js
-var isInteger = Number.isInteger;
-var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
-var isSafeInteger = Number.isSafeInteger;
-
-// ../../../../node_modules/.pnpm/@stablelib+binary@2.0.1/node_modules/@stablelib/binary/lib/binary.js
-function readUint32BE(array, offset = 0) {
-  return (array[offset] << 24 | array[offset + 1] << 16 | array[offset + 2] << 8 | array[offset + 3]) >>> 0;
-}
-function writeUint32BE(value, out = new Uint8Array(4), offset = 0) {
-  out[offset + 0] = value >>> 24;
-  out[offset + 1] = value >>> 16;
-  out[offset + 2] = value >>> 8;
-  out[offset + 3] = value >>> 0;
-  return out;
-}
-
-// ../../../../node_modules/.pnpm/@stablelib+wipe@2.0.1/node_modules/@stablelib/wipe/lib/wipe.js
-function wipe(array) {
-  for (let i = 0; i < array.length; i++) {
-    array[i] = 0;
-  }
-  return array;
-}
-
-// ../../../../node_modules/.pnpm/@stablelib+sha256@2.0.1/node_modules/@stablelib/sha256/lib/sha256.js
-var DIGEST_LENGTH = 32;
-var BLOCK_SIZE = 64;
-var SHA256 = class {
-  /** Length of hash output */
-  digestLength = DIGEST_LENGTH;
-  /** Block size */
-  blockSize = BLOCK_SIZE;
-  // Note: Int32Array is used instead of Uint32Array for performance reasons.
-  _state = new Int32Array(8);
-  // hash state
-  _temp = new Int32Array(64);
-  // temporary state
-  _buffer = new Uint8Array(128);
-  // buffer for data to hash
-  _bufferLength = 0;
-  // number of bytes in buffer
-  _bytesHashed = 0;
-  // number of total bytes hashed
-  _finished = false;
-  // indicates whether the hash was finalized
-  constructor() {
-    this.reset();
-  }
-  _initState() {
-    this._state[0] = 1779033703;
-    this._state[1] = 3144134277;
-    this._state[2] = 1013904242;
-    this._state[3] = 2773480762;
-    this._state[4] = 1359893119;
-    this._state[5] = 2600822924;
-    this._state[6] = 528734635;
-    this._state[7] = 1541459225;
-  }
-  /**
-   * Resets hash state making it possible
-   * to re-use this instance to hash other data.
-   */
-  reset() {
-    this._initState();
-    this._bufferLength = 0;
-    this._bytesHashed = 0;
-    this._finished = false;
-    return this;
-  }
-  /**
-   * Cleans internal buffers and resets hash state.
-   */
-  clean() {
-    wipe(this._buffer);
-    wipe(this._temp);
-    this.reset();
-  }
-  /**
-   * Updates hash state with the given data.
-   *
-   * Throws error when trying to update already finalized hash:
-   * instance must be reset to update it again.
-   */
-  update(data, dataLength = data.length) {
-    if (this._finished) {
-      throw new Error("SHA256: can't update because hash was finished.");
-    }
-    let dataPos = 0;
-    this._bytesHashed += dataLength;
-    if (this._bufferLength > 0) {
-      while (this._bufferLength < this.blockSize && dataLength > 0) {
-        this._buffer[this._bufferLength++] = data[dataPos++];
-        dataLength--;
-      }
-      if (this._bufferLength === this.blockSize) {
-        hashBlocks(this._temp, this._state, this._buffer, 0, this.blockSize);
-        this._bufferLength = 0;
-      }
-    }
-    if (dataLength >= this.blockSize) {
-      dataPos = hashBlocks(this._temp, this._state, data, dataPos, dataLength);
-      dataLength %= this.blockSize;
-    }
-    while (dataLength > 0) {
-      this._buffer[this._bufferLength++] = data[dataPos++];
-      dataLength--;
+    if (prefixCodePoint === void 0) {
+      throw new Error("Invalid prefix character");
     }
-    return this;
+    this.prefixCodePoint = prefixCodePoint;
+    this.baseDecode = baseDecode;
   }
-  /**
-   * Finalizes hash state and puts hash into out.
-   * If hash was already finalized, puts the same value.
-   */
-  finish(out) {
-    if (!this._finished) {
-      const bytesHashed = this._bytesHashed;
-      const left = this._bufferLength;
-      const bitLenHi = bytesHashed / 536870912 | 0;
-      const bitLenLo = bytesHashed << 3;
-      const padLength = bytesHashed % 64 < 56 ? 64 : 128;
-      this._buffer[left] = 128;
-      for (let i = left + 1; i < padLength - 8; i++) {
-        this._buffer[i] = 0;
+  decode(text) {
+    if (typeof text === "string") {
+      if (text.codePointAt(0) !== this.prefixCodePoint) {
+        throw Error(`Unable to decode multibase string ${JSON.stringify(text)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`);
       }
-      writeUint32BE(bitLenHi, this._buffer, padLength - 8);
-      writeUint32BE(bitLenLo, this._buffer, padLength - 4);
-      hashBlocks(this._temp, this._state, this._buffer, 0, padLength);
-      this._finished = true;
-    }
-    for (let i = 0; i < this.digestLength / 4; i++) {
-      writeUint32BE(this._state[i], out, i * 4);
+      return this.baseDecode(text.slice(this.prefix.length));
+    } else {
+      throw Error("Can only multibase decode strings");
     }
-    return this;
   }
-  /**
-   * Returns the final hash digest.
-   */
-  digest() {
-    const out = new Uint8Array(this.digestLength);
-    this.finish(out);
-    return out;
+  or(decoder) {
+    return or(this, decoder);
   }
-  /**
-   * Function useful for HMAC/PBKDF2 optimization.
-   * Returns hash state to be used with restoreState().
-   * Only chain value is saved, not buffers or other
-   * state variables.
-   */
-  saveState() {
-    if (this._finished) {
-      throw new Error("SHA256: cannot save finished state");
-    }
-    return {
-      state: new Int32Array(this._state),
-      buffer: this._bufferLength > 0 ? new Uint8Array(this._buffer) : void 0,
-      bufferLength: this._bufferLength,
-      bytesHashed: this._bytesHashed
-    };
+};
+var ComposedDecoder = class {
+  decoders;
+  constructor(decoders) {
+    this.decoders = decoders;
   }
-  /**
-   * Function useful for HMAC/PBKDF2 optimization.
-   * Restores state saved by saveState() and sets bytesHashed
-   * to the given value.
-   */
-  restoreState(savedState) {
-    this._state.set(savedState.state);
-    this._bufferLength = savedState.bufferLength;
-    if (savedState.buffer) {
-      this._buffer.set(savedState.buffer);
-    }
-    this._bytesHashed = savedState.bytesHashed;
-    this._finished = false;
-    return this;
+  or(decoder) {
+    return or(this, decoder);
   }
-  /**
-   * Cleans state returned by saveState().
-   */
-  cleanSavedState(savedState) {
-    wipe(savedState.state);
-    if (savedState.buffer) {
-      wipe(savedState.buffer);
+  decode(input) {
+    const prefix = input[0];
+    const decoder = this.decoders[prefix];
+    if (decoder != null) {
+      return decoder.decode(input);
+    } else {
+      throw RangeError(`Unable to decode multibase string ${JSON.stringify(input)}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`);
     }
-    savedState.bufferLength = 0;
-    savedState.bytesHashed = 0;
   }
 };
-var K = new Int32Array([
-  1116352408,
-  1899447441,
-  3049323471,
-  3921009573,
-  961987163,
-  1508970993,
-  2453635748,
-  2870763221,
-  3624381080,
-  310598401,
-  607225278,
-  1426881987,
-  1925078388,
-  2162078206,
-  2614888103,
-  3248222580,
-  3835390401,
-  4022224774,
-  264347078,
-  604807628,
-  770255983,
-  1249150122,
-  1555081692,
-  1996064986,
-  2554220882,
-  2821834349,
-  2952996808,
-  3210313671,
-  3336571891,
-  3584528711,
-  113926993,
-  338241895,
-  666307205,
-  773529912,
-  1294757372,
-  1396182291,
-  1695183700,
-  1986661051,
-  2177026350,
-  2456956037,
-  2730485921,
-  2820302411,
-  3259730800,
-  3345764771,
-  3516065817,
-  3600352804,
-  4094571909,
-  275423344,
-  430227734,
-  506948616,
-  659060556,
-  883997877,
-  958139571,
-  1322822218,
-  1537002063,
-  1747873779,
-  1955562222,
-  2024104815,
-  2227730452,
-  2361852424,
-  2428436474,
-  2756734187,
-  3204031479,
-  3329325298
-]);
-function hashBlocks(w, v2, p, pos, len) {
-  while (len >= 64) {
-    let a = v2[0];
-    let b = v2[1];
-    let c = v2[2];
-    let d = v2[3];
-    let e = v2[4];
-    let f = v2[5];
-    let g = v2[6];
-    let h = v2[7];
-    for (let i = 0; i < 16; i++) {
-      let j = pos + i * 4;
-      w[i] = readUint32BE(p, j);
-    }
-    for (let i = 16; i < 64; i++) {
-      let u = w[i - 2];
-      let t1 = (u >>> 17 | u << 32 - 17) ^ (u >>> 19 | u << 32 - 19) ^ u >>> 10;
-      u = w[i - 15];
-      let t2 = (u >>> 7 | u << 32 - 7) ^ (u >>> 18 | u << 32 - 18) ^ u >>> 3;
-      w[i] = (t1 + w[i - 7] | 0) + (t2 + w[i - 16] | 0);
-    }
-    for (let i = 0; i < 64; i++) {
-      let t1 = (((e >>> 6 | e << 32 - 6) ^ (e >>> 11 | e << 32 - 11) ^ (e >>> 25 | e << 32 - 25)) + (e & f ^ ~e & g) | 0) + (h + (K[i] + w[i] | 0) | 0) | 0;
-      let t2 = ((a >>> 2 | a << 32 - 2) ^ (a >>> 13 | a << 32 - 13) ^ (a >>> 22 | a << 32 - 22)) + (a & b ^ a & c ^ b & c) | 0;
-      h = g;
-      g = f;
-      f = e;
-      e = d + t1 | 0;
-      d = c;
-      c = b;
-      b = a;
-      a = t1 + t2 | 0;
-    }
-    v2[0] += a;
-    v2[1] += b;
-    v2[2] += c;
-    v2[3] += d;
-    v2[4] += e;
-    v2[5] += f;
-    v2[6] += g;
-    v2[7] += h;
-    pos += 64;
-    len -= 64;
+function or(left, right) {
+  return new ComposedDecoder({
+    ...left.decoders ?? { [left.prefix]: left },
+    ...right.decoders ?? { [right.prefix]: right }
+  });
+}
+var Codec = class {
+  name;
+  prefix;
+  baseEncode;
+  baseDecode;
+  encoder;
+  decoder;
+  constructor(name, prefix, baseEncode, baseDecode) {
+    this.name = name;
+    this.prefix = prefix;
+    this.baseEncode = baseEncode;
+    this.baseDecode = baseDecode;
+    this.encoder = new Encoder(name, prefix, baseEncode);
+    this.decoder = new Decoder(name, prefix, baseDecode);
   }
-  return pos;
+  encode(input) {
+    return this.encoder.encode(input);
+  }
+  decode(input) {
+    return this.decoder.decode(input);
+  }
+};
+function from({ name, prefix, encode, decode }) {
+  return new Codec(name, prefix, encode, decode);
+}
+function baseX({ name, prefix, alphabet }) {
+  const { encode, decode } = base_x_default(alphabet, name);
+  return from({
+    prefix,
+    name,
+    encode,
+    decode: (text) => coerce(decode(text))
+  });
 }
 
+// ../../../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/bases/base58.js
+var base58btc = baseX({
+  name: "base58btc",
+  prefix: "z",
+  alphabet: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+});
+var base58flickr = baseX({
+  name: "base58flickr",
+  prefix: "Z",
+  alphabet: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
+});
+
 // ../../crypto/dist/src/utils.js
-var import_libsodium_wrappers = __toESM(require_libsodium_wrappers(), 1);
 var fromHexString = (hexString) => import_libsodium_wrappers.default.from_hex(hexString);
 var asU8 = (bytes) => {
   return bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);