@wovin/connect-nftstorage 0.0.1-RC21 → 0.0.1-RC22

package/dist/chunk-R6GDUZUI.js

@@ -0,0 +1,1520 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from2, except, desc) => {
+  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+    for (let key of __getOwnPropNames(from2))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// ../../../node_modules/.pnpm/multiformats@12.1.3/node_modules/multiformats/src/bases/base32.js
+var base32_exports = {};
+__export(base32_exports, {
+  base32: () => base32,
+  base32hex: () => base32hex,
+  base32hexpad: () => base32hexpad,
+  base32hexpadupper: () => base32hexpadupper,
+  base32hexupper: () => base32hexupper,
+  base32pad: () => base32pad,
+  base32padupper: () => base32padupper,
+  base32upper: () => base32upper,
+  base32z: () => base32z
+});
+
+// ../../../node_modules/.pnpm/multiformats@12.1.3/node_modules/multiformats/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 encode3(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 length2 = 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 < length2) && 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");
+      }
+      length2 = i2;
+      pbegin++;
+    }
+    var it2 = size - length2;
+    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 length2 = 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 < length2) && 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");
+      }
+      length2 = i2;
+      psz++;
+    }
+    if (source[psz] === " ") {
+      return;
+    }
+    var it4 = size - length2;
+    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 decode5(string) {
+    var buffer = decodeUnsafe(string);
+    if (buffer) {
+      return buffer;
+    }
+    throw new Error(`Non-${name} character`);
+  }
+  return {
+    encode: encode3,
+    decodeUnsafe,
+    decode: decode5
+  };
+}
+var src = base;
+var _brrp__multiformats_scope_baseX = src;
+var base_x_default = _brrp__multiformats_scope_baseX;
+
+// ../../../node_modules/.pnpm/multiformats@12.1.3/node_modules/multiformats/src/bytes.js
+var empty = new Uint8Array(0);
+var equals = (aa, bb) => {
+  if (aa === bb)
+    return true;
+  if (aa.byteLength !== bb.byteLength) {
+    return false;
+  }
+  for (let ii = 0; ii < aa.byteLength; ii++) {
+    if (aa[ii] !== bb[ii]) {
+      return false;
+    }
+  }
+  return true;
+};
+var 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");
+};
+var fromString = (str) => new TextEncoder().encode(str);
+var toString = (b) => new TextDecoder().decode(b);
+
+// ../../../node_modules/.pnpm/multiformats@12.1.3/node_modules/multiformats/src/bases/base.js
+var Encoder = class {
+  /**
+   * @param {Base} name
+   * @param {Prefix} prefix
+   * @param {(bytes:Uint8Array) => string} baseEncode
+   */
+  constructor(name, prefix, baseEncode) {
+    this.name = name;
+    this.prefix = prefix;
+    this.baseEncode = baseEncode;
+  }
+  /**
+   * @param {Uint8Array} bytes
+   * @returns {API.Multibase<Prefix>}
+   */
+  encode(bytes) {
+    if (bytes instanceof Uint8Array) {
+      return `${this.prefix}${this.baseEncode(bytes)}`;
+    } else {
+      throw Error("Unknown type, must be binary type");
+    }
+  }
+};
+var Decoder = class {
+  /**
+   * @param {Base} name
+   * @param {Prefix} prefix
+   * @param {(text:string) => Uint8Array} baseDecode
+   */
+  constructor(name, prefix, baseDecode) {
+    this.name = name;
+    this.prefix = prefix;
+    if (prefix.codePointAt(0) === void 0) {
+      throw new Error("Invalid prefix character");
+    }
+    this.prefixCodePoint = /** @type {number} */
+    prefix.codePointAt(0);
+    this.baseDecode = baseDecode;
+  }
+  /**
+   * @param {string} text
+   */
+  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");
+    }
+  }
+  /**
+   * @template {string} OtherPrefix
+   * @param {API.UnibaseDecoder<OtherPrefix>|ComposedDecoder<OtherPrefix>} decoder
+   * @returns {ComposedDecoder<Prefix|OtherPrefix>}
+   */
+  or(decoder) {
+    return or(this, decoder);
+  }
+};
+var ComposedDecoder = class {
+  /**
+   * @param {Decoders<Prefix>} decoders
+   */
+  constructor(decoders) {
+    this.decoders = decoders;
+  }
+  /**
+   * @template {string} OtherPrefix
+   * @param {API.UnibaseDecoder<OtherPrefix>|ComposedDecoder<OtherPrefix>} decoder
+   * @returns {ComposedDecoder<Prefix|OtherPrefix>}
+   */
+  or(decoder) {
+    return or(this, decoder);
+  }
+  /**
+   * @param {string} input
+   * @returns {Uint8Array}
+   */
+  decode(input) {
+    const prefix = (
+      /** @type {Prefix} */
+      input[0]
+    );
+    const decoder = this.decoders[prefix];
+    if (decoder) {
+      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`);
+    }
+  }
+};
+var or = (left, right) => new ComposedDecoder(
+  /** @type {Decoders<L|R>} */
+  {
+    ...left.decoders || { [
+      /** @type API.UnibaseDecoder<L> */
+      left.prefix
+    ]: left },
+    ...right.decoders || { [
+      /** @type API.UnibaseDecoder<R> */
+      right.prefix
+    ]: right }
+  }
+);
+var Codec = class {
+  /**
+   * @param {Base} name
+   * @param {Prefix} prefix
+   * @param {(bytes:Uint8Array) => string} baseEncode
+   * @param {(text:string) => Uint8Array} baseDecode
+   */
+  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);
+  }
+  /**
+   * @param {Uint8Array} input
+   */
+  encode(input) {
+    return this.encoder.encode(input);
+  }
+  /**
+   * @param {string} input
+   */
+  decode(input) {
+    return this.decoder.decode(input);
+  }
+};
+var from = ({ name, prefix, encode: encode3, decode: decode5 }) => new Codec(name, prefix, encode3, decode5);
+var baseX = ({ prefix, name, alphabet }) => {
+  const { encode: encode3, decode: decode5 } = base_x_default(alphabet, name);
+  return from({
+    prefix,
+    name,
+    encode: encode3,
+    /**
+     * @param {string} text
+     */
+    decode: (text) => coerce(decode5(text))
+  });
+};
+var decode = (string, alphabet, bitsPerChar, name) => {
+  const codes = {};
+  for (let i = 0; i < alphabet.length; ++i) {
+    codes[alphabet[i]] = i;
+  }
+  let end = string.length;
+  while (string[end - 1] === "=") {
+    --end;
+  }
+  const out = new Uint8Array(end * bitsPerChar / 8 | 0);
+  let bits = 0;
+  let buffer = 0;
+  let written = 0;
+  for (let i = 0; i < end; ++i) {
+    const value = codes[string[i]];
+    if (value === void 0) {
+      throw new SyntaxError(`Non-${name} character`);
+    }
+    buffer = buffer << bitsPerChar | value;
+    bits += bitsPerChar;
+    if (bits >= 8) {
+      bits -= 8;
+      out[written++] = 255 & buffer >> bits;
+    }
+  }
+  if (bits >= bitsPerChar || 255 & buffer << 8 - bits) {
+    throw new SyntaxError("Unexpected end of data");
+  }
+  return out;
+};
+var encode = (data, alphabet, bitsPerChar) => {
+  const pad = alphabet[alphabet.length - 1] === "=";
+  const mask = (1 << bitsPerChar) - 1;
+  let out = "";
+  let bits = 0;
+  let buffer = 0;
+  for (let i = 0; i < data.length; ++i) {
+    buffer = buffer << 8 | data[i];
+    bits += 8;
+    while (bits > bitsPerChar) {
+      bits -= bitsPerChar;
+      out += alphabet[mask & buffer >> bits];
+    }
+  }
+  if (bits) {
+    out += alphabet[mask & buffer << bitsPerChar - bits];
+  }
+  if (pad) {
+    while (out.length * bitsPerChar & 7) {
+      out += "=";
+    }
+  }
+  return out;
+};
+var rfc4648 = ({ name, prefix, bitsPerChar, alphabet }) => {
+  return from({
+    prefix,
+    name,
+    encode(input) {
+      return encode(input, alphabet, bitsPerChar);
+    },
+    decode(input) {
+      return decode(input, alphabet, bitsPerChar, name);
+    }
+  });
+};
+
+// ../../../node_modules/.pnpm/multiformats@12.1.3/node_modules/multiformats/src/bases/base32.js
+var base32 = rfc4648({
+  prefix: "b",
+  name: "base32",
+  alphabet: "abcdefghijklmnopqrstuvwxyz234567",
+  bitsPerChar: 5
+});
+var base32upper = rfc4648({
+  prefix: "B",
+  name: "base32upper",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567",
+  bitsPerChar: 5
+});
+var base32pad = rfc4648({
+  prefix: "c",
+  name: "base32pad",
+  alphabet: "abcdefghijklmnopqrstuvwxyz234567=",
+  bitsPerChar: 5
+});
+var base32padupper = rfc4648({
+  prefix: "C",
+  name: "base32padupper",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=",
+  bitsPerChar: 5
+});
+var base32hex = rfc4648({
+  prefix: "v",
+  name: "base32hex",
+  alphabet: "0123456789abcdefghijklmnopqrstuv",
+  bitsPerChar: 5
+});
+var base32hexupper = rfc4648({
+  prefix: "V",
+  name: "base32hexupper",
+  alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV",
+  bitsPerChar: 5
+});
+var base32hexpad = rfc4648({
+  prefix: "t",
+  name: "base32hexpad",
+  alphabet: "0123456789abcdefghijklmnopqrstuv=",
+  bitsPerChar: 5
+});
+var base32hexpadupper = rfc4648({
+  prefix: "T",
+  name: "base32hexpadupper",
+  alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV=",
+  bitsPerChar: 5
+});
+var base32z = rfc4648({
+  prefix: "h",
+  name: "base32z",
+  alphabet: "ybndrfg8ejkmcpqxot1uwisza345h769",
+  bitsPerChar: 5
+});
+
+// ../../../node_modules/.pnpm/multiformats@12.1.3/node_modules/multiformats/src/bases/base58.js
+var base58_exports = {};
+__export(base58_exports, {
+  base58btc: () => base58btc,
+  base58flickr: () => base58flickr
+});
+var base58btc = baseX({
+  name: "base58btc",
+  prefix: "z",
+  alphabet: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+});
+var base58flickr = baseX({
+  name: "base58flickr",
+  prefix: "Z",
+  alphabet: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
+});
+
+// ../../../node_modules/.pnpm/multiformats@12.1.3/node_modules/multiformats/vendor/varint.js
+var encode_1 = encode2;
+var MSB = 128;
+var REST = 127;
+var MSBALL = ~REST;
+var INT = Math.pow(2, 31);
+function encode2(num, out, offset) {
+  out = out || [];
+  offset = offset || 0;
+  var oldOffset = offset;
+  while (num >= INT) {
+    out[offset++] = num & 255 | MSB;
+    num /= 128;
+  }
+  while (num & MSBALL) {
+    out[offset++] = num & 255 | MSB;
+    num >>>= 7;
+  }
+  out[offset] = num | 0;
+  encode2.bytes = offset - oldOffset + 1;
+  return out;
+}
+var decode2 = read;
+var MSB$1 = 128;
+var REST$1 = 127;
+function read(buf, offset) {
+  var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf.length;
+  do {
+    if (counter >= l) {
+      read.bytes = 0;
+      throw new RangeError("Could not decode varint");
+    }
+    b = buf[counter++];
+    res += shift < 28 ? (b & REST$1) << shift : (b & REST$1) * Math.pow(2, shift);
+    shift += 7;
+  } while (b >= MSB$1);
+  read.bytes = counter - offset;
+  return res;
+}
+var N1 = Math.pow(2, 7);
+var N2 = Math.pow(2, 14);
+var N3 = Math.pow(2, 21);
+var N4 = Math.pow(2, 28);
+var N5 = Math.pow(2, 35);
+var N6 = Math.pow(2, 42);
+var N7 = Math.pow(2, 49);
+var N8 = Math.pow(2, 56);
+var N9 = Math.pow(2, 63);
+var length = function(value) {
+  return value < N1 ? 1 : value < N2 ? 2 : value < N3 ? 3 : value < N4 ? 4 : value < N5 ? 5 : value < N6 ? 6 : value < N7 ? 7 : value < N8 ? 8 : value < N9 ? 9 : 10;
+};
+var varint = {
+  encode: encode_1,
+  decode: decode2,
+  encodingLength: length
+};
+var _brrp_varint = varint;
+var varint_default = _brrp_varint;
+
+// ../../../node_modules/.pnpm/multiformats@12.1.3/node_modules/multiformats/src/varint.js
+var decode3 = (data, offset = 0) => {
+  const code = varint_default.decode(data, offset);
+  return [code, varint_default.decode.bytes];
+};
+var encodeTo = (int, target, offset = 0) => {
+  varint_default.encode(int, target, offset);
+  return target;
+};
+var encodingLength = (int) => {
+  return varint_default.encodingLength(int);
+};
+
+// ../../../node_modules/.pnpm/multiformats@12.1.3/node_modules/multiformats/src/hashes/digest.js
+var create = (code, digest) => {
+  const size = digest.byteLength;
+  const sizeOffset = encodingLength(code);
+  const digestOffset = sizeOffset + encodingLength(size);
+  const bytes = new Uint8Array(digestOffset + size);
+  encodeTo(code, bytes, 0);
+  encodeTo(size, bytes, sizeOffset);
+  bytes.set(digest, digestOffset);
+  return new Digest(code, size, digest, bytes);
+};
+var decode4 = (multihash) => {
+  const bytes = coerce(multihash);
+  const [code, sizeOffset] = decode3(bytes);
+  const [size, digestOffset] = decode3(bytes.subarray(sizeOffset));
+  const digest = bytes.subarray(sizeOffset + digestOffset);
+  if (digest.byteLength !== size) {
+    throw new Error("Incorrect length");
+  }
+  return new Digest(code, size, digest, bytes);
+};
+var equals2 = (a, b) => {
+  if (a === b) {
+    return true;
+  } else {
+    const data = (
+      /** @type {{code?:unknown, size?:unknown, bytes?:unknown}} */
+      b
+    );
+    return a.code === data.code && a.size === data.size && data.bytes instanceof Uint8Array && equals(a.bytes, data.bytes);
+  }
+};
+var Digest = class {
+  /**
+   * Creates a multihash digest.
+   *
+   * @param {Code} code
+   * @param {Size} size
+   * @param {Uint8Array} digest
+   * @param {Uint8Array} bytes
+   */
+  constructor(code, size, digest, bytes) {
+    this.code = code;
+    this.size = size;
+    this.digest = digest;
+    this.bytes = bytes;
+  }
+};
+
+// ../../../node_modules/.pnpm/multiformats@12.1.3/node_modules/multiformats/src/cid.js
+var format = (link, base2) => {
+  const { bytes, version } = link;
+  switch (version) {
+    case 0:
+      return toStringV0(
+        bytes,
+        baseCache(link),
+        /** @type {API.MultibaseEncoder<"z">} */
+        base2 || base58btc.encoder
+      );
+    default:
+      return toStringV1(
+        bytes,
+        baseCache(link),
+        /** @type {API.MultibaseEncoder<Prefix>} */
+        base2 || base32.encoder
+      );
+  }
+};
+var cache = /* @__PURE__ */ new WeakMap();
+var baseCache = (cid) => {
+  const baseCache2 = cache.get(cid);
+  if (baseCache2 == null) {
+    const baseCache3 = /* @__PURE__ */ new Map();
+    cache.set(cid, baseCache3);
+    return baseCache3;
+  }
+  return baseCache2;
+};
+var CID = class _CID {
+  /**
+   * @param {Version} version - Version of the CID
+   * @param {Format} code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
+   * @param {API.MultihashDigest<Alg>} multihash - (Multi)hash of the of the content.
+   * @param {Uint8Array} bytes
+   */
+  constructor(version, code, multihash, bytes) {
+    this.code = code;
+    this.version = version;
+    this.multihash = multihash;
+    this.bytes = bytes;
+    this["/"] = bytes;
+  }
+  /**
+   * Signalling `cid.asCID === cid` has been replaced with `cid['/'] === cid.bytes`
+   * please either use `CID.asCID(cid)` or switch to new signalling mechanism
+   *
+   * @deprecated
+   */
+  get asCID() {
+    return this;
+  }
+  // ArrayBufferView
+  get byteOffset() {
+    return this.bytes.byteOffset;
+  }
+  // ArrayBufferView
+  get byteLength() {
+    return this.bytes.byteLength;
+  }
+  /**
+   * @returns {CID<Data, API.DAG_PB, API.SHA_256, 0>}
+   */
+  toV0() {
+    switch (this.version) {
+      case 0: {
+        return (
+          /** @type {CID<Data, API.DAG_PB, API.SHA_256, 0>} */
+          this
+        );
+      }
+      case 1: {
+        const { code, multihash } = this;
+        if (code !== DAG_PB_CODE) {
+          throw new Error("Cannot convert a non dag-pb CID to CIDv0");
+        }
+        if (multihash.code !== SHA_256_CODE) {
+          throw new Error("Cannot convert non sha2-256 multihash CID to CIDv0");
+        }
+        return (
+          /** @type {CID<Data, API.DAG_PB, API.SHA_256, 0>} */
+          _CID.createV0(
+            /** @type {API.MultihashDigest<API.SHA_256>} */
+            multihash
+          )
+        );
+      }
+      default: {
+        throw Error(
+          `Can not convert CID version ${this.version} to version 0. This is a bug please report`
+        );
+      }
+    }
+  }
+  /**
+   * @returns {CID<Data, Format, Alg, 1>}
+   */
+  toV1() {
+    switch (this.version) {
+      case 0: {
+        const { code, digest } = this.multihash;
+        const multihash = create(code, digest);
+        return (
+          /** @type {CID<Data, Format, Alg, 1>} */
+          _CID.createV1(this.code, multihash)
+        );
+      }
+      case 1: {
+        return (
+          /** @type {CID<Data, Format, Alg, 1>} */
+          this
+        );
+      }
+      default: {
+        throw Error(
+          `Can not convert CID version ${this.version} to version 1. This is a bug please report`
+        );
+      }
+    }
+  }
+  /**
+   * @param {unknown} other
+   * @returns {other is CID<Data, Format, Alg, Version>}
+   */
+  equals(other) {
+    return _CID.equals(this, other);
+  }
+  /**
+   * @template {unknown} Data
+   * @template {number} Format
+   * @template {number} Alg
+   * @template {API.Version} Version
+   * @param {API.Link<Data, Format, Alg, Version>} self
+   * @param {unknown} other
+   * @returns {other is CID}
+   */
+  static equals(self2, other) {
+    const unknown = (
+      /** @type {{code?:unknown, version?:unknown, multihash?:unknown}} */
+      other
+    );
+    return unknown && self2.code === unknown.code && self2.version === unknown.version && equals2(self2.multihash, unknown.multihash);
+  }
+  /**
+   * @param {API.MultibaseEncoder<string>} [base]
+   * @returns {string}
+   */
+  toString(base2) {
+    return format(this, base2);
+  }
+  /**
+   * @returns {API.LinkJSON<this>}
+   */
+  toJSON() {
+    return { "/": format(this) };
+  }
+  link() {
+    return this;
+  }
+  get [Symbol.toStringTag]() {
+    return "CID";
+  }
+  // Legacy
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return `CID(${this.toString()})`;
+  }
+  /**
+   * Takes any input `value` and returns a `CID` instance if it was
+   * a `CID` otherwise returns `null`. If `value` is instanceof `CID`
+   * it will return value back. If `value` is not instance of this CID
+   * class, but is compatible CID it will return new instance of this
+   * `CID` class. Otherwise returns null.
+   *
+   * This allows two different incompatible versions of CID library to
+   * co-exist and interop as long as binary interface is compatible.
+   *
+   * @template {unknown} Data
+   * @template {number} Format
+   * @template {number} Alg
+   * @template {API.Version} Version
+   * @template {unknown} U
+   * @param {API.Link<Data, Format, Alg, Version>|U} input
+   * @returns {CID<Data, Format, Alg, Version>|null}
+   */
+  static asCID(input) {
+    if (input == null) {
+      return null;
+    }
+    const value = (
+      /** @type {any} */
+      input
+    );
+    if (value instanceof _CID) {
+      return value;
+    } else if (value["/"] != null && value["/"] === value.bytes || value.asCID === value) {
+      const { version, code, multihash, bytes } = value;
+      return new _CID(
+        version,
+        code,
+        /** @type {API.MultihashDigest<Alg>} */
+        multihash,
+        bytes || encodeCID(version, code, multihash.bytes)
+      );
+    } else if (value[cidSymbol] === true) {
+      const { version, multihash, code } = value;
+      const digest = (
+        /** @type {API.MultihashDigest<Alg>} */
+        decode4(multihash)
+      );
+      return _CID.create(version, code, digest);
+    } else {
+      return null;
+    }
+  }
+  /**
+   *
+   * @template {unknown} Data
+   * @template {number} Format
+   * @template {number} Alg
+   * @template {API.Version} Version
+   * @param {Version} version - Version of the CID
+   * @param {Format} code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
+   * @param {API.MultihashDigest<Alg>} digest - (Multi)hash of the of the content.
+   * @returns {CID<Data, Format, Alg, Version>}
+   */
+  static create(version, code, digest) {
+    if (typeof code !== "number") {
+      throw new Error("String codecs are no longer supported");
+    }
+    if (!(digest.bytes instanceof Uint8Array)) {
+      throw new Error("Invalid digest");
+    }
+    switch (version) {
+      case 0: {
+        if (code !== DAG_PB_CODE) {
+          throw new Error(
+            `Version 0 CID must use dag-pb (code: ${DAG_PB_CODE}) block encoding`
+          );
+        } else {
+          return new _CID(version, code, digest, digest.bytes);
+        }
+      }
+      case 1: {
+        const bytes = encodeCID(version, code, digest.bytes);
+        return new _CID(version, code, digest, bytes);
+      }
+      default: {
+        throw new Error("Invalid version");
+      }
+    }
+  }
+  /**
+   * Simplified version of `create` for CIDv0.
+   *
+   * @template {unknown} [T=unknown]
+   * @param {API.MultihashDigest<typeof SHA_256_CODE>} digest - Multihash.
+   * @returns {CID<T, typeof DAG_PB_CODE, typeof SHA_256_CODE, 0>}
+   */
+  static createV0(digest) {
+    return _CID.create(0, DAG_PB_CODE, digest);
+  }
+  /**
+   * Simplified version of `create` for CIDv1.
+   *
+   * @template {unknown} Data
+   * @template {number} Code
+   * @template {number} Alg
+   * @param {Code} code - Content encoding format code.
+   * @param {API.MultihashDigest<Alg>} digest - Miltihash of the content.
+   * @returns {CID<Data, Code, Alg, 1>}
+   */
+  static createV1(code, digest) {
+    return _CID.create(1, code, digest);
+  }
+  /**
+   * Decoded a CID from its binary representation. The byte array must contain
+   * only the CID with no additional bytes.
+   *
+   * An error will be thrown if the bytes provided do not contain a valid
+   * binary representation of a CID.
+   *
+   * @template {unknown} Data
+   * @template {number} Code
+   * @template {number} Alg
+   * @template {API.Version} Ver
+   * @param {API.ByteView<API.Link<Data, Code, Alg, Ver>>} bytes
+   * @returns {CID<Data, Code, Alg, Ver>}
+   */
+  static decode(bytes) {
+    const [cid, remainder] = _CID.decodeFirst(bytes);
+    if (remainder.length) {
+      throw new Error("Incorrect length");
+    }
+    return cid;
+  }
+  /**
+   * Decoded a CID from its binary representation at the beginning of a byte
+   * array.
+   *
+   * Returns an array with the first element containing the CID and the second
+   * element containing the remainder of the original byte array. The remainder
+   * will be a zero-length byte array if the provided bytes only contained a
+   * binary CID representation.
+   *
+   * @template {unknown} T
+   * @template {number} C
+   * @template {number} A
+   * @template {API.Version} V
+   * @param {API.ByteView<API.Link<T, C, A, V>>} bytes
+   * @returns {[CID<T, C, A, V>, Uint8Array]}
+   */
+  static decodeFirst(bytes) {
+    const specs = _CID.inspectBytes(bytes);
+    const prefixSize = specs.size - specs.multihashSize;
+    const multihashBytes = coerce(
+      bytes.subarray(prefixSize, prefixSize + specs.multihashSize)
+    );
+    if (multihashBytes.byteLength !== specs.multihashSize) {
+      throw new Error("Incorrect length");
+    }
+    const digestBytes = multihashBytes.subarray(
+      specs.multihashSize - specs.digestSize
+    );
+    const digest = new Digest(
+      specs.multihashCode,
+      specs.digestSize,
+      digestBytes,
+      multihashBytes
+    );
+    const cid = specs.version === 0 ? _CID.createV0(
+      /** @type {API.MultihashDigest<API.SHA_256>} */
+      digest
+    ) : _CID.createV1(specs.codec, digest);
+    return [
+      /** @type {CID<T, C, A, V>} */
+      cid,
+      bytes.subarray(specs.size)
+    ];
+  }
+  /**
+   * Inspect the initial bytes of a CID to determine its properties.
+   *
+   * Involves decoding up to 4 varints. Typically this will require only 4 to 6
+   * bytes but for larger multicodec code values and larger multihash digest
+   * lengths these varints can be quite large. It is recommended that at least
+   * 10 bytes be made available in the `initialBytes` argument for a complete
+   * inspection.
+   *
+   * @template {unknown} T
+   * @template {number} C
+   * @template {number} A
+   * @template {API.Version} V
+   * @param {API.ByteView<API.Link<T, C, A, V>>} initialBytes
+   * @returns {{ version:V, codec:C, multihashCode:A, digestSize:number, multihashSize:number, size:number }}
+   */
+  static inspectBytes(initialBytes) {
+    let offset = 0;
+    const next = () => {
+      const [i, length2] = decode3(initialBytes.subarray(offset));
+      offset += length2;
+      return i;
+    };
+    let version = (
+      /** @type {V} */
+      next()
+    );
+    let codec = (
+      /** @type {C} */
+      DAG_PB_CODE
+    );
+    if (
+      /** @type {number} */
+      version === 18
+    ) {
+      version = /** @type {V} */
+      0;
+      offset = 0;
+    } else {
+      codec = /** @type {C} */
+      next();
+    }
+    if (version !== 0 && version !== 1) {
+      throw new RangeError(`Invalid CID version ${version}`);
+    }
+    const prefixSize = offset;
+    const multihashCode = (
+      /** @type {A} */
+      next()
+    );
+    const digestSize = next();
+    const size = offset + digestSize;
+    const multihashSize = size - prefixSize;
+    return { version, codec, multihashCode, digestSize, multihashSize, size };
+  }
+  /**
+   * Takes cid in a string representation and creates an instance. If `base`
+   * decoder is not provided will use a default from the configuration. It will
+   * throw an error if encoding of the CID is not compatible with supplied (or
+   * a default decoder).
+   *
+   * @template {string} Prefix
+   * @template {unknown} Data
+   * @template {number} Code
+   * @template {number} Alg
+   * @template {API.Version} Ver
+   * @param {API.ToString<API.Link<Data, Code, Alg, Ver>, Prefix>} source
+   * @param {API.MultibaseDecoder<Prefix>} [base]
+   * @returns {CID<Data, Code, Alg, Ver>}
+   */
+  static parse(source, base2) {
+    const [prefix, bytes] = parseCIDtoBytes(source, base2);
+    const cid = _CID.decode(bytes);
+    if (cid.version === 0 && source[0] !== "Q") {
+      throw Error("Version 0 CID string must not include multibase prefix");
+    }
+    baseCache(cid).set(prefix, source);
+    return cid;
+  }
+};
+var parseCIDtoBytes = (source, base2) => {
+  switch (source[0]) {
+    case "Q": {
+      const decoder = base2 || base58btc;
+      return [
+        /** @type {Prefix} */
+        base58btc.prefix,
+        decoder.decode(`${base58btc.prefix}${source}`)
+      ];
+    }
+    case base58btc.prefix: {
+      const decoder = base2 || base58btc;
+      return [
+        /** @type {Prefix} */
+        base58btc.prefix,
+        decoder.decode(source)
+      ];
+    }
+    case base32.prefix: {
+      const decoder = base2 || base32;
+      return [
+        /** @type {Prefix} */
+        base32.prefix,
+        decoder.decode(source)
+      ];
+    }
+    default: {
+      if (base2 == null) {
+        throw Error(
+          "To parse non base32 or base58btc encoded CID multibase decoder must be provided"
+        );
+      }
+      return [
+        /** @type {Prefix} */
+        source[0],
+        base2.decode(source)
+      ];
+    }
+  }
+};
+var toStringV0 = (bytes, cache2, base2) => {
+  const { prefix } = base2;
+  if (prefix !== base58btc.prefix) {
+    throw Error(`Cannot string encode V0 in ${base2.name} encoding`);
+  }
+  const cid = cache2.get(prefix);
+  if (cid == null) {
+    const cid2 = base2.encode(bytes).slice(1);
+    cache2.set(prefix, cid2);
+    return cid2;
+  } else {
+    return cid;
+  }
+};
+var toStringV1 = (bytes, cache2, base2) => {
+  const { prefix } = base2;
+  const cid = cache2.get(prefix);
+  if (cid == null) {
+    const cid2 = base2.encode(bytes);
+    cache2.set(prefix, cid2);
+    return cid2;
+  } else {
+    return cid;
+  }
+};
+var DAG_PB_CODE = 112;
+var SHA_256_CODE = 18;
+var encodeCID = (version, code, multihash) => {
+  const codeOffset = encodingLength(version);
+  const hashOffset = codeOffset + encodingLength(code);
+  const bytes = new Uint8Array(hashOffset + multihash.byteLength);
+  encodeTo(version, bytes, 0);
+  encodeTo(code, bytes, codeOffset);
+  bytes.set(multihash, hashOffset);
+  return bytes;
+};
+var cidSymbol = Symbol.for("@ipld/js-cid/CID");
+
+// ../../../node_modules/.pnpm/besonders-logger@1.0.0-RC11_3myifxmc6j23mthq5k5h6wvx4a/node_modules/besonders-logger/dist/src/index.mjs
+var __create2 = Object.create;
+var __defProp2 = Object.defineProperty;
+var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames2 = Object.getOwnPropertyNames;
+var __getProtoOf2 = Object.getPrototypeOf;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __commonJS2 = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps2 = (to, from2, except, desc) => {
+  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+    for (let key of __getOwnPropNames2(from2))
+      if (!__hasOwnProp2.call(to, key) && key !== except)
+        __defProp2(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc2(from2, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __publicField2 = (obj, key, value) => {
+  __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var require_lib = __commonJS2({
+  "../../node_modules/.pnpm/browser-or-node@2.1.1/node_modules/browser-or-node/lib/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) {
+      return typeof obj;
+    } : function(obj) {
+      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+    };
+    var isBrowser2 = typeof window !== "undefined" && typeof window.document !== "undefined";
+    var isNode2 = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+    var isWebWorker = (typeof self === "undefined" ? "undefined" : _typeof(self)) === "object" && self.constructor && self.constructor.name === "DedicatedWorkerGlobalScope";
+    var isJsDom = typeof window !== "undefined" && window.name === "nodejs" || typeof navigator !== "undefined" && (navigator.userAgent.includes("Node.js") || navigator.userAgent.includes("jsdom"));
+    var isDeno = typeof Deno !== "undefined" && typeof Deno.version !== "undefined" && typeof Deno.version.deno !== "undefined";
+    exports.isBrowser = isBrowser2;
+    exports.isWebWorker = isWebWorker;
+    exports.isNode = isNode2;
+    exports.isJsDom = isJsDom;
+    exports.isDeno = isDeno;
+  }
+});
+var require_fast_json_stable_stringify = __commonJS2({
+  "../../node_modules/.pnpm/fast-json-stable-stringify@2.1.0/node_modules/fast-json-stable-stringify/index.js"(exports, module) {
+    "use strict";
+    module.exports = function(data, opts) {
+      if (!opts)
+        opts = {};
+      if (typeof opts === "function")
+        opts = { cmp: opts };
+      var cycles = typeof opts.cycles === "boolean" ? opts.cycles : false;
+      var cmp = opts.cmp && /* @__PURE__ */ function(f) {
+        return function(node) {
+          return function(a, b) {
+            var aobj = { key: a, value: node[a] };
+            var bobj = { key: b, value: node[b] };
+            return f(aobj, bobj);
+          };
+        };
+      }(opts.cmp);
+      var seen = [];
+      return function stringify2(node) {
+        if (node && node.toJSON && typeof node.toJSON === "function") {
+          node = node.toJSON();
+        }
+        if (node === void 0)
+          return;
+        if (typeof node == "number")
+          return isFinite(node) ? "" + node : "null";
+        if (typeof node !== "object")
+          return JSON.stringify(node);
+        var i, out;
+        if (Array.isArray(node)) {
+          out = "[";
+          for (i = 0; i < node.length; i++) {
+            if (i)
+              out += ",";
+            out += stringify2(node[i]) || "null";
+          }
+          return out + "]";
+        }
+        if (node === null)
+          return "null";
+        if (seen.indexOf(node) !== -1) {
+          if (cycles)
+            return JSON.stringify("__cycle__");
+          throw new TypeError("Converting circular structure to JSON");
+        }
+        var seenIndex = seen.push(node) - 1;
+        var keys = Object.keys(node).sort(cmp && cmp(node));
+        out = "";
+        for (i = 0; i < keys.length; i++) {
+          var key = keys[i];
+          var value = stringify2(node[key]);
+          if (!value)
+            continue;
+          if (out)
+            out += ",";
+          out += JSON.stringify(key) + ":" + value;
+        }
+        seen.splice(seenIndex, 1);
+        return "{" + out + "}";
+      }(data);
+    };
+  }
+});
+var import_browser_or_node = __toESM2(require_lib(), 1);
+var import_fast_json_stable_stringify = __toESM2(require_fast_json_stable_stringify(), 1);
+var TIME_PREFIX_ENABLED = false;
+var PERFORMANCE_PREFIX_ENABLED = false;
+if (import_browser_or_node.isNode) {
+  if (process?.env?.LOGGER_TIME_PREFIX)
+    TIME_PREFIX_ENABLED = process?.env?.LOGGER_TIME_PREFIX === "true";
+  if (process?.env?.LOGGER_PERF_PREFIX)
+    PERFORMANCE_PREFIX_ENABLED = process?.env?.LOGGER_PERF_PREFIX === "true";
+}
+var DEFAULT_CONFIG = Object.freeze({
+  prefix: void 0,
+  time: TIME_PREFIX_ENABLED,
+  delta: PERFORMANCE_PREFIX_ENABLED,
+  dimDebugOnServer: true,
+  printOriginOnServer: true,
+  serverInspectOptions: {},
+  customFormattersOnServer: true,
+  // Depth of stacktrace to show on server
+  // - integer saying how many lines
+  // - false to disable, true for all
+  printStackLinesOnServer: false,
+  dim: true
+});
+var StringFormatters = [
+  // Format to string (Client console - currently not on server)
+  // {
+  //   match: obj => obj instanceof Model,
+  //   format: m => {
+  //     const { displayName } = m
+  //     return `${m.constructor.name}#${m.ID}${displayName ? `{${displayName}}` : ''}`
+  //   },
+  // },
+];
+var LoggerTime = class {
+  constructor(sinceFirst, sinceLast, time, delta) {
+    __publicField(this, "sinceFirst", 0);
+    __publicField(this, "sinceLast", 0);
+    __publicField(this, "time", false);
+    __publicField(this, "delta", false);
+    Object.assign(this, { sinceFirst, sinceLast, time, delta });
+  }
+  toString() {
+    const sinceFirstNum = this.sinceFirst * 1e-3;
+    const sinceFirst = sinceFirstNum.toFixed(sinceFirstNum < 5 ? 2 : 1);
+    const sinceLast = this.sinceLast < 1e3 ? `${this.sinceLast.toFixed(0)}`.padStart(5, " ") : `${`${(this.sinceLast * 1e-3).toFixed(this.sinceLast < 1e4 ? 1 : 0)}`.padStart(4, " ")}s`;
+    return `[${[this.time ? sinceFirst : null, this.delta ? sinceLast : null].join(",")}]`;
+  }
+};
+var Style = class {
+  constructor(style, string) {
+    Object.assign(this, { style, string });
+  }
+};
+var formattersEnabled = false;
+var _Logger = class {
+  /**
+   * This is a clever way to log without the extra check on each log line.
+   * Use it like this:
+   * ```
+   * const { WARN, LOG, DEBUG, VERBOSE } = Logger.setup(Logger.INFO); // eslint-disable-line no-unused-vars
+   * LOG('message', data);
+   * DEBUG(this.collectionName, '...')
+   * if (!VERBOSE.isDisabled) {
+   *   const verboseStuff = generateVerboseStuff(); // computationally intensive
+   *   VERBOSE('Here it is:', verboseStuff)
+   * }
+   * ```
+   *
+   * @ param {number} level See {@link LVs}
+   * @ param {object} config see DEFAULT_CONFIG
+   * @ typedef {Function & {isDisabled: boolean, isEnabled: boolean, ...}} LogFunc
+   * @ returns {{LOG: LogFunc, VERBOSE: LogFunc, DEBUG: LogFunc, WARN: LogFunc, ERROR: LogFunc}}
+   */
+  static setup(level = _Logger.INFO, config = {}) {
+    config = Object.assign({}, DEFAULT_CONFIG, config);
+    if (level > 10)
+      console.debug("setup logger", { config });
+    const debugLogForStub = this.wrapLog(console.debug, { ...config, dim: config.dimDebugOnServer });
+    const stub = (...args) => {
+      if (window?.FORCE_DISABLE_LOGLEVEL)
+        debugLogForStub(...args);
+    };
+    stub.isDisabled = true;
+    stub.isEnabled = false;
+    const groupCollapsed = this.wrapLog(console.groupCollapsed, config);
+    const addExtraFxs = (enabled, func) => {
+      function group(...args) {
+        const functionToWrap = args[args.length - 1];
+        if (functionToWrap === stub)
+          return functionToWrap();
+        groupCollapsed(...args.slice(0, -1));
+        const asyncWrapper = async () => {
+          try {
+            const result = functionToWrap();
+            return result instanceof Promise ? await result : result;
+          } finally {
+            console.groupEnd();
+          }
+        };
+        return asyncWrapper();
+      }
+      const realFunc = Object.assign(
+        func.bind({}),
+        // clone function - https://stackoverflow.com/a/6772648
+        {
+          isEnabled: enabled,
+          isDisabled: !enabled,
+          group,
+          force: func
+        }
+      );
+      if (enabled) {
+        return realFunc;
+      } else {
+        return Object.assign(
+          stub.bind({}),
+          // clone stub function - https://stackoverflow.com/a/6772648
+          {
+            isEnabled: enabled,
+            isDisabled: !enabled,
+            group,
+            force: realFunc
+          }
+        );
+      }
+    };
+    const ERRFX = addExtraFxs(level >= _Logger.ERROR, this.wrapLog(console.error, config));
+    const ERROR = (...params) => {
+      ERRFX(...params);
+      return new Error((0, import_fast_json_stable_stringify.default)(params));
+    };
+    return {
+      ERROR,
+      WARN: addExtraFxs(level >= _Logger.WARN, this.wrapLog(console.warn, config)),
+      LOG: addExtraFxs(level >= _Logger.INFO, this.wrapLog(console.log, config)),
+      DEBUG: addExtraFxs(level >= _Logger.DEBUG, this.wrapLog(console.log, { ...config, dim: config.dimDebugOnServer })),
+      // not using console.debug as that requires dev tools verbose to be enabled
+      VERBOSE: addExtraFxs(level >= _Logger.VERBOSE, this.wrapLog(console.debug, { ...config, dim: config.dimDebugOnServer }))
+    };
+  }
+  static wrapLog(logFunc, config) {
+    if (!import_browser_or_node.isNode) {
+      const fixedArgs = [];
+      if (config.time || config.delta) {
+        const isChrome = import_browser_or_node.isBrowser && navigator.userAgent.includes("Chrome");
+        const p = isChrome ? ["", _Logger.timeStr(!!config.time, !!config.delta)] : [];
+        fixedArgs.push(...p);
+      }
+      if (config.prefix) {
+        if (formattersEnabled)
+          fixedArgs.push(new Style("dim", config.prefix));
+        else
+          fixedArgs.push(config.prefix);
+      }
+      return logFunc.bind(console, ...fixedArgs);
+    } else {
+      return logFunc.bind(console);
+    }
+  }
+  // static log(msg, logPerformance = true) {
+  //   const p = this.perf();
+  //   return logPerformance ? `${p} ${msg}` : msg;
+  // }
+  static timeStr(time, delta, returnAsString = 0) {
+    if (!performance.now)
+      return void 0;
+    const now = performance.now();
+    if (!_Logger.firstLog) {
+      _Logger.firstLog = now;
+      _Logger.lastLog = now;
+    }
+    const p = new LoggerTime(now - _Logger.firstLog, now - _Logger.lastLog, time, delta);
+    _Logger.lastLog = now;
+    return returnAsString ? p.toString() : p;
+  }
+  // (for nodejs) ~ https://stackoverflow.com/a/47296370/1633985
+  static getOriginFromStack(stack) {
+    let skippedFirst = false;
+    for (const line of stack.split("\n")) {
+      const matches = line.match(/^\s+at\s+(.*)/);
+      if (matches) {
+        if (skippedFirst) {
+          return matches[1].trim().replace(__dirname, "");
+        }
+        skippedFirst = true;
+      }
+    }
+  }
+};
+var Logger = _Logger;
+__publicField2(Logger, "ERROR", 2);
+__publicField2(Logger, "WARN", 4);
+__publicField2(Logger, "INFO", 6);
+__publicField2(Logger, "LOG", 6);
+__publicField2(Logger, "DEBUG", 8);
+__publicField2(Logger, "VERBOSE", 10);
+__publicField2(Logger, "firstLog", 0);
+__publicField2(Logger, "lastLog", 0);
+if (import_browser_or_node.isBrowser) {
+  window.devtoolsFormatters = window.devtoolsFormatters ?? [];
+  window.devtoolsFormatters.push(
+    {
+      // Custom formatters
+      header: (obj) => {
+        if (StringFormatters && StringFormatters.length) {
+          for (const formatter of StringFormatters) {
+            if (formatter.match(obj))
+              return ["span", {}, formatter.format(obj)];
+          }
+        }
+        return null;
+      },
+      hasBody: () => true
+    },
+    {
+      // Performance object //
+      // This is a sneaky way to show performance info withouth any extra calls when logging:
+      // LOG(`...`)
+      // it would work without this if we would have some way to intercept the call:
+      // L.INFO('...') - a getter on L that adds the current time as prefix
+      // LOG('...')() - returns the log function with all argumends bound
+      // But instead we are adding a custom formatter that replaced the placeholder object of class P with the performance info
+      header: (obj) => {
+        if (!(obj instanceof LoggerTime))
+          return null;
+        if (!formattersEnabled)
+          formattersEnabled = true;
+        const p = Logger.timeStr(obj.time, obj.delta);
+        return [
+          "span",
+          { style: "font-weight: light; color: grey" },
+          p?.toString()
+          // ['a', { href: 'vscodium://file/home/manu/dev/tamera/bookr/imports/lib/utils/Logger.js' }, 'WOW'],
+        ];
+      },
+      hasBody: () => false
+    },
+    {
+      // Style object
+      header: (obj) => {
+        if (!(obj instanceof Style))
+          return null;
+        if (!formattersEnabled)
+          formattersEnabled = true;
+        return ["span", {
+          style: "font-weight: light; color: grey; "
+          /* font-style: italic; */
+        }, obj.string];
+      },
+      hasBody: () => false
+    }
+  );
+} else if (import_browser_or_node.isNode) {
+}
+
+export {
+  __require,
+  __commonJS,
+  __export,
+  __toESM,
+  coerce,
+  fromString,
+  toString,
+  from,
+  baseX,
+  rfc4648,
+  base32_exports,
+  base58_exports,
+  create,
+  decode4 as decode,
+  CID,
+  Logger
+};
+//# sourceMappingURL=chunk-R6GDUZUI.js.map