@multiversx/sdk-dapp-liquidity 1.0.12 → 1.0.14

package/bitcoin-DAvQGpeP.js

@@ -0,0 +1,3251 @@
+#!/usr/bin/env node
+"use strict";
+var _a;
+const require$$0$1 = require("react");
+var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+function getDefaultExportFromCjs(x2) {
+  return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
+}
+function getAugmentedNamespace(n3) {
+  if (n3.__esModule) return n3;
+  var f2 = n3.default;
+  if (typeof f2 == "function") {
+    var a2 = function a3() {
+      if (this instanceof a3) {
+        return Reflect.construct(f2, arguments, this.constructor);
+      }
+      return f2.apply(this, arguments);
+    };
+    a2.prototype = f2.prototype;
+  } else a2 = {};
+  Object.defineProperty(a2, "__esModule", { value: true });
+  Object.keys(n3).forEach(function(k2) {
+    var d2 = Object.getOwnPropertyDescriptor(n3, k2);
+    Object.defineProperty(a2, k2, d2.get ? d2 : {
+      enumerable: true,
+      get: function() {
+        return n3[k2];
+      }
+    });
+  });
+  return a2;
+}
+const e$3 = Symbol(), t$2 = Symbol(), r$3 = "a", n$3 = "w";
+let o$4 = (e2, t2) => new Proxy(e2, t2);
+const s$3 = Object.getPrototypeOf, c$3 = /* @__PURE__ */ new WeakMap(), l$2 = (e2) => e2 && (c$3.has(e2) ? c$3.get(e2) : s$3(e2) === Object.prototype || s$3(e2) === Array.prototype), f$2 = (e2) => "object" == typeof e2 && null !== e2, i$4 = (e2) => {
+  if (Array.isArray(e2)) return Array.from(e2);
+  const t2 = Object.getOwnPropertyDescriptors(e2);
+  return Object.values(t2).forEach((e3) => {
+    e3.configurable = true;
+  }), Object.create(s$3(e2), t2);
+}, u$2 = (e2) => e2[t$2] || e2, a$2 = (s2, c2, f2, p2) => {
+  if (!l$2(s2)) return s2;
+  let g2 = p2 && p2.get(s2);
+  if (!g2) {
+    const e2 = u$2(s2);
+    g2 = ((e3) => Object.values(Object.getOwnPropertyDescriptors(e3)).some((e4) => !e4.configurable && !e4.writable))(e2) ? [e2, i$4(e2)] : [e2], null == p2 || p2.set(s2, g2);
+  }
+  const [y3, h2] = g2;
+  let w2 = f2 && f2.get(y3);
+  return w2 && w2[1].f === !!h2 || (w2 = ((o2, s3) => {
+    const c3 = { f: s3 };
+    let l2 = false;
+    const f3 = (e2, t2) => {
+      if (!l2) {
+        let s4 = c3[r$3].get(o2);
+        if (s4 || (s4 = {}, c3[r$3].set(o2, s4)), e2 === n$3) s4[n$3] = true;
+        else {
+          let r2 = s4[e2];
+          r2 || (r2 = /* @__PURE__ */ new Set(), s4[e2] = r2), r2.add(t2);
+        }
+      }
+    }, i2 = { get: (e2, n3) => n3 === t$2 ? o2 : (f3("k", n3), a$2(Reflect.get(e2, n3), c3[r$3], c3.c, c3.t)), has: (t2, n3) => n3 === e$3 ? (l2 = true, c3[r$3].delete(o2), true) : (f3("h", n3), Reflect.has(t2, n3)), getOwnPropertyDescriptor: (e2, t2) => (f3("o", t2), Reflect.getOwnPropertyDescriptor(e2, t2)), ownKeys: (e2) => (f3(n$3), Reflect.ownKeys(e2)) };
+    return s3 && (i2.set = i2.deleteProperty = () => false), [i2, c3];
+  })(y3, !!h2), w2[1].p = o$4(h2 || y3, w2[0]), f2 && f2.set(y3, w2)), w2[1][r$3] = c2, w2[1].c = f2, w2[1].t = p2, w2[1].p;
+}, p$2 = (e2, t2, r2, o2, s2 = Object.is) => {
+  if (s2(e2, t2)) return false;
+  if (!f$2(e2) || !f$2(t2)) return true;
+  const c2 = r2.get(u$2(e2));
+  if (!c2) return true;
+  if (o2) {
+    const r3 = o2.get(e2);
+    if (r3 && r3.n === t2) return r3.g;
+    o2.set(e2, { n: t2, g: false });
+  }
+  let l2 = null;
+  try {
+    for (const r3 of c2.h || []) if (l2 = Reflect.has(e2, r3) !== Reflect.has(t2, r3), l2) return l2;
+    if (true === c2[n$3]) {
+      if (l2 = ((e3, t3) => {
+        const r3 = Reflect.ownKeys(e3), n3 = Reflect.ownKeys(t3);
+        return r3.length !== n3.length || r3.some((e4, t4) => e4 !== n3[t4]);
+      })(e2, t2), l2) return l2;
+    } else for (const r3 of c2.o || []) if (l2 = !!Reflect.getOwnPropertyDescriptor(e2, r3) != !!Reflect.getOwnPropertyDescriptor(t2, r3), l2) return l2;
+    for (const n3 of c2.k || []) if (l2 = p$2(e2[n3], t2[n3], r2, o2, s2), l2) return l2;
+    return null === l2 && (l2 = true), l2;
+  } finally {
+    o2 && o2.set(e2, { n: t2, g: l2 });
+  }
+}, y$2 = (e2) => l$2(e2) && e2[t$2] || null, h$2 = (e2, t2 = true) => {
+  c$3.set(e2, t2);
+}, w = (e2, t2, r2) => {
+  const o2 = [], s2 = /* @__PURE__ */ new WeakSet(), c2 = (e3, l2) => {
+    if (s2.has(e3)) return;
+    f$2(e3) && s2.add(e3);
+    const i2 = f$2(e3) && t2.get(u$2(e3));
+    if (i2) {
+      var a2, p2;
+      if (null == (a2 = i2.h) || a2.forEach((e4) => {
+        const t3 = `:has(${String(e4)})`;
+        o2.push(l2 ? [...l2, t3] : [t3]);
+      }), true === i2[n$3]) {
+        const e4 = ":ownKeys";
+        o2.push(l2 ? [...l2, e4] : [e4]);
+      } else {
+        var g2;
+        null == (g2 = i2.o) || g2.forEach((e4) => {
+          const t3 = `:hasOwn(${String(e4)})`;
+          o2.push(l2 ? [...l2, t3] : [t3]);
+        });
+      }
+      null == (p2 = i2.k) || p2.forEach((t3) => {
+        !("value" in (Object.getOwnPropertyDescriptor(e3, t3) || {})) || c2(e3[t3], l2 ? [...l2, t3] : [t3]);
+      });
+    } else l2 && o2.push(l2);
+  };
+  return c2(e2), o2;
+};
+const __vite_import_meta_env__$1 = {};
+const isObject = (x2) => typeof x2 === "object" && x2 !== null;
+const proxyStateMap = /* @__PURE__ */ new WeakMap();
+const refSet = /* @__PURE__ */ new WeakSet();
+const buildProxyFunction = (objectIs = Object.is, newProxy = (target, handler) => new Proxy(target, handler), canProxy = (x2) => isObject(x2) && !refSet.has(x2) && (Array.isArray(x2) || !(Symbol.iterator in x2)) && !(x2 instanceof WeakMap) && !(x2 instanceof WeakSet) && !(x2 instanceof Error) && !(x2 instanceof Number) && !(x2 instanceof Date) && !(x2 instanceof String) && !(x2 instanceof RegExp) && !(x2 instanceof ArrayBuffer), defaultHandlePromise = (promise) => {
+  switch (promise.status) {
+    case "fulfilled":
+      return promise.value;
+    case "rejected":
+      throw promise.reason;
+    default:
+      throw promise;
+  }
+}, snapCache = /* @__PURE__ */ new WeakMap(), createSnapshot = (target, version, handlePromise = defaultHandlePromise) => {
+  const cache = snapCache.get(target);
+  if ((cache == null ? void 0 : cache[0]) === version) {
+    return cache[1];
+  }
+  const snap = Array.isArray(target) ? [] : Object.create(Object.getPrototypeOf(target));
+  h$2(snap, true);
+  snapCache.set(target, [version, snap]);
+  Reflect.ownKeys(target).forEach((key) => {
+    if (Object.getOwnPropertyDescriptor(snap, key)) {
+      return;
+    }
+    const value = Reflect.get(target, key);
+    const { enumerable } = Reflect.getOwnPropertyDescriptor(
+      target,
+      key
+    );
+    const desc = {
+      value,
+      enumerable,
+      // This is intentional to avoid copying with proxy-compare.
+      // It's still non-writable, so it avoids assigning a value.
+      configurable: true
+    };
+    if (refSet.has(value)) {
+      h$2(value, false);
+    } else if (value instanceof Promise) {
+      delete desc.value;
+      desc.get = () => handlePromise(value);
+    } else if (proxyStateMap.has(value)) {
+      const [target2, ensureVersion] = proxyStateMap.get(
+        value
+      );
+      desc.value = createSnapshot(
+        target2,
+        ensureVersion(),
+        handlePromise
+      );
+    }
+    Object.defineProperty(snap, key, desc);
+  });
+  return Object.preventExtensions(snap);
+}, proxyCache = /* @__PURE__ */ new WeakMap(), versionHolder = [1, 1], proxyFunction = (initialObject) => {
+  if (!isObject(initialObject)) {
+    throw new Error("object required");
+  }
+  const found = proxyCache.get(initialObject);
+  if (found) {
+    return found;
+  }
+  let version = versionHolder[0];
+  const listeners = /* @__PURE__ */ new Set();
+  const notifyUpdate = (op, nextVersion = ++versionHolder[0]) => {
+    if (version !== nextVersion) {
+      version = nextVersion;
+      listeners.forEach((listener) => listener(op, nextVersion));
+    }
+  };
+  let checkVersion = versionHolder[1];
+  const ensureVersion = (nextCheckVersion = ++versionHolder[1]) => {
+    if (checkVersion !== nextCheckVersion && !listeners.size) {
+      checkVersion = nextCheckVersion;
+      propProxyStates.forEach(([propProxyState]) => {
+        const propVersion = propProxyState[1](nextCheckVersion);
+        if (propVersion > version) {
+          version = propVersion;
+        }
+      });
+    }
+    return version;
+  };
+  const createPropListener = (prop) => (op, nextVersion) => {
+    const newOp = [...op];
+    newOp[1] = [prop, ...newOp[1]];
+    notifyUpdate(newOp, nextVersion);
+  };
+  const propProxyStates = /* @__PURE__ */ new Map();
+  const addPropListener = (prop, propProxyState) => {
+    if ((__vite_import_meta_env__$1 ? "production" : void 0) !== "production" && propProxyStates.has(prop)) {
+      throw new Error("prop listener already exists");
+    }
+    if (listeners.size) {
+      const remove = propProxyState[3](createPropListener(prop));
+      propProxyStates.set(prop, [propProxyState, remove]);
+    } else {
+      propProxyStates.set(prop, [propProxyState]);
+    }
+  };
+  const removePropListener = (prop) => {
+    var _a2;
+    const entry = propProxyStates.get(prop);
+    if (entry) {
+      propProxyStates.delete(prop);
+      (_a2 = entry[1]) == null ? void 0 : _a2.call(entry);
+    }
+  };
+  const addListener = (listener) => {
+    listeners.add(listener);
+    if (listeners.size === 1) {
+      propProxyStates.forEach(([propProxyState, prevRemove], prop) => {
+        if ((__vite_import_meta_env__$1 ? "production" : void 0) !== "production" && prevRemove) {
+          throw new Error("remove already exists");
+        }
+        const remove = propProxyState[3](createPropListener(prop));
+        propProxyStates.set(prop, [propProxyState, remove]);
+      });
+    }
+    const removeListener = () => {
+      listeners.delete(listener);
+      if (listeners.size === 0) {
+        propProxyStates.forEach(([propProxyState, remove], prop) => {
+          if (remove) {
+            remove();
+            propProxyStates.set(prop, [propProxyState]);
+          }
+        });
+      }
+    };
+    return removeListener;
+  };
+  const baseObject = Array.isArray(initialObject) ? [] : Object.create(Object.getPrototypeOf(initialObject));
+  const handler = {
+    deleteProperty(target, prop) {
+      const prevValue = Reflect.get(target, prop);
+      removePropListener(prop);
+      const deleted = Reflect.deleteProperty(target, prop);
+      if (deleted) {
+        notifyUpdate(["delete", [prop], prevValue]);
+      }
+      return deleted;
+    },
+    set(target, prop, value, receiver) {
+      const hasPrevValue = Reflect.has(target, prop);
+      const prevValue = Reflect.get(target, prop, receiver);
+      if (hasPrevValue && (objectIs(prevValue, value) || proxyCache.has(value) && objectIs(prevValue, proxyCache.get(value)))) {
+        return true;
+      }
+      removePropListener(prop);
+      if (isObject(value)) {
+        value = y$2(value) || value;
+      }
+      let nextValue = value;
+      if (value instanceof Promise) {
+        value.then((v2) => {
+          value.status = "fulfilled";
+          value.value = v2;
+          notifyUpdate(["resolve", [prop], v2]);
+        }).catch((e2) => {
+          value.status = "rejected";
+          value.reason = e2;
+          notifyUpdate(["reject", [prop], e2]);
+        });
+      } else {
+        if (!proxyStateMap.has(value) && canProxy(value)) {
+          nextValue = proxyFunction(value);
+        }
+        const childProxyState = !refSet.has(nextValue) && proxyStateMap.get(nextValue);
+        if (childProxyState) {
+          addPropListener(prop, childProxyState);
+        }
+      }
+      Reflect.set(target, prop, nextValue, receiver);
+      notifyUpdate(["set", [prop], value, prevValue]);
+      return true;
+    }
+  };
+  const proxyObject = newProxy(baseObject, handler);
+  proxyCache.set(initialObject, proxyObject);
+  const proxyState = [
+    baseObject,
+    ensureVersion,
+    createSnapshot,
+    addListener
+  ];
+  proxyStateMap.set(proxyObject, proxyState);
+  Reflect.ownKeys(initialObject).forEach((key) => {
+    const desc = Object.getOwnPropertyDescriptor(
+      initialObject,
+      key
+    );
+    if ("value" in desc) {
+      proxyObject[key] = initialObject[key];
+      delete desc.value;
+      delete desc.writable;
+    }
+    Object.defineProperty(baseObject, key, desc);
+  });
+  return proxyObject;
+}) => [
+  // public functions
+  proxyFunction,
+  // shared state
+  proxyStateMap,
+  refSet,
+  // internal things
+  objectIs,
+  newProxy,
+  canProxy,
+  defaultHandlePromise,
+  snapCache,
+  createSnapshot,
+  proxyCache,
+  versionHolder
+];
+const [defaultProxyFunction] = buildProxyFunction();
+function proxy(initialObject = {}) {
+  return defaultProxyFunction(initialObject);
+}
+function subscribe(proxyObject, callback, notifyInSync) {
+  const proxyState = proxyStateMap.get(proxyObject);
+  if ((__vite_import_meta_env__$1 ? "production" : void 0) !== "production" && !proxyState) {
+    console.warn("Please use proxy object");
+  }
+  let promise;
+  const ops = [];
+  const addListener = proxyState[3];
+  let isListenerActive = false;
+  const listener = (op) => {
+    ops.push(op);
+    if (!promise) {
+      promise = Promise.resolve().then(() => {
+        promise = void 0;
+        if (isListenerActive) {
+          callback(ops.splice(0));
+        }
+      });
+    }
+  };
+  const removeListener = addListener(listener);
+  isListenerActive = true;
+  return () => {
+    isListenerActive = false;
+    removeListener();
+  };
+}
+function snapshot(proxyObject, handlePromise) {
+  const proxyState = proxyStateMap.get(proxyObject);
+  if ((__vite_import_meta_env__$1 ? "production" : void 0) !== "production" && !proxyState) {
+    console.warn("Please use proxy object");
+  }
+  const [target, ensureVersion, createSnapshot] = proxyState;
+  return createSnapshot(target, ensureVersion(), handlePromise);
+}
+function ref(obj) {
+  refSet.add(obj);
+  return obj;
+}
+function subscribeKey(proxyObject, key, callback, notifyInSync) {
+  let prevValue = proxyObject[key];
+  return subscribe(
+    proxyObject,
+    () => {
+      const nextValue = proxyObject[key];
+      if (!Object.is(prevValue, nextValue)) {
+        callback(prevValue = nextValue);
+      }
+    }
+  );
+}
+function proxyMap(entries) {
+  const map = proxy({
+    data: Array.from([]),
+    has(key) {
+      return this.data.some((p2) => p2[0] === key);
+    },
+    set(key, value) {
+      const record = this.data.find((p2) => p2[0] === key);
+      if (record) {
+        record[1] = value;
+      } else {
+        this.data.push([key, value]);
+      }
+      return this;
+    },
+    get(key) {
+      var _a2;
+      return (_a2 = this.data.find((p2) => p2[0] === key)) == null ? void 0 : _a2[1];
+    },
+    delete(key) {
+      const index = this.data.findIndex((p2) => p2[0] === key);
+      if (index === -1) {
+        return false;
+      }
+      this.data.splice(index, 1);
+      return true;
+    },
+    clear() {
+      this.data.splice(0);
+    },
+    get size() {
+      return this.data.length;
+    },
+    toJSON() {
+      return new Map(this.data);
+    },
+    forEach(cb) {
+      this.data.forEach((p2) => {
+        cb(p2[1], p2[0], this);
+      });
+    },
+    keys() {
+      return this.data.map((p2) => p2[0]).values();
+    },
+    values() {
+      return this.data.map((p2) => p2[1]).values();
+    },
+    entries() {
+      return new Map(this.data).entries();
+    },
+    get [Symbol.toStringTag]() {
+      return "Map";
+    },
+    [Symbol.iterator]() {
+      return this.entries();
+    }
+  });
+  Object.defineProperties(map, {
+    data: {
+      enumerable: false
+    },
+    size: {
+      enumerable: false
+    },
+    toJSON: {
+      enumerable: false
+    }
+  });
+  Object.seal(map);
+  return map;
+}
+function getW3mThemeVariables(themeVariables, themeType) {
+  if (themeType === "light") {
+    return {
+      "--w3m-accent": (themeVariables == null ? void 0 : themeVariables["--w3m-accent"]) || "hsla(231, 100%, 70%, 1)",
+      "--w3m-background": "#fff"
+    };
+  }
+  return {
+    "--w3m-accent": (themeVariables == null ? void 0 : themeVariables["--w3m-accent"]) || "hsla(230, 100%, 67%, 1)",
+    "--w3m-background": "#121313"
+  };
+}
+function tryStringify(o2) {
+  try {
+    return JSON.stringify(o2);
+  } catch (e2) {
+    return '"[Circular]"';
+  }
+}
+var quickFormatUnescaped = format$1;
+function format$1(f2, args, opts) {
+  var ss = opts && opts.stringify || tryStringify;
+  var offset = 1;
+  if (typeof f2 === "object" && f2 !== null) {
+    var len = args.length + offset;
+    if (len === 1) return f2;
+    var objects = new Array(len);
+    objects[0] = ss(f2);
+    for (var index = 1; index < len; index++) {
+      objects[index] = ss(args[index]);
+    }
+    return objects.join(" ");
+  }
+  if (typeof f2 !== "string") {
+    return f2;
+  }
+  var argLen = args.length;
+  if (argLen === 0) return f2;
+  var str = "";
+  var a2 = 1 - offset;
+  var lastPos = -1;
+  var flen = f2 && f2.length || 0;
+  for (var i2 = 0; i2 < flen; ) {
+    if (f2.charCodeAt(i2) === 37 && i2 + 1 < flen) {
+      lastPos = lastPos > -1 ? lastPos : 0;
+      switch (f2.charCodeAt(i2 + 1)) {
+        case 100:
+        case 102:
+          if (a2 >= argLen)
+            break;
+          if (args[a2] == null) break;
+          if (lastPos < i2)
+            str += f2.slice(lastPos, i2);
+          str += Number(args[a2]);
+          lastPos = i2 + 2;
+          i2++;
+          break;
+        case 105:
+          if (a2 >= argLen)
+            break;
+          if (args[a2] == null) break;
+          if (lastPos < i2)
+            str += f2.slice(lastPos, i2);
+          str += Math.floor(Number(args[a2]));
+          lastPos = i2 + 2;
+          i2++;
+          break;
+        case 79:
+        case 111:
+        case 106:
+          if (a2 >= argLen)
+            break;
+          if (args[a2] === void 0) break;
+          if (lastPos < i2)
+            str += f2.slice(lastPos, i2);
+          var type = typeof args[a2];
+          if (type === "string") {
+            str += "'" + args[a2] + "'";
+            lastPos = i2 + 2;
+            i2++;
+            break;
+          }
+          if (type === "function") {
+            str += args[a2].name || "<anonymous>";
+            lastPos = i2 + 2;
+            i2++;
+            break;
+          }
+          str += ss(args[a2]);
+          lastPos = i2 + 2;
+          i2++;
+          break;
+        case 115:
+          if (a2 >= argLen)
+            break;
+          if (lastPos < i2)
+            str += f2.slice(lastPos, i2);
+          str += String(args[a2]);
+          lastPos = i2 + 2;
+          i2++;
+          break;
+        case 37:
+          if (lastPos < i2)
+            str += f2.slice(lastPos, i2);
+          str += "%";
+          lastPos = i2 + 2;
+          i2++;
+          a2--;
+          break;
+      }
+      ++a2;
+    }
+    ++i2;
+  }
+  if (lastPos === -1)
+    return f2;
+  else if (lastPos < flen) {
+    str += f2.slice(lastPos);
+  }
+  return str;
+}
+const format = quickFormatUnescaped;
+var browser = pino;
+const _console = pfGlobalThisOrFallback().console || {};
+const stdSerializers = {
+  mapHttpRequest: mock,
+  mapHttpResponse: mock,
+  wrapRequestSerializer: passthrough,
+  wrapResponseSerializer: passthrough,
+  wrapErrorSerializer: passthrough,
+  req: mock,
+  res: mock,
+  err: asErrValue
+};
+function shouldSerialize(serialize, serializers) {
+  if (Array.isArray(serialize)) {
+    const hasToFilter = serialize.filter(function(k2) {
+      return k2 !== "!stdSerializers.err";
+    });
+    return hasToFilter;
+  } else if (serialize === true) {
+    return Object.keys(serializers);
+  }
+  return false;
+}
+function pino(opts) {
+  opts = opts || {};
+  opts.browser = opts.browser || {};
+  const transmit2 = opts.browser.transmit;
+  if (transmit2 && typeof transmit2.send !== "function") {
+    throw Error("pino: transmit option must have a send function");
+  }
+  const proto = opts.browser.write || _console;
+  if (opts.browser.write) opts.browser.asObject = true;
+  const serializers = opts.serializers || {};
+  const serialize = shouldSerialize(opts.browser.serialize, serializers);
+  let stdErrSerialize = opts.browser.serialize;
+  if (Array.isArray(opts.browser.serialize) && opts.browser.serialize.indexOf("!stdSerializers.err") > -1) stdErrSerialize = false;
+  const levels = ["error", "fatal", "warn", "info", "debug", "trace"];
+  if (typeof proto === "function") {
+    proto.error = proto.fatal = proto.warn = proto.info = proto.debug = proto.trace = proto;
+  }
+  if (opts.enabled === false) opts.level = "silent";
+  const level = opts.level || "info";
+  const logger = Object.create(proto);
+  if (!logger.log) logger.log = noop;
+  Object.defineProperty(logger, "levelVal", {
+    get: getLevelVal
+  });
+  Object.defineProperty(logger, "level", {
+    get: getLevel,
+    set: setLevel
+  });
+  const setOpts = {
+    transmit: transmit2,
+    serialize,
+    asObject: opts.browser.asObject,
+    levels,
+    timestamp: getTimeFunction(opts)
+  };
+  logger.levels = pino.levels;
+  logger.level = level;
+  logger.setMaxListeners = logger.getMaxListeners = logger.emit = logger.addListener = logger.on = logger.prependListener = logger.once = logger.prependOnceListener = logger.removeListener = logger.removeAllListeners = logger.listeners = logger.listenerCount = logger.eventNames = logger.write = logger.flush = noop;
+  logger.serializers = serializers;
+  logger._serialize = serialize;
+  logger._stdErrSerialize = stdErrSerialize;
+  logger.child = child;
+  if (transmit2) logger._logEvent = createLogEventShape();
+  function getLevelVal() {
+    return this.level === "silent" ? Infinity : this.levels.values[this.level];
+  }
+  function getLevel() {
+    return this._level;
+  }
+  function setLevel(level2) {
+    if (level2 !== "silent" && !this.levels.values[level2]) {
+      throw Error("unknown level " + level2);
+    }
+    this._level = level2;
+    set(setOpts, logger, "error", "log");
+    set(setOpts, logger, "fatal", "error");
+    set(setOpts, logger, "warn", "error");
+    set(setOpts, logger, "info", "log");
+    set(setOpts, logger, "debug", "log");
+    set(setOpts, logger, "trace", "log");
+  }
+  function child(bindings, childOptions) {
+    if (!bindings) {
+      throw new Error("missing bindings for child Pino");
+    }
+    childOptions = childOptions || {};
+    if (serialize && bindings.serializers) {
+      childOptions.serializers = bindings.serializers;
+    }
+    const childOptionsSerializers = childOptions.serializers;
+    if (serialize && childOptionsSerializers) {
+      var childSerializers = Object.assign({}, serializers, childOptionsSerializers);
+      var childSerialize = opts.browser.serialize === true ? Object.keys(childSerializers) : serialize;
+      delete bindings.serializers;
+      applySerializers([bindings], childSerialize, childSerializers, this._stdErrSerialize);
+    }
+    function Child(parent) {
+      this._childLevel = (parent._childLevel | 0) + 1;
+      this.error = bind(parent, bindings, "error");
+      this.fatal = bind(parent, bindings, "fatal");
+      this.warn = bind(parent, bindings, "warn");
+      this.info = bind(parent, bindings, "info");
+      this.debug = bind(parent, bindings, "debug");
+      this.trace = bind(parent, bindings, "trace");
+      if (childSerializers) {
+        this.serializers = childSerializers;
+        this._serialize = childSerialize;
+      }
+      if (transmit2) {
+        this._logEvent = createLogEventShape(
+          [].concat(parent._logEvent.bindings, bindings)
+        );
+      }
+    }
+    Child.prototype = this;
+    return new Child(this);
+  }
+  return logger;
+}
+pino.levels = {
+  values: {
+    fatal: 60,
+    error: 50,
+    warn: 40,
+    info: 30,
+    debug: 20,
+    trace: 10
+  },
+  labels: {
+    10: "trace",
+    20: "debug",
+    30: "info",
+    40: "warn",
+    50: "error",
+    60: "fatal"
+  }
+};
+pino.stdSerializers = stdSerializers;
+pino.stdTimeFunctions = Object.assign({}, { nullTime, epochTime, unixTime, isoTime });
+function set(opts, logger, level, fallback) {
+  const proto = Object.getPrototypeOf(logger);
+  logger[level] = logger.levelVal > logger.levels.values[level] ? noop : proto[level] ? proto[level] : _console[level] || _console[fallback] || noop;
+  wrap(opts, logger, level);
+}
+function wrap(opts, logger, level) {
+  if (!opts.transmit && logger[level] === noop) return;
+  logger[level] = /* @__PURE__ */ function(write) {
+    return function LOG() {
+      const ts = opts.timestamp();
+      const args = new Array(arguments.length);
+      const proto = Object.getPrototypeOf && Object.getPrototypeOf(this) === _console ? _console : this;
+      for (var i2 = 0; i2 < args.length; i2++) args[i2] = arguments[i2];
+      if (opts.serialize && !opts.asObject) {
+        applySerializers(args, this._serialize, this.serializers, this._stdErrSerialize);
+      }
+      if (opts.asObject) write.call(proto, asObject(this, level, args, ts));
+      else write.apply(proto, args);
+      if (opts.transmit) {
+        const transmitLevel = opts.transmit.level || logger.level;
+        const transmitValue = pino.levels.values[transmitLevel];
+        const methodValue = pino.levels.values[level];
+        if (methodValue < transmitValue) return;
+        transmit(this, {
+          ts,
+          methodLevel: level,
+          methodValue,
+          transmitValue: pino.levels.values[opts.transmit.level || logger.level],
+          send: opts.transmit.send,
+          val: logger.levelVal
+        }, args);
+      }
+    };
+  }(logger[level]);
+}
+function asObject(logger, level, args, ts) {
+  if (logger._serialize) applySerializers(args, logger._serialize, logger.serializers, logger._stdErrSerialize);
+  const argsCloned = args.slice();
+  let msg = argsCloned[0];
+  const o2 = {};
+  if (ts) {
+    o2.time = ts;
+  }
+  o2.level = pino.levels.values[level];
+  let lvl = (logger._childLevel | 0) + 1;
+  if (lvl < 1) lvl = 1;
+  if (msg !== null && typeof msg === "object") {
+    while (lvl-- && typeof argsCloned[0] === "object") {
+      Object.assign(o2, argsCloned.shift());
+    }
+    msg = argsCloned.length ? format(argsCloned.shift(), argsCloned) : void 0;
+  } else if (typeof msg === "string") msg = format(argsCloned.shift(), argsCloned);
+  if (msg !== void 0) o2.msg = msg;
+  return o2;
+}
+function applySerializers(args, serialize, serializers, stdErrSerialize) {
+  for (const i2 in args) {
+    if (stdErrSerialize && args[i2] instanceof Error) {
+      args[i2] = pino.stdSerializers.err(args[i2]);
+    } else if (typeof args[i2] === "object" && !Array.isArray(args[i2])) {
+      for (const k2 in args[i2]) {
+        if (serialize && serialize.indexOf(k2) > -1 && k2 in serializers) {
+          args[i2][k2] = serializers[k2](args[i2][k2]);
+        }
+      }
+    }
+  }
+}
+function bind(parent, bindings, level) {
+  return function() {
+    const args = new Array(1 + arguments.length);
+    args[0] = bindings;
+    for (var i2 = 1; i2 < args.length; i2++) {
+      args[i2] = arguments[i2 - 1];
+    }
+    return parent[level].apply(this, args);
+  };
+}
+function transmit(logger, opts, args) {
+  const send = opts.send;
+  const ts = opts.ts;
+  const methodLevel = opts.methodLevel;
+  const methodValue = opts.methodValue;
+  const val = opts.val;
+  const bindings = logger._logEvent.bindings;
+  applySerializers(
+    args,
+    logger._serialize || Object.keys(logger.serializers),
+    logger.serializers,
+    logger._stdErrSerialize === void 0 ? true : logger._stdErrSerialize
+  );
+  logger._logEvent.ts = ts;
+  logger._logEvent.messages = args.filter(function(arg) {
+    return bindings.indexOf(arg) === -1;
+  });
+  logger._logEvent.level.label = methodLevel;
+  logger._logEvent.level.value = methodValue;
+  send(methodLevel, logger._logEvent, val);
+  logger._logEvent = createLogEventShape(bindings);
+}
+function createLogEventShape(bindings) {
+  return {
+    ts: 0,
+    messages: [],
+    bindings: bindings || [],
+    level: { label: "", value: 0 }
+  };
+}
+function asErrValue(err) {
+  const obj = {
+    type: err.constructor.name,
+    msg: err.message,
+    stack: err.stack
+  };
+  for (const key in err) {
+    if (obj[key] === void 0) {
+      obj[key] = err[key];
+    }
+  }
+  return obj;
+}
+function getTimeFunction(opts) {
+  if (typeof opts.timestamp === "function") {
+    return opts.timestamp;
+  }
+  if (opts.timestamp === false) {
+    return nullTime;
+  }
+  return epochTime;
+}
+function mock() {
+  return {};
+}
+function passthrough(a2) {
+  return a2;
+}
+function noop() {
+}
+function nullTime() {
+  return false;
+}
+function epochTime() {
+  return Date.now();
+}
+function unixTime() {
+  return Math.round(Date.now() / 1e3);
+}
+function isoTime() {
+  return new Date(Date.now()).toISOString();
+}
+function pfGlobalThisOrFallback() {
+  function defd(o2) {
+    return typeof o2 !== "undefined" && o2;
+  }
+  try {
+    if (typeof globalThis !== "undefined") return globalThis;
+    Object.defineProperty(Object.prototype, "globalThis", {
+      get: function() {
+        delete Object.prototype.globalThis;
+        return this.globalThis = this;
+      },
+      configurable: true
+    });
+    return globalThis;
+  } catch (e2) {
+    return defd(self) || defd(window) || defd(this) || {};
+  }
+}
+const Ot = /* @__PURE__ */ getDefaultExportFromCjs(browser);
+function base(ALPHABET2) {
+  if (ALPHABET2.length >= 255) {
+    throw new TypeError("Alphabet too long");
+  }
+  const BASE_MAP = new Uint8Array(256);
+  for (let j2 = 0; j2 < BASE_MAP.length; j2++) {
+    BASE_MAP[j2] = 255;
+  }
+  for (let i2 = 0; i2 < ALPHABET2.length; i2++) {
+    const x2 = ALPHABET2.charAt(i2);
+    const xc = x2.charCodeAt(0);
+    if (BASE_MAP[xc] !== 255) {
+      throw new TypeError(x2 + " is ambiguous");
+    }
+    BASE_MAP[xc] = i2;
+  }
+  const BASE = ALPHABET2.length;
+  const LEADER = ALPHABET2.charAt(0);
+  const FACTOR = Math.log(BASE) / Math.log(256);
+  const 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 "";
+    }
+    let zeroes = 0;
+    let length = 0;
+    let pbegin = 0;
+    const pend = source.length;
+    while (pbegin !== pend && source[pbegin] === 0) {
+      pbegin++;
+      zeroes++;
+    }
+    const size = (pend - pbegin) * iFACTOR + 1 >>> 0;
+    const b58 = new Uint8Array(size);
+    while (pbegin !== pend) {
+      let carry = source[pbegin];
+      let i2 = 0;
+      for (let 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++;
+    }
+    let it2 = size - length;
+    while (it2 !== size && b58[it2] === 0) {
+      it2++;
+    }
+    let str = LEADER.repeat(zeroes);
+    for (; it2 < size; ++it2) {
+      str += ALPHABET2.charAt(b58[it2]);
+    }
+    return str;
+  }
+  function decodeUnsafe(source) {
+    if (typeof source !== "string") {
+      throw new TypeError("Expected String");
+    }
+    if (source.length === 0) {
+      return new Uint8Array();
+    }
+    let psz = 0;
+    let zeroes = 0;
+    let length = 0;
+    while (source[psz] === LEADER) {
+      zeroes++;
+      psz++;
+    }
+    const size = (source.length - psz) * FACTOR + 1 >>> 0;
+    const b256 = new Uint8Array(size);
+    while (psz < source.length) {
+      const charCode = source.charCodeAt(psz);
+      if (charCode > 255) {
+        return;
+      }
+      let carry = BASE_MAP[charCode];
+      if (carry === 255) {
+        return;
+      }
+      let i2 = 0;
+      for (let 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++;
+    }
+    let it4 = size - length;
+    while (it4 !== size && b256[it4] === 0) {
+      it4++;
+    }
+    const vch = new Uint8Array(zeroes + (size - it4));
+    let j2 = zeroes;
+    while (it4 !== size) {
+      vch[j2++] = b256[it4++];
+    }
+    return vch;
+  }
+  function decode(string) {
+    const buffer = decodeUnsafe(string);
+    if (buffer) {
+      return buffer;
+    }
+    throw new Error("Non-base" + BASE + " character");
+  }
+  return {
+    encode,
+    decodeUnsafe,
+    decode
+  };
+}
+var ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+const bs58 = base(ALPHABET);
+var cjs = {};
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+var extendStatics = function(d2, b2) {
+  extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d3, b3) {
+    d3.__proto__ = b3;
+  } || function(d3, b3) {
+    for (var p2 in b3) if (b3.hasOwnProperty(p2)) d3[p2] = b3[p2];
+  };
+  return extendStatics(d2, b2);
+};
+function __extends(d2, b2) {
+  extendStatics(d2, b2);
+  function __() {
+    this.constructor = d2;
+  }
+  d2.prototype = b2 === null ? Object.create(b2) : (__.prototype = b2.prototype, new __());
+}
+var __assign = function() {
+  __assign = Object.assign || function __assign2(t2) {
+    for (var s2, i2 = 1, n3 = arguments.length; i2 < n3; i2++) {
+      s2 = arguments[i2];
+      for (var p2 in s2) if (Object.prototype.hasOwnProperty.call(s2, p2)) t2[p2] = s2[p2];
+    }
+    return t2;
+  };
+  return __assign.apply(this, arguments);
+};
+function __rest(s2, e2) {
+  var t2 = {};
+  for (var p2 in s2) if (Object.prototype.hasOwnProperty.call(s2, p2) && e2.indexOf(p2) < 0)
+    t2[p2] = s2[p2];
+  if (s2 != null && typeof Object.getOwnPropertySymbols === "function")
+    for (var i2 = 0, p2 = Object.getOwnPropertySymbols(s2); i2 < p2.length; i2++) {
+      if (e2.indexOf(p2[i2]) < 0 && Object.prototype.propertyIsEnumerable.call(s2, p2[i2]))
+        t2[p2[i2]] = s2[p2[i2]];
+    }
+  return t2;
+}
+function __decorate(decorators, target, key, desc) {
+  var c2 = arguments.length, r2 = c2 < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d2;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r2 = Reflect.decorate(decorators, target, key, desc);
+  else for (var i2 = decorators.length - 1; i2 >= 0; i2--) if (d2 = decorators[i2]) r2 = (c2 < 3 ? d2(r2) : c2 > 3 ? d2(target, key, r2) : d2(target, key)) || r2;
+  return c2 > 3 && r2 && Object.defineProperty(target, key, r2), r2;
+}
+function __param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+function __metadata(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+function __awaiter(thisArg, _arguments, P2, generator) {
+  function adopt(value) {
+    return value instanceof P2 ? value : new P2(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P2 || (P2 = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e2) {
+        reject(e2);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e2) {
+        reject(e2);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+}
+function __generator(thisArg, body) {
+  var _2 = { label: 0, sent: function() {
+    if (t2[0] & 1) throw t2[1];
+    return t2[1];
+  }, trys: [], ops: [] }, f2, y3, t2, g2;
+  return g2 = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g2[Symbol.iterator] = function() {
+    return this;
+  }), g2;
+  function verb(n3) {
+    return function(v2) {
+      return step([n3, v2]);
+    };
+  }
+  function step(op) {
+    if (f2) throw new TypeError("Generator is already executing.");
+    while (_2) try {
+      if (f2 = 1, y3 && (t2 = op[0] & 2 ? y3["return"] : op[0] ? y3["throw"] || ((t2 = y3["return"]) && t2.call(y3), 0) : y3.next) && !(t2 = t2.call(y3, op[1])).done) return t2;
+      if (y3 = 0, t2) op = [op[0] & 2, t2.value];
+      switch (op[0]) {
+        case 0:
+        case 1:
+          t2 = op;
+          break;
+        case 4:
+          _2.label++;
+          return { value: op[1], done: false };
+        case 5:
+          _2.label++;
+          y3 = op[1];
+          op = [0];
+          continue;
+        case 7:
+          op = _2.ops.pop();
+          _2.trys.pop();
+          continue;
+        default:
+          if (!(t2 = _2.trys, t2 = t2.length > 0 && t2[t2.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+            _2 = 0;
+            continue;
+          }
+          if (op[0] === 3 && (!t2 || op[1] > t2[0] && op[1] < t2[3])) {
+            _2.label = op[1];
+            break;
+          }
+          if (op[0] === 6 && _2.label < t2[1]) {
+            _2.label = t2[1];
+            t2 = op;
+            break;
+          }
+          if (t2 && _2.label < t2[2]) {
+            _2.label = t2[2];
+            _2.ops.push(op);
+            break;
+          }
+          if (t2[2]) _2.ops.pop();
+          _2.trys.pop();
+          continue;
+      }
+      op = body.call(thisArg, _2);
+    } catch (e2) {
+      op = [6, e2];
+      y3 = 0;
+    } finally {
+      f2 = t2 = 0;
+    }
+    if (op[0] & 5) throw op[1];
+    return { value: op[0] ? op[1] : void 0, done: true };
+  }
+}
+function __createBinding(o2, m2, k2, k22) {
+  if (k22 === void 0) k22 = k2;
+  o2[k22] = m2[k2];
+}
+function __exportStar(m2, exports2) {
+  for (var p2 in m2) if (p2 !== "default" && !exports2.hasOwnProperty(p2)) exports2[p2] = m2[p2];
+}
+function __values(o2) {
+  var s2 = typeof Symbol === "function" && Symbol.iterator, m2 = s2 && o2[s2], i2 = 0;
+  if (m2) return m2.call(o2);
+  if (o2 && typeof o2.length === "number") return {
+    next: function() {
+      if (o2 && i2 >= o2.length) o2 = void 0;
+      return { value: o2 && o2[i2++], done: !o2 };
+    }
+  };
+  throw new TypeError(s2 ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __read(o2, n3) {
+  var m2 = typeof Symbol === "function" && o2[Symbol.iterator];
+  if (!m2) return o2;
+  var i2 = m2.call(o2), r2, ar = [], e2;
+  try {
+    while ((n3 === void 0 || n3-- > 0) && !(r2 = i2.next()).done) ar.push(r2.value);
+  } catch (error) {
+    e2 = { error };
+  } finally {
+    try {
+      if (r2 && !r2.done && (m2 = i2["return"])) m2.call(i2);
+    } finally {
+      if (e2) throw e2.error;
+    }
+  }
+  return ar;
+}
+function __spread() {
+  for (var ar = [], i2 = 0; i2 < arguments.length; i2++)
+    ar = ar.concat(__read(arguments[i2]));
+  return ar;
+}
+function __spreadArrays() {
+  for (var s2 = 0, i2 = 0, il = arguments.length; i2 < il; i2++) s2 += arguments[i2].length;
+  for (var r2 = Array(s2), k2 = 0, i2 = 0; i2 < il; i2++)
+    for (var a2 = arguments[i2], j2 = 0, jl = a2.length; j2 < jl; j2++, k2++)
+      r2[k2] = a2[j2];
+  return r2;
+}
+function __await(v2) {
+  return this instanceof __await ? (this.v = v2, this) : new __await(v2);
+}
+function __asyncGenerator(thisArg, _arguments, generator) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var g2 = generator.apply(thisArg, _arguments || []), i2, q = [];
+  return i2 = {}, verb("next"), verb("throw"), verb("return"), i2[Symbol.asyncIterator] = function() {
+    return this;
+  }, i2;
+  function verb(n3) {
+    if (g2[n3]) i2[n3] = function(v2) {
+      return new Promise(function(a2, b2) {
+        q.push([n3, v2, a2, b2]) > 1 || resume(n3, v2);
+      });
+    };
+  }
+  function resume(n3, v2) {
+    try {
+      step(g2[n3](v2));
+    } catch (e2) {
+      settle(q[0][3], e2);
+    }
+  }
+  function step(r2) {
+    r2.value instanceof __await ? Promise.resolve(r2.value.v).then(fulfill, reject) : settle(q[0][2], r2);
+  }
+  function fulfill(value) {
+    resume("next", value);
+  }
+  function reject(value) {
+    resume("throw", value);
+  }
+  function settle(f2, v2) {
+    if (f2(v2), q.shift(), q.length) resume(q[0][0], q[0][1]);
+  }
+}
+function __asyncDelegator(o2) {
+  var i2, p2;
+  return i2 = {}, verb("next"), verb("throw", function(e2) {
+    throw e2;
+  }), verb("return"), i2[Symbol.iterator] = function() {
+    return this;
+  }, i2;
+  function verb(n3, f2) {
+    i2[n3] = o2[n3] ? function(v2) {
+      return (p2 = !p2) ? { value: __await(o2[n3](v2)), done: n3 === "return" } : f2 ? f2(v2) : v2;
+    } : f2;
+  }
+}
+function __asyncValues(o2) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var m2 = o2[Symbol.asyncIterator], i2;
+  return m2 ? m2.call(o2) : (o2 = typeof __values === "function" ? __values(o2) : o2[Symbol.iterator](), i2 = {}, verb("next"), verb("throw"), verb("return"), i2[Symbol.asyncIterator] = function() {
+    return this;
+  }, i2);
+  function verb(n3) {
+    i2[n3] = o2[n3] && function(v2) {
+      return new Promise(function(resolve, reject) {
+        v2 = o2[n3](v2), settle(resolve, reject, v2.done, v2.value);
+      });
+    };
+  }
+  function settle(resolve, reject, d2, v2) {
+    Promise.resolve(v2).then(function(v3) {
+      resolve({ value: v3, done: d2 });
+    }, reject);
+  }
+}
+function __makeTemplateObject(cooked, raw) {
+  if (Object.defineProperty) {
+    Object.defineProperty(cooked, "raw", { value: raw });
+  } else {
+    cooked.raw = raw;
+  }
+  return cooked;
+}
+function __importStar(mod) {
+  if (mod && mod.__esModule) return mod;
+  var result = {};
+  if (mod != null) {
+    for (var k2 in mod) if (Object.hasOwnProperty.call(mod, k2)) result[k2] = mod[k2];
+  }
+  result.default = mod;
+  return result;
+}
+function __importDefault(mod) {
+  return mod && mod.__esModule ? mod : { default: mod };
+}
+function __classPrivateFieldGet(receiver, privateMap) {
+  if (!privateMap.has(receiver)) {
+    throw new TypeError("attempted to get private field on non-instance");
+  }
+  return privateMap.get(receiver);
+}
+function __classPrivateFieldSet(receiver, privateMap, value) {
+  if (!privateMap.has(receiver)) {
+    throw new TypeError("attempted to set private field on non-instance");
+  }
+  privateMap.set(receiver, value);
+  return value;
+}
+const tslib_es6 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  get __assign() {
+    return __assign;
+  },
+  __asyncDelegator,
+  __asyncGenerator,
+  __asyncValues,
+  __await,
+  __awaiter,
+  __classPrivateFieldGet,
+  __classPrivateFieldSet,
+  __createBinding,
+  __decorate,
+  __exportStar,
+  __extends,
+  __generator,
+  __importDefault,
+  __importStar,
+  __makeTemplateObject,
+  __metadata,
+  __param,
+  __read,
+  __rest,
+  __spread,
+  __spreadArrays,
+  __values
+}, Symbol.toStringTag, { value: "Module" }));
+const require$$0 = /* @__PURE__ */ getAugmentedNamespace(tslib_es6);
+var crypto = {};
+var hasRequiredCrypto;
+function requireCrypto() {
+  if (hasRequiredCrypto) return crypto;
+  hasRequiredCrypto = 1;
+  Object.defineProperty(crypto, "__esModule", { value: true });
+  crypto.isBrowserCryptoAvailable = crypto.getSubtleCrypto = crypto.getBrowerCrypto = void 0;
+  function getBrowerCrypto() {
+    return (commonjsGlobal === null || commonjsGlobal === void 0 ? void 0 : commonjsGlobal.crypto) || (commonjsGlobal === null || commonjsGlobal === void 0 ? void 0 : commonjsGlobal.msCrypto) || {};
+  }
+  crypto.getBrowerCrypto = getBrowerCrypto;
+  function getSubtleCrypto() {
+    const browserCrypto = getBrowerCrypto();
+    return browserCrypto.subtle || browserCrypto.webkitSubtle;
+  }
+  crypto.getSubtleCrypto = getSubtleCrypto;
+  function isBrowserCryptoAvailable() {
+    return !!getBrowerCrypto() && !!getSubtleCrypto();
+  }
+  crypto.isBrowserCryptoAvailable = isBrowserCryptoAvailable;
+  return crypto;
+}
+var env = {};
+var hasRequiredEnv;
+function requireEnv() {
+  if (hasRequiredEnv) return env;
+  hasRequiredEnv = 1;
+  Object.defineProperty(env, "__esModule", { value: true });
+  env.isBrowser = env.isNode = env.isReactNative = void 0;
+  function isReactNative() {
+    return typeof document === "undefined" && typeof navigator !== "undefined" && navigator.product === "ReactNative";
+  }
+  env.isReactNative = isReactNative;
+  function isNode() {
+    return typeof process !== "undefined" && typeof process.versions !== "undefined" && typeof process.versions.node !== "undefined";
+  }
+  env.isNode = isNode;
+  function isBrowser() {
+    return !isReactNative() && !isNode();
+  }
+  env.isBrowser = isBrowser;
+  return env;
+}
+(function(exports2) {
+  Object.defineProperty(exports2, "__esModule", { value: true });
+  const tslib_1 = require$$0;
+  tslib_1.__exportStar(requireCrypto(), exports2);
+  tslib_1.__exportStar(requireEnv(), exports2);
+})(cjs);
+var shim = { exports: {} };
+var useSyncExternalStoreShim_production_min = {};
+/**
+ * @license React
+ * use-sync-external-store-shim.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var hasRequiredUseSyncExternalStoreShim_production_min;
+function requireUseSyncExternalStoreShim_production_min() {
+  if (hasRequiredUseSyncExternalStoreShim_production_min) return useSyncExternalStoreShim_production_min;
+  hasRequiredUseSyncExternalStoreShim_production_min = 1;
+  var e2 = require$$0$1;
+  function h2(a2, b2) {
+    return a2 === b2 && (0 !== a2 || 1 / a2 === 1 / b2) || a2 !== a2 && b2 !== b2;
+  }
+  var k2 = "function" === typeof Object.is ? Object.is : h2, l2 = e2.useState, m2 = e2.useEffect, n3 = e2.useLayoutEffect, p2 = e2.useDebugValue;
+  function q(a2, b2) {
+    var d2 = b2(), f2 = l2({ inst: { value: d2, getSnapshot: b2 } }), c2 = f2[0].inst, g2 = f2[1];
+    n3(function() {
+      c2.value = d2;
+      c2.getSnapshot = b2;
+      r2(c2) && g2({ inst: c2 });
+    }, [a2, d2, b2]);
+    m2(function() {
+      r2(c2) && g2({ inst: c2 });
+      return a2(function() {
+        r2(c2) && g2({ inst: c2 });
+      });
+    }, [a2]);
+    p2(d2);
+    return d2;
+  }
+  function r2(a2) {
+    var b2 = a2.getSnapshot;
+    a2 = a2.value;
+    try {
+      var d2 = b2();
+      return !k2(a2, d2);
+    } catch (f2) {
+      return true;
+    }
+  }
+  function t2(a2, b2) {
+    return b2();
+  }
+  var u2 = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? t2 : q;
+  useSyncExternalStoreShim_production_min.useSyncExternalStore = void 0 !== e2.useSyncExternalStore ? e2.useSyncExternalStore : u2;
+  return useSyncExternalStoreShim_production_min;
+}
+var useSyncExternalStoreShim_development = {};
+/**
+ * @license React
+ * use-sync-external-store-shim.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var hasRequiredUseSyncExternalStoreShim_development;
+function requireUseSyncExternalStoreShim_development() {
+  if (hasRequiredUseSyncExternalStoreShim_development) return useSyncExternalStoreShim_development;
+  hasRequiredUseSyncExternalStoreShim_development = 1;
+  if (process.env.NODE_ENV !== "production") {
+    (function() {
+      if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function") {
+        __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
+      }
+      var React = require$$0$1;
+      var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+      function error(format2) {
+        {
+          {
+            for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+              args[_key2 - 1] = arguments[_key2];
+            }
+            printWarning("error", format2, args);
+          }
+        }
+      }
+      function printWarning(level, format2, args) {
+        {
+          var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+          var stack = ReactDebugCurrentFrame.getStackAddendum();
+          if (stack !== "") {
+            format2 += "%s";
+            args = args.concat([stack]);
+          }
+          var argsWithFormat = args.map(function(item) {
+            return String(item);
+          });
+          argsWithFormat.unshift("Warning: " + format2);
+          Function.prototype.apply.call(console[level], console, argsWithFormat);
+        }
+      }
+      function is(x2, y3) {
+        return x2 === y3 && (x2 !== 0 || 1 / x2 === 1 / y3) || x2 !== x2 && y3 !== y3;
+      }
+      var objectIs = typeof Object.is === "function" ? Object.is : is;
+      var useState = React.useState, useEffect = React.useEffect, useLayoutEffect = React.useLayoutEffect, useDebugValue = React.useDebugValue;
+      var didWarnOld18Alpha = false;
+      var didWarnUncachedGetSnapshot = false;
+      function useSyncExternalStore2(subscribe2, getSnapshot, getServerSnapshot) {
+        {
+          if (!didWarnOld18Alpha) {
+            if (React.startTransition !== void 0) {
+              didWarnOld18Alpha = true;
+              error("You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release.");
+            }
+          }
+        }
+        var value = getSnapshot();
+        {
+          if (!didWarnUncachedGetSnapshot) {
+            var cachedValue = getSnapshot();
+            if (!objectIs(value, cachedValue)) {
+              error("The result of getSnapshot should be cached to avoid an infinite loop");
+              didWarnUncachedGetSnapshot = true;
+            }
+          }
+        }
+        var _useState = useState({
+          inst: {
+            value,
+            getSnapshot
+          }
+        }), inst = _useState[0].inst, forceUpdate = _useState[1];
+        useLayoutEffect(function() {
+          inst.value = value;
+          inst.getSnapshot = getSnapshot;
+          if (checkIfSnapshotChanged(inst)) {
+            forceUpdate({
+              inst
+            });
+          }
+        }, [subscribe2, value, getSnapshot]);
+        useEffect(function() {
+          if (checkIfSnapshotChanged(inst)) {
+            forceUpdate({
+              inst
+            });
+          }
+          var handleStoreChange = function() {
+            if (checkIfSnapshotChanged(inst)) {
+              forceUpdate({
+                inst
+              });
+            }
+          };
+          return subscribe2(handleStoreChange);
+        }, [subscribe2]);
+        useDebugValue(value);
+        return value;
+      }
+      function checkIfSnapshotChanged(inst) {
+        var latestGetSnapshot = inst.getSnapshot;
+        var prevValue = inst.value;
+        try {
+          var nextValue = latestGetSnapshot();
+          return !objectIs(prevValue, nextValue);
+        } catch (error2) {
+          return true;
+        }
+      }
+      function useSyncExternalStore$1(subscribe2, getSnapshot, getServerSnapshot) {
+        return getSnapshot();
+      }
+      var canUseDOM = !!(typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined");
+      var isServerEnvironment = !canUseDOM;
+      var shim2 = isServerEnvironment ? useSyncExternalStore$1 : useSyncExternalStore2;
+      var useSyncExternalStore$2 = React.useSyncExternalStore !== void 0 ? React.useSyncExternalStore : shim2;
+      useSyncExternalStoreShim_development.useSyncExternalStore = useSyncExternalStore$2;
+      if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function") {
+        __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
+      }
+    })();
+  }
+  return useSyncExternalStoreShim_development;
+}
+if (process.env.NODE_ENV === "production") {
+  shim.exports = requireUseSyncExternalStoreShim_production_min();
+} else {
+  shim.exports = requireUseSyncExternalStoreShim_development();
+}
+var shimExports = shim.exports;
+const useSyncExternalStoreExports = /* @__PURE__ */ getDefaultExportFromCjs(shimExports);
+const __vite_import_meta_env__ = {};
+const { use } = require$$0$1;
+const { useSyncExternalStore } = useSyncExternalStoreExports;
+const useAffectedDebugValue = (state, affected) => {
+  const pathList = require$$0$1.useRef();
+  require$$0$1.useEffect(() => {
+    pathList.current = w(state, affected);
+  });
+  require$$0$1.useDebugValue(pathList.current);
+};
+const targetCache = /* @__PURE__ */ new WeakMap();
+function useSnapshot(proxyObject, options) {
+  const notifyInSync = void 0;
+  const lastSnapshot = require$$0$1.useRef();
+  const lastAffected = require$$0$1.useRef();
+  let inRender = true;
+  const currSnapshot = useSyncExternalStore(
+    require$$0$1.useCallback(
+      (callback) => {
+        const unsub = subscribe(proxyObject, callback);
+        callback();
+        return unsub;
+      },
+      [proxyObject, notifyInSync]
+    ),
+    () => {
+      const nextSnapshot = snapshot(proxyObject, use);
+      try {
+        if (!inRender && lastSnapshot.current && lastAffected.current && !p$2(
+          lastSnapshot.current,
+          nextSnapshot,
+          lastAffected.current,
+          /* @__PURE__ */ new WeakMap()
+        )) {
+          return lastSnapshot.current;
+        }
+      } catch (e2) {
+      }
+      return nextSnapshot;
+    },
+    () => snapshot(proxyObject, use)
+  );
+  inRender = false;
+  const currAffected = /* @__PURE__ */ new WeakMap();
+  require$$0$1.useEffect(() => {
+    lastSnapshot.current = currSnapshot;
+    lastAffected.current = currAffected;
+  });
+  if ((__vite_import_meta_env__ ? "production" : void 0) !== "production") {
+    useAffectedDebugValue(currSnapshot, currAffected);
+  }
+  const proxyCache = require$$0$1.useMemo(() => /* @__PURE__ */ new WeakMap(), []);
+  return a$2(
+    currSnapshot,
+    currAffected,
+    proxyCache,
+    targetCache
+  );
+}
+const ConstantsUtil = {
+  ACCOUNT_TABS: [{ label: "Tokens" }, { label: "NFTs" }, { label: "Activity" }],
+  SECURE_SITE_ORIGIN: (typeof process !== "undefined" && typeof process.env !== "undefined" ? process.env["NEXT_PUBLIC_SECURE_SITE_ORIGIN"] : void 0) || "https://secure.walletconnect.org",
+  VIEW_DIRECTION: {
+    Next: "next",
+    Prev: "prev"
+  },
+  DEFAULT_CONNECT_METHOD_ORDER: ["email", "social", "wallet"],
+  ANIMATION_DURATIONS: {
+    HeaderText: 120,
+    ModalHeight: 150,
+    ViewTransition: 150
+  }
+};
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+const t$1 = globalThis, e$2 = t$1.ShadowRoot && (void 0 === t$1.ShadyCSS || t$1.ShadyCSS.nativeShadow) && "adoptedStyleSheets" in Document.prototype && "replace" in CSSStyleSheet.prototype, s$2 = Symbol(), o$3 = /* @__PURE__ */ new WeakMap();
+let n$2 = class n {
+  constructor(t2, e2, o2) {
+    if (this._$cssResult$ = true, o2 !== s$2) throw Error("CSSResult is not constructable. Use `unsafeCSS` or `css` instead.");
+    this.cssText = t2, this.t = e2;
+  }
+  get styleSheet() {
+    let t2 = this.o;
+    const s2 = this.t;
+    if (e$2 && void 0 === t2) {
+      const e2 = void 0 !== s2 && 1 === s2.length;
+      e2 && (t2 = o$3.get(s2)), void 0 === t2 && ((this.o = t2 = new CSSStyleSheet()).replaceSync(this.cssText), e2 && o$3.set(s2, t2));
+    }
+    return t2;
+  }
+  toString() {
+    return this.cssText;
+  }
+};
+const r$2 = (t2) => new n$2("string" == typeof t2 ? t2 : t2 + "", void 0, s$2), i$3 = (t2, ...e2) => {
+  const o2 = 1 === t2.length ? t2[0] : e2.reduce((e3, s2, o3) => e3 + ((t3) => {
+    if (true === t3._$cssResult$) return t3.cssText;
+    if ("number" == typeof t3) return t3;
+    throw Error("Value passed to 'css' function must be a 'css' function result: " + t3 + ". Use 'unsafeCSS' to pass non-literal values, but take care to ensure page security.");
+  })(s2) + t2[o3 + 1], t2[0]);
+  return new n$2(o2, t2, s$2);
+}, S$1 = (s2, o2) => {
+  if (e$2) s2.adoptedStyleSheets = o2.map((t2) => t2 instanceof CSSStyleSheet ? t2 : t2.styleSheet);
+  else for (const e2 of o2) {
+    const o3 = document.createElement("style"), n3 = t$1.litNonce;
+    void 0 !== n3 && o3.setAttribute("nonce", n3), o3.textContent = e2.cssText, s2.appendChild(o3);
+  }
+}, c$2 = e$2 ? (t2) => t2 : (t2) => t2 instanceof CSSStyleSheet ? ((t3) => {
+  let e2 = "";
+  for (const s2 of t3.cssRules) e2 += s2.cssText;
+  return r$2(e2);
+})(t2) : t2;
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+const { is: i$2, defineProperty: e$1, getOwnPropertyDescriptor: h$1, getOwnPropertyNames: r$1, getOwnPropertySymbols: o$2, getPrototypeOf: n$1 } = Object, a$1 = globalThis, c$1 = a$1.trustedTypes, l$1 = c$1 ? c$1.emptyScript : "", p$1 = a$1.reactiveElementPolyfillSupport, d$1 = (t2, s2) => t2, u$1 = { toAttribute(t2, s2) {
+  switch (s2) {
+    case Boolean:
+      t2 = t2 ? l$1 : null;
+      break;
+    case Object:
+    case Array:
+      t2 = null == t2 ? t2 : JSON.stringify(t2);
+  }
+  return t2;
+}, fromAttribute(t2, s2) {
+  let i2 = t2;
+  switch (s2) {
+    case Boolean:
+      i2 = null !== t2;
+      break;
+    case Number:
+      i2 = null === t2 ? null : Number(t2);
+      break;
+    case Object:
+    case Array:
+      try {
+        i2 = JSON.parse(t2);
+      } catch (t3) {
+        i2 = null;
+      }
+  }
+  return i2;
+} }, f$1 = (t2, s2) => !i$2(t2, s2), b$1 = { attribute: true, type: String, converter: u$1, reflect: false, useDefault: false, hasChanged: f$1 };
+Symbol.metadata ?? (Symbol.metadata = Symbol("metadata")), a$1.litPropertyMetadata ?? (a$1.litPropertyMetadata = /* @__PURE__ */ new WeakMap());
+let y$1 = class y extends HTMLElement {
+  static addInitializer(t2) {
+    this._$Ei(), (this.l ?? (this.l = [])).push(t2);
+  }
+  static get observedAttributes() {
+    return this.finalize(), this._$Eh && [...this._$Eh.keys()];
+  }
+  static createProperty(t2, s2 = b$1) {
+    if (s2.state && (s2.attribute = false), this._$Ei(), this.prototype.hasOwnProperty(t2) && ((s2 = Object.create(s2)).wrapped = true), this.elementProperties.set(t2, s2), !s2.noAccessor) {
+      const i2 = Symbol(), h2 = this.getPropertyDescriptor(t2, i2, s2);
+      void 0 !== h2 && e$1(this.prototype, t2, h2);
+    }
+  }
+  static getPropertyDescriptor(t2, s2, i2) {
+    const { get: e2, set: r2 } = h$1(this.prototype, t2) ?? { get() {
+      return this[s2];
+    }, set(t3) {
+      this[s2] = t3;
+    } };
+    return { get: e2, set(s3) {
+      const h2 = e2 == null ? void 0 : e2.call(this);
+      r2 == null ? void 0 : r2.call(this, s3), this.requestUpdate(t2, h2, i2);
+    }, configurable: true, enumerable: true };
+  }
+  static getPropertyOptions(t2) {
+    return this.elementProperties.get(t2) ?? b$1;
+  }
+  static _$Ei() {
+    if (this.hasOwnProperty(d$1("elementProperties"))) return;
+    const t2 = n$1(this);
+    t2.finalize(), void 0 !== t2.l && (this.l = [...t2.l]), this.elementProperties = new Map(t2.elementProperties);
+  }
+  static finalize() {
+    if (this.hasOwnProperty(d$1("finalized"))) return;
+    if (this.finalized = true, this._$Ei(), this.hasOwnProperty(d$1("properties"))) {
+      const t3 = this.properties, s2 = [...r$1(t3), ...o$2(t3)];
+      for (const i2 of s2) this.createProperty(i2, t3[i2]);
+    }
+    const t2 = this[Symbol.metadata];
+    if (null !== t2) {
+      const s2 = litPropertyMetadata.get(t2);
+      if (void 0 !== s2) for (const [t3, i2] of s2) this.elementProperties.set(t3, i2);
+    }
+    this._$Eh = /* @__PURE__ */ new Map();
+    for (const [t3, s2] of this.elementProperties) {
+      const i2 = this._$Eu(t3, s2);
+      void 0 !== i2 && this._$Eh.set(i2, t3);
+    }
+    this.elementStyles = this.finalizeStyles(this.styles);
+  }
+  static finalizeStyles(s2) {
+    const i2 = [];
+    if (Array.isArray(s2)) {
+      const e2 = new Set(s2.flat(1 / 0).reverse());
+      for (const s3 of e2) i2.unshift(c$2(s3));
+    } else void 0 !== s2 && i2.push(c$2(s2));
+    return i2;
+  }
+  static _$Eu(t2, s2) {
+    const i2 = s2.attribute;
+    return false === i2 ? void 0 : "string" == typeof i2 ? i2 : "string" == typeof t2 ? t2.toLowerCase() : void 0;
+  }
+  constructor() {
+    super(), this._$Ep = void 0, this.isUpdatePending = false, this.hasUpdated = false, this._$Em = null, this._$Ev();
+  }
+  _$Ev() {
+    var _a2;
+    this._$ES = new Promise((t2) => this.enableUpdating = t2), this._$AL = /* @__PURE__ */ new Map(), this._$E_(), this.requestUpdate(), (_a2 = this.constructor.l) == null ? void 0 : _a2.forEach((t2) => t2(this));
+  }
+  addController(t2) {
+    var _a2;
+    (this._$EO ?? (this._$EO = /* @__PURE__ */ new Set())).add(t2), void 0 !== this.renderRoot && this.isConnected && ((_a2 = t2.hostConnected) == null ? void 0 : _a2.call(t2));
+  }
+  removeController(t2) {
+    var _a2;
+    (_a2 = this._$EO) == null ? void 0 : _a2.delete(t2);
+  }
+  _$E_() {
+    const t2 = /* @__PURE__ */ new Map(), s2 = this.constructor.elementProperties;
+    for (const i2 of s2.keys()) this.hasOwnProperty(i2) && (t2.set(i2, this[i2]), delete this[i2]);
+    t2.size > 0 && (this._$Ep = t2);
+  }
+  createRenderRoot() {
+    const t2 = this.shadowRoot ?? this.attachShadow(this.constructor.shadowRootOptions);
+    return S$1(t2, this.constructor.elementStyles), t2;
+  }
+  connectedCallback() {
+    var _a2;
+    this.renderRoot ?? (this.renderRoot = this.createRenderRoot()), this.enableUpdating(true), (_a2 = this._$EO) == null ? void 0 : _a2.forEach((t2) => {
+      var _a3;
+      return (_a3 = t2.hostConnected) == null ? void 0 : _a3.call(t2);
+    });
+  }
+  enableUpdating(t2) {
+  }
+  disconnectedCallback() {
+    var _a2;
+    (_a2 = this._$EO) == null ? void 0 : _a2.forEach((t2) => {
+      var _a3;
+      return (_a3 = t2.hostDisconnected) == null ? void 0 : _a3.call(t2);
+    });
+  }
+  attributeChangedCallback(t2, s2, i2) {
+    this._$AK(t2, i2);
+  }
+  _$ET(t2, s2) {
+    var _a2;
+    const i2 = this.constructor.elementProperties.get(t2), e2 = this.constructor._$Eu(t2, i2);
+    if (void 0 !== e2 && true === i2.reflect) {
+      const h2 = (void 0 !== ((_a2 = i2.converter) == null ? void 0 : _a2.toAttribute) ? i2.converter : u$1).toAttribute(s2, i2.type);
+      this._$Em = t2, null == h2 ? this.removeAttribute(e2) : this.setAttribute(e2, h2), this._$Em = null;
+    }
+  }
+  _$AK(t2, s2) {
+    var _a2, _b;
+    const i2 = this.constructor, e2 = i2._$Eh.get(t2);
+    if (void 0 !== e2 && this._$Em !== e2) {
+      const t3 = i2.getPropertyOptions(e2), h2 = "function" == typeof t3.converter ? { fromAttribute: t3.converter } : void 0 !== ((_a2 = t3.converter) == null ? void 0 : _a2.fromAttribute) ? t3.converter : u$1;
+      this._$Em = e2, this[e2] = h2.fromAttribute(s2, t3.type) ?? ((_b = this._$Ej) == null ? void 0 : _b.get(e2)) ?? null, this._$Em = null;
+    }
+  }
+  requestUpdate(t2, s2, i2) {
+    var _a2;
+    if (void 0 !== t2) {
+      const e2 = this.constructor, h2 = this[t2];
+      if (i2 ?? (i2 = e2.getPropertyOptions(t2)), !((i2.hasChanged ?? f$1)(h2, s2) || i2.useDefault && i2.reflect && h2 === ((_a2 = this._$Ej) == null ? void 0 : _a2.get(t2)) && !this.hasAttribute(e2._$Eu(t2, i2)))) return;
+      this.C(t2, s2, i2);
+    }
+    false === this.isUpdatePending && (this._$ES = this._$EP());
+  }
+  C(t2, s2, { useDefault: i2, reflect: e2, wrapped: h2 }, r2) {
+    i2 && !(this._$Ej ?? (this._$Ej = /* @__PURE__ */ new Map())).has(t2) && (this._$Ej.set(t2, r2 ?? s2 ?? this[t2]), true !== h2 || void 0 !== r2) || (this._$AL.has(t2) || (this.hasUpdated || i2 || (s2 = void 0), this._$AL.set(t2, s2)), true === e2 && this._$Em !== t2 && (this._$Eq ?? (this._$Eq = /* @__PURE__ */ new Set())).add(t2));
+  }
+  async _$EP() {
+    this.isUpdatePending = true;
+    try {
+      await this._$ES;
+    } catch (t3) {
+      Promise.reject(t3);
+    }
+    const t2 = this.scheduleUpdate();
+    return null != t2 && await t2, !this.isUpdatePending;
+  }
+  scheduleUpdate() {
+    return this.performUpdate();
+  }
+  performUpdate() {
+    var _a2;
+    if (!this.isUpdatePending) return;
+    if (!this.hasUpdated) {
+      if (this.renderRoot ?? (this.renderRoot = this.createRenderRoot()), this._$Ep) {
+        for (const [t4, s3] of this._$Ep) this[t4] = s3;
+        this._$Ep = void 0;
+      }
+      const t3 = this.constructor.elementProperties;
+      if (t3.size > 0) for (const [s3, i2] of t3) {
+        const { wrapped: t4 } = i2, e2 = this[s3];
+        true !== t4 || this._$AL.has(s3) || void 0 === e2 || this.C(s3, void 0, i2, e2);
+      }
+    }
+    let t2 = false;
+    const s2 = this._$AL;
+    try {
+      t2 = this.shouldUpdate(s2), t2 ? (this.willUpdate(s2), (_a2 = this._$EO) == null ? void 0 : _a2.forEach((t3) => {
+        var _a3;
+        return (_a3 = t3.hostUpdate) == null ? void 0 : _a3.call(t3);
+      }), this.update(s2)) : this._$EM();
+    } catch (s3) {
+      throw t2 = false, this._$EM(), s3;
+    }
+    t2 && this._$AE(s2);
+  }
+  willUpdate(t2) {
+  }
+  _$AE(t2) {
+    var _a2;
+    (_a2 = this._$EO) == null ? void 0 : _a2.forEach((t3) => {
+      var _a3;
+      return (_a3 = t3.hostUpdated) == null ? void 0 : _a3.call(t3);
+    }), this.hasUpdated || (this.hasUpdated = true, this.firstUpdated(t2)), this.updated(t2);
+  }
+  _$EM() {
+    this._$AL = /* @__PURE__ */ new Map(), this.isUpdatePending = false;
+  }
+  get updateComplete() {
+    return this.getUpdateComplete();
+  }
+  getUpdateComplete() {
+    return this._$ES;
+  }
+  shouldUpdate(t2) {
+    return true;
+  }
+  update(t2) {
+    this._$Eq && (this._$Eq = this._$Eq.forEach((t3) => this._$ET(t3, this[t3]))), this._$EM();
+  }
+  updated(t2) {
+  }
+  firstUpdated(t2) {
+  }
+};
+y$1.elementStyles = [], y$1.shadowRootOptions = { mode: "open" }, y$1[d$1("elementProperties")] = /* @__PURE__ */ new Map(), y$1[d$1("finalized")] = /* @__PURE__ */ new Map(), p$1 == null ? void 0 : p$1({ ReactiveElement: y$1 }), (a$1.reactiveElementVersions ?? (a$1.reactiveElementVersions = [])).push("2.1.0");
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+const t = globalThis, i$1 = t.trustedTypes, s$1 = i$1 ? i$1.createPolicy("lit-html", { createHTML: (t2) => t2 }) : void 0, e = "$lit$", h = `lit$${Math.random().toFixed(9).slice(2)}$`, o$1 = "?" + h, n2 = `<${o$1}>`, r = document, l = () => r.createComment(""), c = (t2) => null === t2 || "object" != typeof t2 && "function" != typeof t2, a = Array.isArray, u = (t2) => a(t2) || "function" == typeof (t2 == null ? void 0 : t2[Symbol.iterator]), d = "[ 	\n\f\r]", f = /<(?:(!--|\/[^a-zA-Z])|(\/?[a-zA-Z][^>\s]*)|(\/?$))/g, v = /-->/g, _ = />/g, m = RegExp(`>|${d}(?:([^\\s"'>=/]+)(${d}*=${d}*(?:[^ 	
+\f\r"'\`<>=]|("|')|))|$)`, "g"), p = /'/g, g = /"/g, $ = /^(?:script|style|textarea|title)$/i, y2 = (t2) => (i2, ...s2) => ({ _$litType$: t2, strings: i2, values: s2 }), x = y2(1), b = y2(2), T = Symbol.for("lit-noChange"), E = Symbol.for("lit-nothing"), A = /* @__PURE__ */ new WeakMap(), C = r.createTreeWalker(r, 129);
+function P(t2, i2) {
+  if (!a(t2) || !t2.hasOwnProperty("raw")) throw Error("invalid template strings array");
+  return void 0 !== s$1 ? s$1.createHTML(i2) : i2;
+}
+const V = (t2, i2) => {
+  const s2 = t2.length - 1, o2 = [];
+  let r2, l2 = 2 === i2 ? "<svg>" : 3 === i2 ? "<math>" : "", c2 = f;
+  for (let i3 = 0; i3 < s2; i3++) {
+    const s3 = t2[i3];
+    let a2, u2, d2 = -1, y3 = 0;
+    for (; y3 < s3.length && (c2.lastIndex = y3, u2 = c2.exec(s3), null !== u2); ) y3 = c2.lastIndex, c2 === f ? "!--" === u2[1] ? c2 = v : void 0 !== u2[1] ? c2 = _ : void 0 !== u2[2] ? ($.test(u2[2]) && (r2 = RegExp("</" + u2[2], "g")), c2 = m) : void 0 !== u2[3] && (c2 = m) : c2 === m ? ">" === u2[0] ? (c2 = r2 ?? f, d2 = -1) : void 0 === u2[1] ? d2 = -2 : (d2 = c2.lastIndex - u2[2].length, a2 = u2[1], c2 = void 0 === u2[3] ? m : '"' === u2[3] ? g : p) : c2 === g || c2 === p ? c2 = m : c2 === v || c2 === _ ? c2 = f : (c2 = m, r2 = void 0);
+    const x2 = c2 === m && t2[i3 + 1].startsWith("/>") ? " " : "";
+    l2 += c2 === f ? s3 + n2 : d2 >= 0 ? (o2.push(a2), s3.slice(0, d2) + e + s3.slice(d2) + h + x2) : s3 + h + (-2 === d2 ? i3 : x2);
+  }
+  return [P(t2, l2 + (t2[s2] || "<?>") + (2 === i2 ? "</svg>" : 3 === i2 ? "</math>" : "")), o2];
+};
+class N {
+  constructor({ strings: t2, _$litType$: s2 }, n3) {
+    let r2;
+    this.parts = [];
+    let c2 = 0, a2 = 0;
+    const u2 = t2.length - 1, d2 = this.parts, [f2, v2] = V(t2, s2);
+    if (this.el = N.createElement(f2, n3), C.currentNode = this.el.content, 2 === s2 || 3 === s2) {
+      const t3 = this.el.content.firstChild;
+      t3.replaceWith(...t3.childNodes);
+    }
+    for (; null !== (r2 = C.nextNode()) && d2.length < u2; ) {
+      if (1 === r2.nodeType) {
+        if (r2.hasAttributes()) for (const t3 of r2.getAttributeNames()) if (t3.endsWith(e)) {
+          const i2 = v2[a2++], s3 = r2.getAttribute(t3).split(h), e2 = /([.?@])?(.*)/.exec(i2);
+          d2.push({ type: 1, index: c2, name: e2[2], strings: s3, ctor: "." === e2[1] ? H : "?" === e2[1] ? I : "@" === e2[1] ? L : k }), r2.removeAttribute(t3);
+        } else t3.startsWith(h) && (d2.push({ type: 6, index: c2 }), r2.removeAttribute(t3));
+        if ($.test(r2.tagName)) {
+          const t3 = r2.textContent.split(h), s3 = t3.length - 1;
+          if (s3 > 0) {
+            r2.textContent = i$1 ? i$1.emptyScript : "";
+            for (let i2 = 0; i2 < s3; i2++) r2.append(t3[i2], l()), C.nextNode(), d2.push({ type: 2, index: ++c2 });
+            r2.append(t3[s3], l());
+          }
+        }
+      } else if (8 === r2.nodeType) if (r2.data === o$1) d2.push({ type: 2, index: c2 });
+      else {
+        let t3 = -1;
+        for (; -1 !== (t3 = r2.data.indexOf(h, t3 + 1)); ) d2.push({ type: 7, index: c2 }), t3 += h.length - 1;
+      }
+      c2++;
+    }
+  }
+  static createElement(t2, i2) {
+    const s2 = r.createElement("template");
+    return s2.innerHTML = t2, s2;
+  }
+}
+function S(t2, i2, s2 = t2, e2) {
+  var _a2, _b;
+  if (i2 === T) return i2;
+  let h2 = void 0 !== e2 ? (_a2 = s2._$Co) == null ? void 0 : _a2[e2] : s2._$Cl;
+  const o2 = c(i2) ? void 0 : i2._$litDirective$;
+  return (h2 == null ? void 0 : h2.constructor) !== o2 && ((_b = h2 == null ? void 0 : h2._$AO) == null ? void 0 : _b.call(h2, false), void 0 === o2 ? h2 = void 0 : (h2 = new o2(t2), h2._$AT(t2, s2, e2)), void 0 !== e2 ? (s2._$Co ?? (s2._$Co = []))[e2] = h2 : s2._$Cl = h2), void 0 !== h2 && (i2 = S(t2, h2._$AS(t2, i2.values), h2, e2)), i2;
+}
+class M {
+  constructor(t2, i2) {
+    this._$AV = [], this._$AN = void 0, this._$AD = t2, this._$AM = i2;
+  }
+  get parentNode() {
+    return this._$AM.parentNode;
+  }
+  get _$AU() {
+    return this._$AM._$AU;
+  }
+  u(t2) {
+    const { el: { content: i2 }, parts: s2 } = this._$AD, e2 = ((t2 == null ? void 0 : t2.creationScope) ?? r).importNode(i2, true);
+    C.currentNode = e2;
+    let h2 = C.nextNode(), o2 = 0, n3 = 0, l2 = s2[0];
+    for (; void 0 !== l2; ) {
+      if (o2 === l2.index) {
+        let i3;
+        2 === l2.type ? i3 = new R(h2, h2.nextSibling, this, t2) : 1 === l2.type ? i3 = new l2.ctor(h2, l2.name, l2.strings, this, t2) : 6 === l2.type && (i3 = new z(h2, this, t2)), this._$AV.push(i3), l2 = s2[++n3];
+      }
+      o2 !== (l2 == null ? void 0 : l2.index) && (h2 = C.nextNode(), o2++);
+    }
+    return C.currentNode = r, e2;
+  }
+  p(t2) {
+    let i2 = 0;
+    for (const s2 of this._$AV) void 0 !== s2 && (void 0 !== s2.strings ? (s2._$AI(t2, s2, i2), i2 += s2.strings.length - 2) : s2._$AI(t2[i2])), i2++;
+  }
+}
+class R {
+  get _$AU() {
+    var _a2;
+    return ((_a2 = this._$AM) == null ? void 0 : _a2._$AU) ?? this._$Cv;
+  }
+  constructor(t2, i2, s2, e2) {
+    this.type = 2, this._$AH = E, this._$AN = void 0, this._$AA = t2, this._$AB = i2, this._$AM = s2, this.options = e2, this._$Cv = (e2 == null ? void 0 : e2.isConnected) ?? true;
+  }
+  get parentNode() {
+    let t2 = this._$AA.parentNode;
+    const i2 = this._$AM;
+    return void 0 !== i2 && 11 === (t2 == null ? void 0 : t2.nodeType) && (t2 = i2.parentNode), t2;
+  }
+  get startNode() {
+    return this._$AA;
+  }
+  get endNode() {
+    return this._$AB;
+  }
+  _$AI(t2, i2 = this) {
+    t2 = S(this, t2, i2), c(t2) ? t2 === E || null == t2 || "" === t2 ? (this._$AH !== E && this._$AR(), this._$AH = E) : t2 !== this._$AH && t2 !== T && this._(t2) : void 0 !== t2._$litType$ ? this.$(t2) : void 0 !== t2.nodeType ? this.T(t2) : u(t2) ? this.k(t2) : this._(t2);
+  }
+  O(t2) {
+    return this._$AA.parentNode.insertBefore(t2, this._$AB);
+  }
+  T(t2) {
+    this._$AH !== t2 && (this._$AR(), this._$AH = this.O(t2));
+  }
+  _(t2) {
+    this._$AH !== E && c(this._$AH) ? this._$AA.nextSibling.data = t2 : this.T(r.createTextNode(t2)), this._$AH = t2;
+  }
+  $(t2) {
+    var _a2;
+    const { values: i2, _$litType$: s2 } = t2, e2 = "number" == typeof s2 ? this._$AC(t2) : (void 0 === s2.el && (s2.el = N.createElement(P(s2.h, s2.h[0]), this.options)), s2);
+    if (((_a2 = this._$AH) == null ? void 0 : _a2._$AD) === e2) this._$AH.p(i2);
+    else {
+      const t3 = new M(e2, this), s3 = t3.u(this.options);
+      t3.p(i2), this.T(s3), this._$AH = t3;
+    }
+  }
+  _$AC(t2) {
+    let i2 = A.get(t2.strings);
+    return void 0 === i2 && A.set(t2.strings, i2 = new N(t2)), i2;
+  }
+  k(t2) {
+    a(this._$AH) || (this._$AH = [], this._$AR());
+    const i2 = this._$AH;
+    let s2, e2 = 0;
+    for (const h2 of t2) e2 === i2.length ? i2.push(s2 = new R(this.O(l()), this.O(l()), this, this.options)) : s2 = i2[e2], s2._$AI(h2), e2++;
+    e2 < i2.length && (this._$AR(s2 && s2._$AB.nextSibling, e2), i2.length = e2);
+  }
+  _$AR(t2 = this._$AA.nextSibling, i2) {
+    var _a2;
+    for ((_a2 = this._$AP) == null ? void 0 : _a2.call(this, false, true, i2); t2 && t2 !== this._$AB; ) {
+      const i3 = t2.nextSibling;
+      t2.remove(), t2 = i3;
+    }
+  }
+  setConnected(t2) {
+    var _a2;
+    void 0 === this._$AM && (this._$Cv = t2, (_a2 = this._$AP) == null ? void 0 : _a2.call(this, t2));
+  }
+}
+class k {
+  get tagName() {
+    return this.element.tagName;
+  }
+  get _$AU() {
+    return this._$AM._$AU;
+  }
+  constructor(t2, i2, s2, e2, h2) {
+    this.type = 1, this._$AH = E, this._$AN = void 0, this.element = t2, this.name = i2, this._$AM = e2, this.options = h2, s2.length > 2 || "" !== s2[0] || "" !== s2[1] ? (this._$AH = Array(s2.length - 1).fill(new String()), this.strings = s2) : this._$AH = E;
+  }
+  _$AI(t2, i2 = this, s2, e2) {
+    const h2 = this.strings;
+    let o2 = false;
+    if (void 0 === h2) t2 = S(this, t2, i2, 0), o2 = !c(t2) || t2 !== this._$AH && t2 !== T, o2 && (this._$AH = t2);
+    else {
+      const e3 = t2;
+      let n3, r2;
+      for (t2 = h2[0], n3 = 0; n3 < h2.length - 1; n3++) r2 = S(this, e3[s2 + n3], i2, n3), r2 === T && (r2 = this._$AH[n3]), o2 || (o2 = !c(r2) || r2 !== this._$AH[n3]), r2 === E ? t2 = E : t2 !== E && (t2 += (r2 ?? "") + h2[n3 + 1]), this._$AH[n3] = r2;
+    }
+    o2 && !e2 && this.j(t2);
+  }
+  j(t2) {
+    t2 === E ? this.element.removeAttribute(this.name) : this.element.setAttribute(this.name, t2 ?? "");
+  }
+}
+class H extends k {
+  constructor() {
+    super(...arguments), this.type = 3;
+  }
+  j(t2) {
+    this.element[this.name] = t2 === E ? void 0 : t2;
+  }
+}
+class I extends k {
+  constructor() {
+    super(...arguments), this.type = 4;
+  }
+  j(t2) {
+    this.element.toggleAttribute(this.name, !!t2 && t2 !== E);
+  }
+}
+class L extends k {
+  constructor(t2, i2, s2, e2, h2) {
+    super(t2, i2, s2, e2, h2), this.type = 5;
+  }
+  _$AI(t2, i2 = this) {
+    if ((t2 = S(this, t2, i2, 0) ?? E) === T) return;
+    const s2 = this._$AH, e2 = t2 === E && s2 !== E || t2.capture !== s2.capture || t2.once !== s2.once || t2.passive !== s2.passive, h2 = t2 !== E && (s2 === E || e2);
+    e2 && this.element.removeEventListener(this.name, this, s2), h2 && this.element.addEventListener(this.name, this, t2), this._$AH = t2;
+  }
+  handleEvent(t2) {
+    var _a2;
+    "function" == typeof this._$AH ? this._$AH.call(((_a2 = this.options) == null ? void 0 : _a2.host) ?? this.element, t2) : this._$AH.handleEvent(t2);
+  }
+}
+class z {
+  constructor(t2, i2, s2) {
+    this.element = t2, this.type = 6, this._$AN = void 0, this._$AM = i2, this.options = s2;
+  }
+  get _$AU() {
+    return this._$AM._$AU;
+  }
+  _$AI(t2) {
+    S(this, t2);
+  }
+}
+const j = t.litHtmlPolyfillSupport;
+j == null ? void 0 : j(N, R), (t.litHtmlVersions ?? (t.litHtmlVersions = [])).push("3.3.0");
+const B = (t2, i2, s2) => {
+  const e2 = (s2 == null ? void 0 : s2.renderBefore) ?? i2;
+  let h2 = e2._$litPart$;
+  if (void 0 === h2) {
+    const t3 = (s2 == null ? void 0 : s2.renderBefore) ?? null;
+    e2._$litPart$ = h2 = new R(i2.insertBefore(l(), t3), t3, void 0, s2 ?? {});
+  }
+  return h2._$AI(t2), h2;
+};
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+const s = globalThis;
+class i extends y$1 {
+  constructor() {
+    super(...arguments), this.renderOptions = { host: this }, this._$Do = void 0;
+  }
+  createRenderRoot() {
+    var _a2;
+    const t2 = super.createRenderRoot();
+    return (_a2 = this.renderOptions).renderBefore ?? (_a2.renderBefore = t2.firstChild), t2;
+  }
+  update(t2) {
+    const r2 = this.render();
+    this.hasUpdated || (this.renderOptions.isConnected = this.isConnected), super.update(t2), this._$Do = B(r2, this.renderRoot, this.renderOptions);
+  }
+  connectedCallback() {
+    var _a2;
+    super.connectedCallback(), (_a2 = this._$Do) == null ? void 0 : _a2.setConnected(true);
+  }
+  disconnectedCallback() {
+    var _a2;
+    super.disconnectedCallback(), (_a2 = this._$Do) == null ? void 0 : _a2.setConnected(false);
+  }
+  render() {
+    return T;
+  }
+}
+i._$litElement$ = true, i["finalized"] = true, (_a = s.litElementHydrateSupport) == null ? void 0 : _a.call(s, { LitElement: i });
+const o = s.litElementPolyfillSupport;
+o == null ? void 0 : o({ LitElement: i });
+(s.litElementVersions ?? (s.litElementVersions = [])).push("4.2.0");
+let themeTag = void 0;
+let darkModeTag = void 0;
+let lightModeTag = void 0;
+function initializeTheming(themeVariables, themeMode) {
+  themeTag = document.createElement("style");
+  darkModeTag = document.createElement("style");
+  lightModeTag = document.createElement("style");
+  themeTag.textContent = createRootStyles(themeVariables).core.cssText;
+  darkModeTag.textContent = createRootStyles(themeVariables).dark.cssText;
+  lightModeTag.textContent = createRootStyles(themeVariables).light.cssText;
+  document.head.appendChild(themeTag);
+  document.head.appendChild(darkModeTag);
+  document.head.appendChild(lightModeTag);
+  setColorTheme(themeMode);
+}
+function setColorTheme(themeMode) {
+  if (darkModeTag && lightModeTag) {
+    if (themeMode === "light") {
+      darkModeTag.removeAttribute("media");
+      lightModeTag.media = "enabled";
+    } else {
+      lightModeTag.removeAttribute("media");
+      darkModeTag.media = "enabled";
+    }
+  }
+}
+function setThemeVariables(themeVariables) {
+  if (themeTag && darkModeTag && lightModeTag) {
+    themeTag.textContent = createRootStyles(themeVariables).core.cssText;
+    darkModeTag.textContent = createRootStyles(themeVariables).dark.cssText;
+    lightModeTag.textContent = createRootStyles(themeVariables).light.cssText;
+  }
+}
+function createRootStyles(themeVariables) {
+  return {
+    core: i$3`
+      @import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap');
+      @keyframes w3m-shake {
+        0% {
+          transform: scale(1) rotate(0deg);
+        }
+        20% {
+          transform: scale(1) rotate(-1deg);
+        }
+        40% {
+          transform: scale(1) rotate(1.5deg);
+        }
+        60% {
+          transform: scale(1) rotate(-1.5deg);
+        }
+        80% {
+          transform: scale(1) rotate(1deg);
+        }
+        100% {
+          transform: scale(1) rotate(0deg);
+        }
+      }
+      @keyframes w3m-iframe-fade-out {
+        0% {
+          opacity: 1;
+        }
+        100% {
+          opacity: 0;
+        }
+      }
+      @keyframes w3m-iframe-zoom-in {
+        0% {
+          transform: translateY(50px);
+          opacity: 0;
+        }
+        100% {
+          transform: translateY(0px);
+          opacity: 1;
+        }
+      }
+      @keyframes w3m-iframe-zoom-in-mobile {
+        0% {
+          transform: scale(0.95);
+          opacity: 0;
+        }
+        100% {
+          transform: scale(1);
+          opacity: 1;
+        }
+      }
+      :root {
+        --w3m-modal-width: 360px;
+        --w3m-color-mix-strength: ${r$2((themeVariables == null ? void 0 : themeVariables["--w3m-color-mix-strength"]) ? `${themeVariables["--w3m-color-mix-strength"]}%` : "0%")};
+        --w3m-font-family: ${r$2((themeVariables == null ? void 0 : themeVariables["--w3m-font-family"]) || "Inter, Segoe UI, Roboto, Oxygen, Ubuntu, Cantarell, Fira Sans, Droid Sans, Helvetica Neue, sans-serif;")};
+        --w3m-font-size-master: ${r$2((themeVariables == null ? void 0 : themeVariables["--w3m-font-size-master"]) || "10px")};
+        --w3m-border-radius-master: ${r$2((themeVariables == null ? void 0 : themeVariables["--w3m-border-radius-master"]) || "4px")};
+        --w3m-z-index: ${r$2((themeVariables == null ? void 0 : themeVariables["--w3m-z-index"]) || 999)};
+
+        --wui-font-family: var(--w3m-font-family);
+
+        --wui-font-size-mini: calc(var(--w3m-font-size-master) * 0.8);
+        --wui-font-size-micro: var(--w3m-font-size-master);
+        --wui-font-size-tiny: calc(var(--w3m-font-size-master) * 1.2);
+        --wui-font-size-small: calc(var(--w3m-font-size-master) * 1.4);
+        --wui-font-size-paragraph: calc(var(--w3m-font-size-master) * 1.6);
+        --wui-font-size-medium: calc(var(--w3m-font-size-master) * 1.8);
+        --wui-font-size-large: calc(var(--w3m-font-size-master) * 2);
+        --wui-font-size-title-6: calc(var(--w3m-font-size-master) * 2.2);
+        --wui-font-size-medium-title: calc(var(--w3m-font-size-master) * 2.4);
+        --wui-font-size-2xl: calc(var(--w3m-font-size-master) * 4);
+
+        --wui-border-radius-5xs: var(--w3m-border-radius-master);
+        --wui-border-radius-4xs: calc(var(--w3m-border-radius-master) * 1.5);
+        --wui-border-radius-3xs: calc(var(--w3m-border-radius-master) * 2);
+        --wui-border-radius-xxs: calc(var(--w3m-border-radius-master) * 3);
+        --wui-border-radius-xs: calc(var(--w3m-border-radius-master) * 4);
+        --wui-border-radius-s: calc(var(--w3m-border-radius-master) * 5);
+        --wui-border-radius-m: calc(var(--w3m-border-radius-master) * 7);
+        --wui-border-radius-l: calc(var(--w3m-border-radius-master) * 9);
+        --wui-border-radius-3xl: calc(var(--w3m-border-radius-master) * 20);
+
+        --wui-font-weight-light: 400;
+        --wui-font-weight-regular: 500;
+        --wui-font-weight-medium: 600;
+        --wui-font-weight-bold: 700;
+
+        --wui-letter-spacing-2xl: -1.6px;
+        --wui-letter-spacing-medium-title: -0.96px;
+        --wui-letter-spacing-title-6: -0.88px;
+        --wui-letter-spacing-large: -0.8px;
+        --wui-letter-spacing-medium: -0.72px;
+        --wui-letter-spacing-paragraph: -0.64px;
+        --wui-letter-spacing-small: -0.56px;
+        --wui-letter-spacing-tiny: -0.48px;
+        --wui-letter-spacing-micro: -0.2px;
+        --wui-letter-spacing-mini: -0.16px;
+
+        --wui-spacing-0: 0px;
+        --wui-spacing-4xs: 2px;
+        --wui-spacing-3xs: 4px;
+        --wui-spacing-xxs: 6px;
+        --wui-spacing-2xs: 7px;
+        --wui-spacing-xs: 8px;
+        --wui-spacing-1xs: 10px;
+        --wui-spacing-s: 12px;
+        --wui-spacing-m: 14px;
+        --wui-spacing-l: 16px;
+        --wui-spacing-2l: 18px;
+        --wui-spacing-xl: 20px;
+        --wui-spacing-xxl: 24px;
+        --wui-spacing-2xl: 32px;
+        --wui-spacing-3xl: 40px;
+        --wui-spacing-4xl: 90px;
+        --wui-spacing-5xl: 95px;
+
+        --wui-icon-box-size-xxs: 14px;
+        --wui-icon-box-size-xs: 20px;
+        --wui-icon-box-size-sm: 24px;
+        --wui-icon-box-size-md: 32px;
+        --wui-icon-box-size-mdl: 36px;
+        --wui-icon-box-size-lg: 40px;
+        --wui-icon-box-size-2lg: 48px;
+        --wui-icon-box-size-xl: 64px;
+
+        --wui-icon-size-inherit: inherit;
+        --wui-icon-size-xxs: 10px;
+        --wui-icon-size-xs: 12px;
+        --wui-icon-size-sm: 14px;
+        --wui-icon-size-md: 16px;
+        --wui-icon-size-mdl: 18px;
+        --wui-icon-size-lg: 20px;
+        --wui-icon-size-xl: 24px;
+        --wui-icon-size-xxl: 28px;
+
+        --wui-wallet-image-size-inherit: inherit;
+        --wui-wallet-image-size-sm: 40px;
+        --wui-wallet-image-size-md: 56px;
+        --wui-wallet-image-size-lg: 80px;
+
+        --wui-visual-size-size-inherit: inherit;
+        --wui-visual-size-sm: 40px;
+        --wui-visual-size-md: 55px;
+        --wui-visual-size-lg: 80px;
+
+        --wui-box-size-md: 100px;
+        --wui-box-size-lg: 120px;
+
+        --wui-ease-out-power-2: cubic-bezier(0, 0, 0.22, 1);
+        --wui-ease-out-power-1: cubic-bezier(0, 0, 0.55, 1);
+
+        --wui-ease-in-power-3: cubic-bezier(0.66, 0, 1, 1);
+        --wui-ease-in-power-2: cubic-bezier(0.45, 0, 1, 1);
+        --wui-ease-in-power-1: cubic-bezier(0.3, 0, 1, 1);
+
+        --wui-ease-inout-power-1: cubic-bezier(0.45, 0, 0.55, 1);
+
+        --wui-duration-lg: 200ms;
+        --wui-duration-md: 125ms;
+        --wui-duration-sm: 75ms;
+
+        --wui-path-network-sm: path(
+          'M15.4 2.1a5.21 5.21 0 0 1 5.2 0l11.61 6.7a5.21 5.21 0 0 1 2.61 4.52v13.4c0 1.87-1 3.59-2.6 4.52l-11.61 6.7c-1.62.93-3.6.93-5.22 0l-11.6-6.7a5.21 5.21 0 0 1-2.61-4.51v-13.4c0-1.87 1-3.6 2.6-4.52L15.4 2.1Z'
+        );
+
+        --wui-path-network-md: path(
+          'M43.4605 10.7248L28.0485 1.61089C25.5438 0.129705 22.4562 0.129705 19.9515 1.61088L4.53951 10.7248C2.03626 12.2051 0.5 14.9365 0.5 17.886V36.1139C0.5 39.0635 2.03626 41.7949 4.53951 43.2752L19.9515 52.3891C22.4562 53.8703 25.5438 53.8703 28.0485 52.3891L43.4605 43.2752C45.9637 41.7949 47.5 39.0635 47.5 36.114V17.8861C47.5 14.9365 45.9637 12.2051 43.4605 10.7248Z'
+        );
+
+        --wui-path-network-lg: path(
+          'M78.3244 18.926L50.1808 2.45078C45.7376 -0.150261 40.2624 -0.150262 35.8192 2.45078L7.6756 18.926C3.23322 21.5266 0.5 26.3301 0.5 31.5248V64.4752C0.5 69.6699 3.23322 74.4734 7.6756 77.074L35.8192 93.5492C40.2624 96.1503 45.7376 96.1503 50.1808 93.5492L78.3244 77.074C82.7668 74.4734 85.5 69.6699 85.5 64.4752V31.5248C85.5 26.3301 82.7668 21.5266 78.3244 18.926Z'
+        );
+
+        --wui-width-network-sm: 36px;
+        --wui-width-network-md: 48px;
+        --wui-width-network-lg: 86px;
+
+        --wui-height-network-sm: 40px;
+        --wui-height-network-md: 54px;
+        --wui-height-network-lg: 96px;
+
+        --wui-icon-size-network-xs: 12px;
+        --wui-icon-size-network-sm: 16px;
+        --wui-icon-size-network-md: 24px;
+        --wui-icon-size-network-lg: 42px;
+
+        --wui-color-inherit: inherit;
+
+        --wui-color-inverse-100: #fff;
+        --wui-color-inverse-000: #000;
+
+        --wui-cover: rgba(20, 20, 20, 0.8);
+
+        --wui-color-modal-bg: var(--wui-color-modal-bg-base);
+
+        --wui-color-accent-100: var(--wui-color-accent-base-100);
+        --wui-color-accent-090: var(--wui-color-accent-base-090);
+        --wui-color-accent-080: var(--wui-color-accent-base-080);
+
+        --wui-color-success-100: var(--wui-color-success-base-100);
+        --wui-color-success-125: var(--wui-color-success-base-125);
+
+        --wui-color-warning-100: var(--wui-color-warning-base-100);
+
+        --wui-color-error-100: var(--wui-color-error-base-100);
+        --wui-color-error-125: var(--wui-color-error-base-125);
+
+        --wui-color-blue-100: var(--wui-color-blue-base-100);
+        --wui-color-blue-90: var(--wui-color-blue-base-90);
+
+        --wui-icon-box-bg-error-100: var(--wui-icon-box-bg-error-base-100);
+        --wui-icon-box-bg-blue-100: var(--wui-icon-box-bg-blue-base-100);
+        --wui-icon-box-bg-success-100: var(--wui-icon-box-bg-success-base-100);
+        --wui-icon-box-bg-inverse-100: var(--wui-icon-box-bg-inverse-base-100);
+
+        --wui-all-wallets-bg-100: var(--wui-all-wallets-bg-100);
+
+        --wui-avatar-border: var(--wui-avatar-border-base);
+
+        --wui-thumbnail-border: var(--wui-thumbnail-border-base);
+
+        --wui-wallet-button-bg: var(--wui-wallet-button-bg-base);
+
+        --wui-box-shadow-blue: var(--wui-color-accent-glass-020);
+      }
+
+      @supports (background: color-mix(in srgb, white 50%, black)) {
+        :root {
+          --wui-color-modal-bg: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-color-modal-bg-base)
+          );
+
+          --wui-box-shadow-blue: color-mix(in srgb, var(--wui-color-accent-100) 20%, transparent);
+
+          --wui-color-accent-100: color-mix(
+            in srgb,
+            var(--wui-color-accent-base-100) 100%,
+            transparent
+          );
+          --wui-color-accent-090: color-mix(
+            in srgb,
+            var(--wui-color-accent-base-100) 90%,
+            transparent
+          );
+          --wui-color-accent-080: color-mix(
+            in srgb,
+            var(--wui-color-accent-base-100) 80%,
+            transparent
+          );
+          --wui-color-accent-glass-090: color-mix(
+            in srgb,
+            var(--wui-color-accent-base-100) 90%,
+            transparent
+          );
+          --wui-color-accent-glass-080: color-mix(
+            in srgb,
+            var(--wui-color-accent-base-100) 80%,
+            transparent
+          );
+          --wui-color-accent-glass-020: color-mix(
+            in srgb,
+            var(--wui-color-accent-base-100) 20%,
+            transparent
+          );
+          --wui-color-accent-glass-015: color-mix(
+            in srgb,
+            var(--wui-color-accent-base-100) 15%,
+            transparent
+          );
+          --wui-color-accent-glass-010: color-mix(
+            in srgb,
+            var(--wui-color-accent-base-100) 10%,
+            transparent
+          );
+          --wui-color-accent-glass-005: color-mix(
+            in srgb,
+            var(--wui-color-accent-base-100) 5%,
+            transparent
+          );
+          --wui-color-accent-002: color-mix(
+            in srgb,
+            var(--wui-color-accent-base-100) 2%,
+            transparent
+          );
+
+          --wui-color-fg-100: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-color-fg-100)
+          );
+          --wui-color-fg-125: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-color-fg-125)
+          );
+          --wui-color-fg-150: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-color-fg-150)
+          );
+          --wui-color-fg-175: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-color-fg-175)
+          );
+          --wui-color-fg-200: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-color-fg-200)
+          );
+          --wui-color-fg-225: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-color-fg-225)
+          );
+          --wui-color-fg-250: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-color-fg-250)
+          );
+          --wui-color-fg-275: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-color-fg-275)
+          );
+          --wui-color-fg-300: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-color-fg-300)
+          );
+          --wui-color-fg-325: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-color-fg-325)
+          );
+          --wui-color-fg-350: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-color-fg-350)
+          );
+
+          --wui-color-bg-100: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-color-bg-100)
+          );
+          --wui-color-bg-125: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-color-bg-125)
+          );
+          --wui-color-bg-150: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-color-bg-150)
+          );
+          --wui-color-bg-175: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-color-bg-175)
+          );
+          --wui-color-bg-200: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-color-bg-200)
+          );
+          --wui-color-bg-225: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-color-bg-225)
+          );
+          --wui-color-bg-250: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-color-bg-250)
+          );
+          --wui-color-bg-275: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-color-bg-275)
+          );
+          --wui-color-bg-300: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-color-bg-300)
+          );
+          --wui-color-bg-325: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-color-bg-325)
+          );
+          --wui-color-bg-350: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-color-bg-350)
+          );
+
+          --wui-color-success-100: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-color-success-base-100)
+          );
+          --wui-color-success-125: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-color-success-base-125)
+          );
+
+          --wui-color-warning-100: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-color-warning-base-100)
+          );
+
+          --wui-color-error-100: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-color-error-base-100)
+          );
+          --wui-color-blue-100: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-color-blue-base-100)
+          );
+          --wui-color-blue-90: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-color-blue-base-90)
+          );
+          --wui-color-error-125: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-color-error-base-125)
+          );
+
+          --wui-icon-box-bg-error-100: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-icon-box-bg-error-base-100)
+          );
+          --wui-icon-box-bg-accent-100: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-icon-box-bg-blue-base-100)
+          );
+          --wui-icon-box-bg-success-100: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-icon-box-bg-success-base-100)
+          );
+          --wui-icon-box-bg-inverse-100: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-icon-box-bg-inverse-base-100)
+          );
+
+          --wui-all-wallets-bg-100: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-all-wallets-bg-100)
+          );
+
+          --wui-avatar-border: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-avatar-border-base)
+          );
+
+          --wui-thumbnail-border: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-thumbnail-border-base)
+          );
+
+          --wui-wallet-button-bg: color-mix(
+            in srgb,
+            var(--w3m-color-mix) var(--w3m-color-mix-strength),
+            var(--wui-wallet-button-bg-base)
+          );
+        }
+      }
+    `,
+    light: i$3`
+      :root {
+        --w3m-color-mix: ${r$2((themeVariables == null ? void 0 : themeVariables["--w3m-color-mix"]) || "#fff")};
+        --w3m-accent: ${r$2(getW3mThemeVariables(themeVariables, "dark")["--w3m-accent"])};
+        --w3m-default: #fff;
+
+        --wui-color-modal-bg-base: ${r$2(getW3mThemeVariables(themeVariables, "dark")["--w3m-background"])};
+        --wui-color-accent-base-100: var(--w3m-accent);
+
+        --wui-color-blueberry-100: hsla(230, 100%, 67%, 1);
+        --wui-color-blueberry-090: hsla(231, 76%, 61%, 1);
+        --wui-color-blueberry-080: hsla(230, 59%, 55%, 1);
+        --wui-color-blueberry-050: hsla(231, 100%, 70%, 0.1);
+
+        --wui-color-fg-100: #e4e7e7;
+        --wui-color-fg-125: #d0d5d5;
+        --wui-color-fg-150: #a8b1b1;
+        --wui-color-fg-175: #a8b0b0;
+        --wui-color-fg-200: #949e9e;
+        --wui-color-fg-225: #868f8f;
+        --wui-color-fg-250: #788080;
+        --wui-color-fg-275: #788181;
+        --wui-color-fg-300: #6e7777;
+        --wui-color-fg-325: #9a9a9a;
+        --wui-color-fg-350: #363636;
+
+        --wui-color-bg-100: #141414;
+        --wui-color-bg-125: #191a1a;
+        --wui-color-bg-150: #1e1f1f;
+        --wui-color-bg-175: #222525;
+        --wui-color-bg-200: #272a2a;
+        --wui-color-bg-225: #2c3030;
+        --wui-color-bg-250: #313535;
+        --wui-color-bg-275: #363b3b;
+        --wui-color-bg-300: #3b4040;
+        --wui-color-bg-325: #252525;
+        --wui-color-bg-350: #ffffff;
+
+        --wui-color-success-base-100: #26d962;
+        --wui-color-success-base-125: #30a46b;
+
+        --wui-color-warning-base-100: #f3a13f;
+
+        --wui-color-error-base-100: #f25a67;
+        --wui-color-error-base-125: #df4a34;
+
+        --wui-color-blue-base-100: rgba(102, 125, 255, 1);
+        --wui-color-blue-base-90: rgba(102, 125, 255, 0.9);
+
+        --wui-color-success-glass-001: rgba(38, 217, 98, 0.01);
+        --wui-color-success-glass-002: rgba(38, 217, 98, 0.02);
+        --wui-color-success-glass-005: rgba(38, 217, 98, 0.05);
+        --wui-color-success-glass-010: rgba(38, 217, 98, 0.1);
+        --wui-color-success-glass-015: rgba(38, 217, 98, 0.15);
+        --wui-color-success-glass-020: rgba(38, 217, 98, 0.2);
+        --wui-color-success-glass-025: rgba(38, 217, 98, 0.25);
+        --wui-color-success-glass-030: rgba(38, 217, 98, 0.3);
+        --wui-color-success-glass-060: rgba(38, 217, 98, 0.6);
+        --wui-color-success-glass-080: rgba(38, 217, 98, 0.8);
+
+        --wui-color-success-glass-reown-020: rgba(48, 164, 107, 0.2);
+
+        --wui-color-warning-glass-reown-020: rgba(243, 161, 63, 0.2);
+
+        --wui-color-error-glass-001: rgba(242, 90, 103, 0.01);
+        --wui-color-error-glass-002: rgba(242, 90, 103, 0.02);
+        --wui-color-error-glass-005: rgba(242, 90, 103, 0.05);
+        --wui-color-error-glass-010: rgba(242, 90, 103, 0.1);
+        --wui-color-error-glass-015: rgba(242, 90, 103, 0.15);
+        --wui-color-error-glass-020: rgba(242, 90, 103, 0.2);
+        --wui-color-error-glass-025: rgba(242, 90, 103, 0.25);
+        --wui-color-error-glass-030: rgba(242, 90, 103, 0.3);
+        --wui-color-error-glass-060: rgba(242, 90, 103, 0.6);
+        --wui-color-error-glass-080: rgba(242, 90, 103, 0.8);
+
+        --wui-color-error-glass-reown-020: rgba(223, 74, 52, 0.2);
+
+        --wui-color-gray-glass-001: rgba(255, 255, 255, 0.01);
+        --wui-color-gray-glass-002: rgba(255, 255, 255, 0.02);
+        --wui-color-gray-glass-005: rgba(255, 255, 255, 0.05);
+        --wui-color-gray-glass-010: rgba(255, 255, 255, 0.1);
+        --wui-color-gray-glass-015: rgba(255, 255, 255, 0.15);
+        --wui-color-gray-glass-020: rgba(255, 255, 255, 0.2);
+        --wui-color-gray-glass-025: rgba(255, 255, 255, 0.25);
+        --wui-color-gray-glass-030: rgba(255, 255, 255, 0.3);
+        --wui-color-gray-glass-060: rgba(255, 255, 255, 0.6);
+        --wui-color-gray-glass-080: rgba(255, 255, 255, 0.8);
+        --wui-color-gray-glass-090: rgba(255, 255, 255, 0.9);
+
+        --wui-color-dark-glass-100: rgba(42, 42, 42, 1);
+
+        --wui-icon-box-bg-error-base-100: #3c2426;
+        --wui-icon-box-bg-blue-base-100: #20303f;
+        --wui-icon-box-bg-success-base-100: #1f3a28;
+        --wui-icon-box-bg-inverse-base-100: #243240;
+
+        --wui-all-wallets-bg-100: #222b35;
+
+        --wui-avatar-border-base: #252525;
+
+        --wui-thumbnail-border-base: #252525;
+
+        --wui-wallet-button-bg-base: var(--wui-color-bg-125);
+
+        --w3m-card-embedded-shadow-color: rgb(17 17 18 / 25%);
+      }
+    `,
+    dark: i$3`
+      :root {
+        --w3m-color-mix: ${r$2((themeVariables == null ? void 0 : themeVariables["--w3m-color-mix"]) || "#000")};
+        --w3m-accent: ${r$2(getW3mThemeVariables(themeVariables, "light")["--w3m-accent"])};
+        --w3m-default: #000;
+
+        --wui-color-modal-bg-base: ${r$2(getW3mThemeVariables(themeVariables, "light")["--w3m-background"])};
+        --wui-color-accent-base-100: var(--w3m-accent);
+
+        --wui-color-blueberry-100: hsla(231, 100%, 70%, 1);
+        --wui-color-blueberry-090: hsla(231, 97%, 72%, 1);
+        --wui-color-blueberry-080: hsla(231, 92%, 74%, 1);
+
+        --wui-color-fg-100: #141414;
+        --wui-color-fg-125: #2d3131;
+        --wui-color-fg-150: #474d4d;
+        --wui-color-fg-175: #636d6d;
+        --wui-color-fg-200: #798686;
+        --wui-color-fg-225: #828f8f;
+        --wui-color-fg-250: #8b9797;
+        --wui-color-fg-275: #95a0a0;
+        --wui-color-fg-300: #9ea9a9;
+        --wui-color-fg-325: #9a9a9a;
+        --wui-color-fg-350: #d0d0d0;
+
+        --wui-color-bg-100: #ffffff;
+        --wui-color-bg-125: #f5fafa;
+        --wui-color-bg-150: #f3f8f8;
+        --wui-color-bg-175: #eef4f4;
+        --wui-color-bg-200: #eaf1f1;
+        --wui-color-bg-225: #e5eded;
+        --wui-color-bg-250: #e1e9e9;
+        --wui-color-bg-275: #dce7e7;
+        --wui-color-bg-300: #d8e3e3;
+        --wui-color-bg-325: #f3f3f3;
+        --wui-color-bg-350: #202020;
+
+        --wui-color-success-base-100: #26b562;
+        --wui-color-success-base-125: #30a46b;
+
+        --wui-color-warning-base-100: #f3a13f;
+
+        --wui-color-error-base-100: #f05142;
+        --wui-color-error-base-125: #df4a34;
+
+        --wui-color-blue-base-100: rgba(102, 125, 255, 1);
+        --wui-color-blue-base-90: rgba(102, 125, 255, 0.9);
+
+        --wui-color-success-glass-001: rgba(38, 181, 98, 0.01);
+        --wui-color-success-glass-002: rgba(38, 181, 98, 0.02);
+        --wui-color-success-glass-005: rgba(38, 181, 98, 0.05);
+        --wui-color-success-glass-010: rgba(38, 181, 98, 0.1);
+        --wui-color-success-glass-015: rgba(38, 181, 98, 0.15);
+        --wui-color-success-glass-020: rgba(38, 181, 98, 0.2);
+        --wui-color-success-glass-025: rgba(38, 181, 98, 0.25);
+        --wui-color-success-glass-030: rgba(38, 181, 98, 0.3);
+        --wui-color-success-glass-060: rgba(38, 181, 98, 0.6);
+        --wui-color-success-glass-080: rgba(38, 181, 98, 0.8);
+
+        --wui-color-success-glass-reown-020: rgba(48, 164, 107, 0.2);
+
+        --wui-color-warning-glass-reown-020: rgba(243, 161, 63, 0.2);
+
+        --wui-color-error-glass-001: rgba(240, 81, 66, 0.01);
+        --wui-color-error-glass-002: rgba(240, 81, 66, 0.02);
+        --wui-color-error-glass-005: rgba(240, 81, 66, 0.05);
+        --wui-color-error-glass-010: rgba(240, 81, 66, 0.1);
+        --wui-color-error-glass-015: rgba(240, 81, 66, 0.15);
+        --wui-color-error-glass-020: rgba(240, 81, 66, 0.2);
+        --wui-color-error-glass-025: rgba(240, 81, 66, 0.25);
+        --wui-color-error-glass-030: rgba(240, 81, 66, 0.3);
+        --wui-color-error-glass-060: rgba(240, 81, 66, 0.6);
+        --wui-color-error-glass-080: rgba(240, 81, 66, 0.8);
+
+        --wui-color-error-glass-reown-020: rgba(223, 74, 52, 0.2);
+
+        --wui-icon-box-bg-error-base-100: #f4dfdd;
+        --wui-icon-box-bg-blue-base-100: #d9ecfb;
+        --wui-icon-box-bg-success-base-100: #daf0e4;
+        --wui-icon-box-bg-inverse-base-100: #dcecfc;
+
+        --wui-all-wallets-bg-100: #e8f1fa;
+
+        --wui-avatar-border-base: #f3f4f4;
+
+        --wui-thumbnail-border-base: #eaefef;
+
+        --wui-wallet-button-bg-base: var(--wui-color-bg-125);
+
+        --wui-color-gray-glass-001: rgba(0, 0, 0, 0.01);
+        --wui-color-gray-glass-002: rgba(0, 0, 0, 0.02);
+        --wui-color-gray-glass-005: rgba(0, 0, 0, 0.05);
+        --wui-color-gray-glass-010: rgba(0, 0, 0, 0.1);
+        --wui-color-gray-glass-015: rgba(0, 0, 0, 0.15);
+        --wui-color-gray-glass-020: rgba(0, 0, 0, 0.2);
+        --wui-color-gray-glass-025: rgba(0, 0, 0, 0.25);
+        --wui-color-gray-glass-030: rgba(0, 0, 0, 0.3);
+        --wui-color-gray-glass-060: rgba(0, 0, 0, 0.6);
+        --wui-color-gray-glass-080: rgba(0, 0, 0, 0.8);
+        --wui-color-gray-glass-090: rgba(0, 0, 0, 0.9);
+
+        --wui-color-dark-glass-100: rgba(233, 233, 233, 1);
+
+        --w3m-card-embedded-shadow-color: rgb(224 225 233 / 25%);
+      }
+    `
+  };
+}
+const resetStyles = i$3`
+  *,
+  *::after,
+  *::before,
+  :host {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+    font-style: normal;
+    text-rendering: optimizeSpeed;
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+    -webkit-tap-highlight-color: transparent;
+    font-family: var(--wui-font-family);
+    backface-visibility: hidden;
+  }
+`;
+const elementStyles = i$3`
+  button,
+  a {
+    cursor: pointer;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    position: relative;
+    transition:
+      color var(--wui-duration-lg) var(--wui-ease-out-power-1),
+      background-color var(--wui-duration-lg) var(--wui-ease-out-power-1),
+      border var(--wui-duration-lg) var(--wui-ease-out-power-1),
+      border-radius var(--wui-duration-lg) var(--wui-ease-out-power-1),
+      box-shadow var(--wui-duration-lg) var(--wui-ease-out-power-1);
+    will-change: background-color, color, border, box-shadow, border-radius;
+    outline: none;
+    border: none;
+    column-gap: var(--wui-spacing-3xs);
+    background-color: transparent;
+    text-decoration: none;
+  }
+
+  wui-flex {
+    transition: border-radius var(--wui-duration-lg) var(--wui-ease-out-power-1);
+    will-change: border-radius;
+  }
+
+  button:disabled > wui-wallet-image,
+  button:disabled > wui-all-wallets-image,
+  button:disabled > wui-network-image,
+  button:disabled > wui-image,
+  button:disabled > wui-transaction-visual,
+  button:disabled > wui-logo {
+    filter: grayscale(1);
+  }
+
+  @media (hover: hover) and (pointer: fine) {
+    button:hover:enabled {
+      background-color: var(--wui-color-gray-glass-005);
+    }
+
+    button:active:enabled {
+      background-color: var(--wui-color-gray-glass-010);
+    }
+  }
+
+  button:disabled > wui-icon-box {
+    opacity: 0.5;
+  }
+
+  input {
+    border: none;
+    outline: none;
+    appearance: none;
+  }
+`;
+const colorStyles = i$3`
+  .wui-color-inherit {
+    color: var(--wui-color-inherit);
+  }
+
+  .wui-color-accent-100 {
+    color: var(--wui-color-accent-100);
+  }
+
+  .wui-color-error-100 {
+    color: var(--wui-color-error-100);
+  }
+
+  .wui-color-blue-100 {
+    color: var(--wui-color-blue-100);
+  }
+
+  .wui-color-blue-90 {
+    color: var(--wui-color-blue-90);
+  }
+
+  .wui-color-error-125 {
+    color: var(--wui-color-error-125);
+  }
+
+  .wui-color-success-100 {
+    color: var(--wui-color-success-100);
+  }
+
+  .wui-color-success-125 {
+    color: var(--wui-color-success-125);
+  }
+
+  .wui-color-inverse-100 {
+    color: var(--wui-color-inverse-100);
+  }
+
+  .wui-color-inverse-000 {
+    color: var(--wui-color-inverse-000);
+  }
+
+  .wui-color-fg-100 {
+    color: var(--wui-color-fg-100);
+  }
+
+  .wui-color-fg-200 {
+    color: var(--wui-color-fg-200);
+  }
+
+  .wui-color-fg-300 {
+    color: var(--wui-color-fg-300);
+  }
+
+  .wui-color-fg-325 {
+    color: var(--wui-color-fg-325);
+  }
+
+  .wui-color-fg-350 {
+    color: var(--wui-color-fg-350);
+  }
+
+  .wui-bg-color-inherit {
+    background-color: var(--wui-color-inherit);
+  }
+
+  .wui-bg-color-blue-100 {
+    background-color: var(--wui-color-accent-100);
+  }
+
+  .wui-bg-color-error-100 {
+    background-color: var(--wui-color-error-100);
+  }
+
+  .wui-bg-color-error-125 {
+    background-color: var(--wui-color-error-125);
+  }
+
+  .wui-bg-color-success-100 {
+    background-color: var(--wui-color-success-100);
+  }
+
+  .wui-bg-color-success-125 {
+    background-color: var(--wui-color-success-100);
+  }
+
+  .wui-bg-color-inverse-100 {
+    background-color: var(--wui-color-inverse-100);
+  }
+
+  .wui-bg-color-inverse-000 {
+    background-color: var(--wui-color-inverse-000);
+  }
+
+  .wui-bg-color-fg-100 {
+    background-color: var(--wui-color-fg-100);
+  }
+
+  .wui-bg-color-fg-200 {
+    background-color: var(--wui-color-fg-200);
+  }
+
+  .wui-bg-color-fg-300 {
+    background-color: var(--wui-color-fg-300);
+  }
+
+  .wui-color-fg-325 {
+    background-color: var(--wui-color-fg-325);
+  }
+
+  .wui-color-fg-350 {
+    background-color: var(--wui-color-fg-350);
+  }
+`;
+function defineChain(chain) {
+  return {
+    formatters: void 0,
+    fees: void 0,
+    serializers: void 0,
+    ...chain
+  };
+}
+const solana = defineChain({
+  id: "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+  name: "Solana",
+  network: "solana-mainnet",
+  nativeCurrency: { name: "Solana", symbol: "SOL", decimals: 9 },
+  rpcUrls: {
+    default: { http: ["https://rpc.walletconnect.org/v1"] }
+  },
+  blockExplorers: { default: { name: "Solscan", url: "https://solscan.io" } },
+  testnet: false,
+  chainNamespace: "solana",
+  caipNetworkId: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+  deprecatedCaipNetworkId: "solana:4sGjMW1sUnHzSxGspuhpqLDx6wiyjNtZ"
+});
+const solanaDevnet = defineChain({
+  id: "EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
+  name: "Solana Devnet",
+  network: "solana-devnet",
+  nativeCurrency: { name: "Solana", symbol: "SOL", decimals: 9 },
+  rpcUrls: {
+    default: { http: ["https://rpc.walletconnect.org/v1"] }
+  },
+  blockExplorers: { default: { name: "Solscan", url: "https://solscan.io" } },
+  testnet: true,
+  chainNamespace: "solana",
+  caipNetworkId: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
+  deprecatedCaipNetworkId: "solana:8E9rvCKLFQia2Y35HXjjpWzj8weVo44K"
+});
+defineChain({
+  id: "4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z",
+  name: "Solana Testnet",
+  network: "solana-testnet",
+  nativeCurrency: { name: "Solana", symbol: "SOL", decimals: 9 },
+  rpcUrls: {
+    default: { http: ["https://rpc.walletconnect.org/v1"] }
+  },
+  blockExplorers: { default: { name: "Solscan", url: "https://solscan.io" } },
+  testnet: true,
+  chainNamespace: "solana",
+  caipNetworkId: "solana:4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z"
+});
+defineChain({
+  id: "000000000019d6689c085ae165831e93",
+  caipNetworkId: "bip122:000000000019d6689c085ae165831e93",
+  chainNamespace: "bip122",
+  name: "Bitcoin",
+  nativeCurrency: {
+    name: "Bitcoin",
+    symbol: "BTC",
+    decimals: 8
+  },
+  rpcUrls: {
+    default: { http: ["https://rpc.walletconnect.org/v1"] }
+  }
+});
+defineChain({
+  id: "000000000933ea01ad0ee984209779ba",
+  caipNetworkId: "bip122:000000000933ea01ad0ee984209779ba",
+  chainNamespace: "bip122",
+  name: "Bitcoin Testnet",
+  nativeCurrency: {
+    name: "Bitcoin",
+    symbol: "BTC",
+    decimals: 8
+  },
+  rpcUrls: {
+    default: { http: ["https://rpc.walletconnect.org/v1"] }
+  },
+  testnet: true
+});
+exports.ConstantsUtil = ConstantsUtil;
+exports.E = E;
+exports.Ot = Ot;
+exports.T = T;
+exports.b = b;
+exports.browser = browser;
+exports.bs58 = bs58;
+exports.cjs = cjs;
+exports.colorStyles = colorStyles;
+exports.commonjsGlobal = commonjsGlobal;
+exports.elementStyles = elementStyles;
+exports.f = f$1;
+exports.getAugmentedNamespace = getAugmentedNamespace;
+exports.getDefaultExportFromCjs = getDefaultExportFromCjs;
+exports.getW3mThemeVariables = getW3mThemeVariables;
+exports.i = i$3;
+exports.i$1 = i;
+exports.initializeTheming = initializeTheming;
+exports.proxy = proxy;
+exports.proxyMap = proxyMap;
+exports.ref = ref;
+exports.resetStyles = resetStyles;
+exports.setColorTheme = setColorTheme;
+exports.setThemeVariables = setThemeVariables;
+exports.snapshot = snapshot;
+exports.solana = solana;
+exports.solanaDevnet = solanaDevnet;
+exports.subscribe = subscribe;
+exports.subscribeKey = subscribeKey;
+exports.u = u$1;
+exports.useSnapshot = useSnapshot;
+exports.x = x;