@txnlab/use-wallet-solid 3.9.0 → 3.10.1

package/dist/chunk/2PXYBV4S.jsx

@@ -0,0 +1,883 @@
+import {
+  __commonJS,
+  __esm,
+  __export,
+  __reExport,
+  __toCommonJS,
+  __toESM
+} from "./CL7LX3O4.jsx";
+
+// ../../node_modules/.pnpm/@walletconnect+jsonrpc-utils@1.0.8/node_modules/@walletconnect/jsonrpc-utils/dist/esm/constants.js
+var PARSE_ERROR, INVALID_REQUEST, METHOD_NOT_FOUND, INVALID_PARAMS, INTERNAL_ERROR, SERVER_ERROR, RESERVED_ERROR_CODES, SERVER_ERROR_CODE_RANGE, STANDARD_ERROR_MAP, DEFAULT_ERROR;
+var init_constants = __esm({
+  "../../node_modules/.pnpm/@walletconnect+jsonrpc-utils@1.0.8/node_modules/@walletconnect/jsonrpc-utils/dist/esm/constants.js"() {
+    "use strict";
+    PARSE_ERROR = "PARSE_ERROR";
+    INVALID_REQUEST = "INVALID_REQUEST";
+    METHOD_NOT_FOUND = "METHOD_NOT_FOUND";
+    INVALID_PARAMS = "INVALID_PARAMS";
+    INTERNAL_ERROR = "INTERNAL_ERROR";
+    SERVER_ERROR = "SERVER_ERROR";
+    RESERVED_ERROR_CODES = [-32700, -32600, -32601, -32602, -32603];
+    SERVER_ERROR_CODE_RANGE = [-32e3, -32099];
+    STANDARD_ERROR_MAP = {
+      [PARSE_ERROR]: { code: -32700, message: "Parse error" },
+      [INVALID_REQUEST]: { code: -32600, message: "Invalid Request" },
+      [METHOD_NOT_FOUND]: { code: -32601, message: "Method not found" },
+      [INVALID_PARAMS]: { code: -32602, message: "Invalid params" },
+      [INTERNAL_ERROR]: { code: -32603, message: "Internal error" },
+      [SERVER_ERROR]: { code: -32e3, message: "Server error" }
+    };
+    DEFAULT_ERROR = SERVER_ERROR;
+  }
+});
+
+// ../../node_modules/.pnpm/@walletconnect+jsonrpc-utils@1.0.8/node_modules/@walletconnect/jsonrpc-utils/dist/esm/error.js
+function isServerErrorCode(code) {
+  return code <= SERVER_ERROR_CODE_RANGE[0] && code >= SERVER_ERROR_CODE_RANGE[1];
+}
+function isReservedErrorCode(code) {
+  return RESERVED_ERROR_CODES.includes(code);
+}
+function isValidErrorCode(code) {
+  return typeof code === "number";
+}
+function getError(type) {
+  if (!Object.keys(STANDARD_ERROR_MAP).includes(type)) {
+    return STANDARD_ERROR_MAP[DEFAULT_ERROR];
+  }
+  return STANDARD_ERROR_MAP[type];
+}
+function getErrorByCode(code) {
+  const match = Object.values(STANDARD_ERROR_MAP).find((e2) => e2.code === code);
+  if (!match) {
+    return STANDARD_ERROR_MAP[DEFAULT_ERROR];
+  }
+  return match;
+}
+function validateJsonRpcError(response) {
+  if (typeof response.error.code === "undefined") {
+    return { valid: false, error: "Missing code for JSON-RPC error" };
+  }
+  if (typeof response.error.message === "undefined") {
+    return { valid: false, error: "Missing message for JSON-RPC error" };
+  }
+  if (!isValidErrorCode(response.error.code)) {
+    return {
+      valid: false,
+      error: `Invalid error code type for JSON-RPC: ${response.error.code}`
+    };
+  }
+  if (isReservedErrorCode(response.error.code)) {
+    const error = getErrorByCode(response.error.code);
+    if (error.message !== STANDARD_ERROR_MAP[DEFAULT_ERROR].message && response.error.message === error.message) {
+      return {
+        valid: false,
+        error: `Invalid error code message for JSON-RPC: ${response.error.code}`
+      };
+    }
+  }
+  return { valid: true };
+}
+function parseConnectionError(e2, url, type) {
+  return e2.message.includes("getaddrinfo ENOTFOUND") || e2.message.includes("connect ECONNREFUSED") ? new Error(`Unavailable ${type} RPC url at ${url}`) : e2;
+}
+var init_error = __esm({
+  "../../node_modules/.pnpm/@walletconnect+jsonrpc-utils@1.0.8/node_modules/@walletconnect/jsonrpc-utils/dist/esm/error.js"() {
+    "use strict";
+    init_constants();
+  }
+});
+
+// ../../node_modules/.pnpm/@walletconnect+jsonrpc-utils@1.0.8/node_modules/@walletconnect/jsonrpc-utils/dist/esm/format.js
+function payloadId(entropy = 3) {
+  const date = Date.now() * Math.pow(10, entropy);
+  const extra = Math.floor(Math.random() * Math.pow(10, entropy));
+  return date + extra;
+}
+function getBigIntRpcId(entropy = 6) {
+  return BigInt(payloadId(entropy));
+}
+function formatJsonRpcRequest(method, params, id) {
+  return {
+    id: id || payloadId(),
+    jsonrpc: "2.0",
+    method,
+    params
+  };
+}
+function formatJsonRpcResult(id, result) {
+  return {
+    id,
+    jsonrpc: "2.0",
+    result
+  };
+}
+function formatJsonRpcError(id, error, data) {
+  return {
+    id,
+    jsonrpc: "2.0",
+    error: formatErrorMessage(error, data)
+  };
+}
+function formatErrorMessage(error, data) {
+  if (typeof error === "undefined") {
+    return getError(INTERNAL_ERROR);
+  }
+  if (typeof error === "string") {
+    error = Object.assign(Object.assign({}, getError(SERVER_ERROR)), { message: error });
+  }
+  if (typeof data !== "undefined") {
+    error.data = data;
+  }
+  if (isReservedErrorCode(error.code)) {
+    error = getErrorByCode(error.code);
+  }
+  return error;
+}
+var init_format = __esm({
+  "../../node_modules/.pnpm/@walletconnect+jsonrpc-utils@1.0.8/node_modules/@walletconnect/jsonrpc-utils/dist/esm/format.js"() {
+    "use strict";
+    init_error();
+    init_constants();
+  }
+});
+
+// ../../node_modules/.pnpm/@walletconnect+jsonrpc-utils@1.0.8/node_modules/@walletconnect/jsonrpc-utils/dist/esm/validators.js
+function isJsonRpcPayload(payload) {
+  return typeof payload === "object" && "id" in payload && "jsonrpc" in payload && payload.jsonrpc === "2.0";
+}
+function isJsonRpcRequest(payload) {
+  return isJsonRpcPayload(payload) && "method" in payload;
+}
+function isJsonRpcResponse(payload) {
+  return isJsonRpcPayload(payload) && (isJsonRpcResult(payload) || isJsonRpcError(payload));
+}
+function isJsonRpcResult(payload) {
+  return "result" in payload;
+}
+function isJsonRpcError(payload) {
+  return "error" in payload;
+}
+function isJsonRpcValidationInvalid(validation) {
+  return "error" in validation && validation.valid === false;
+}
+var init_validators = __esm({
+  "../../node_modules/.pnpm/@walletconnect+jsonrpc-utils@1.0.8/node_modules/@walletconnect/jsonrpc-utils/dist/esm/validators.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/.pnpm/tslib@1.14.1/node_modules/tslib/tslib.es6.js
+var tslib_es6_exports = {};
+__export(tslib_es6_exports, {
+  __assign: () => __assign,
+  __asyncDelegator: () => __asyncDelegator,
+  __asyncGenerator: () => __asyncGenerator,
+  __asyncValues: () => __asyncValues,
+  __await: () => __await,
+  __awaiter: () => __awaiter,
+  __classPrivateFieldGet: () => __classPrivateFieldGet,
+  __classPrivateFieldSet: () => __classPrivateFieldSet,
+  __createBinding: () => __createBinding,
+  __decorate: () => __decorate,
+  __exportStar: () => __exportStar,
+  __extends: () => __extends,
+  __generator: () => __generator,
+  __importDefault: () => __importDefault,
+  __importStar: () => __importStar,
+  __makeTemplateObject: () => __makeTemplateObject,
+  __metadata: () => __metadata,
+  __param: () => __param,
+  __read: () => __read,
+  __rest: () => __rest,
+  __spread: () => __spread,
+  __spreadArrays: () => __spreadArrays,
+  __values: () => __values
+});
+function __extends(d, b) {
+  extendStatics(d, b);
+  function __() {
+    this.constructor = d;
+  }
+  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+function __rest(s, e2) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e2.indexOf(p) < 0)
+    t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function")
+    for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+      if (e2.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+        t[p[i]] = s[p[i]];
+    }
+  return t;
+}
+function __decorate(decorators, target, key, desc) {
+  var c = arguments.length, r2 = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r2 = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r2 = (c < 3 ? d(r2) : c > 3 ? d(target, key, r2) : d(target, key)) || r2;
+  return c > 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, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = 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 _ = { label: 0, sent: function() {
+    if (t[0] & 1) throw t[1];
+    return t[1];
+  }, trys: [], ops: [] }, f, y, t, g;
+  return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+    return this;
+  }), g;
+  function verb(n2) {
+    return function(v) {
+      return step([n2, v]);
+    };
+  }
+  function step(op) {
+    if (f) throw new TypeError("Generator is already executing.");
+    while (_) try {
+      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+      if (y = 0, t) op = [op[0] & 2, t.value];
+      switch (op[0]) {
+        case 0:
+        case 1:
+          t = op;
+          break;
+        case 4:
+          _.label++;
+          return { value: op[1], done: false };
+        case 5:
+          _.label++;
+          y = op[1];
+          op = [0];
+          continue;
+        case 7:
+          op = _.ops.pop();
+          _.trys.pop();
+          continue;
+        default:
+          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+            _ = 0;
+            continue;
+          }
+          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+            _.label = op[1];
+            break;
+          }
+          if (op[0] === 6 && _.label < t[1]) {
+            _.label = t[1];
+            t = op;
+            break;
+          }
+          if (t && _.label < t[2]) {
+            _.label = t[2];
+            _.ops.push(op);
+            break;
+          }
+          if (t[2]) _.ops.pop();
+          _.trys.pop();
+          continue;
+      }
+      op = body.call(thisArg, _);
+    } catch (e2) {
+      op = [6, e2];
+      y = 0;
+    } finally {
+      f = t = 0;
+    }
+    if (op[0] & 5) throw op[1];
+    return { value: op[0] ? op[1] : void 0, done: true };
+  }
+}
+function __createBinding(o2, m, k, k2) {
+  if (k2 === void 0) k2 = k;
+  o2[k2] = m[k];
+}
+function __exportStar(m, exports) {
+  for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+function __values(o2) {
+  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o2[s], i = 0;
+  if (m) return m.call(o2);
+  if (o2 && typeof o2.length === "number") return {
+    next: function() {
+      if (o2 && i >= o2.length) o2 = void 0;
+      return { value: o2 && o2[i++], done: !o2 };
+    }
+  };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __read(o2, n2) {
+  var m = typeof Symbol === "function" && o2[Symbol.iterator];
+  if (!m) return o2;
+  var i = m.call(o2), r2, ar = [], e2;
+  try {
+    while ((n2 === void 0 || n2-- > 0) && !(r2 = i.next()).done) ar.push(r2.value);
+  } catch (error) {
+    e2 = { error };
+  } finally {
+    try {
+      if (r2 && !r2.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e2) throw e2.error;
+    }
+  }
+  return ar;
+}
+function __spread() {
+  for (var ar = [], i = 0; i < arguments.length; i++)
+    ar = ar.concat(__read(arguments[i]));
+  return ar;
+}
+function __spreadArrays() {
+  for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+  for (var r2 = Array(s), k = 0, i = 0; i < il; i++)
+    for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+      r2[k] = a[j];
+  return r2;
+}
+function __await(v) {
+  return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+function __asyncGenerator(thisArg, _arguments, generator) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var g = generator.apply(thisArg, _arguments || []), i, q = [];
+  return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i;
+  function verb(n2) {
+    if (g[n2]) i[n2] = function(v) {
+      return new Promise(function(a, b) {
+        q.push([n2, v, a, b]) > 1 || resume(n2, v);
+      });
+    };
+  }
+  function resume(n2, v) {
+    try {
+      step(g[n2](v));
+    } 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(f, v) {
+    if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
+  }
+}
+function __asyncDelegator(o2) {
+  var i, p;
+  return i = {}, verb("next"), verb("throw", function(e2) {
+    throw e2;
+  }), verb("return"), i[Symbol.iterator] = function() {
+    return this;
+  }, i;
+  function verb(n2, f) {
+    i[n2] = o2[n2] ? function(v) {
+      return (p = !p) ? { value: __await(o2[n2](v)), done: n2 === "return" } : f ? f(v) : v;
+    } : f;
+  }
+}
+function __asyncValues(o2) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var m = o2[Symbol.asyncIterator], i;
+  return m ? m.call(o2) : (o2 = typeof __values === "function" ? __values(o2) : o2[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i);
+  function verb(n2) {
+    i[n2] = o2[n2] && function(v) {
+      return new Promise(function(resolve, reject) {
+        v = o2[n2](v), settle(resolve, reject, v.done, v.value);
+      });
+    };
+  }
+  function settle(resolve, reject, d, v) {
+    Promise.resolve(v).then(function(v2) {
+      resolve({ value: v2, done: d });
+    }, 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 k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+  }
+  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;
+}
+var extendStatics, __assign;
+var init_tslib_es6 = __esm({
+  "../../node_modules/.pnpm/tslib@1.14.1/node_modules/tslib/tslib.es6.js"() {
+    "use strict";
+    extendStatics = function(d, b) {
+      extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+        d2.__proto__ = b2;
+      } || function(d2, b2) {
+        for (var p in b2) if (b2.hasOwnProperty(p)) d2[p] = b2[p];
+      };
+      return extendStatics(d, b);
+    };
+    __assign = function() {
+      __assign = Object.assign || function __assign2(t) {
+        for (var s, i = 1, n2 = arguments.length; i < n2; i++) {
+          s = arguments[i];
+          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+      };
+      return __assign.apply(this, arguments);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@walletconnect+environment@1.0.1/node_modules/@walletconnect/environment/dist/cjs/crypto.js
+var require_crypto = __commonJS({
+  "../../node_modules/.pnpm/@walletconnect+environment@1.0.1/node_modules/@walletconnect/environment/dist/cjs/crypto.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isBrowserCryptoAvailable = exports.getSubtleCrypto = exports.getBrowerCrypto = void 0;
+    function getBrowerCrypto() {
+      return (global === null || global === void 0 ? void 0 : global.crypto) || (global === null || global === void 0 ? void 0 : global.msCrypto) || {};
+    }
+    exports.getBrowerCrypto = getBrowerCrypto;
+    function getSubtleCrypto() {
+      const browserCrypto = getBrowerCrypto();
+      return browserCrypto.subtle || browserCrypto.webkitSubtle;
+    }
+    exports.getSubtleCrypto = getSubtleCrypto;
+    function isBrowserCryptoAvailable() {
+      return !!getBrowerCrypto() && !!getSubtleCrypto();
+    }
+    exports.isBrowserCryptoAvailable = isBrowserCryptoAvailable;
+  }
+});
+
+// ../../node_modules/.pnpm/@walletconnect+environment@1.0.1/node_modules/@walletconnect/environment/dist/cjs/env.js
+var require_env = __commonJS({
+  "../../node_modules/.pnpm/@walletconnect+environment@1.0.1/node_modules/@walletconnect/environment/dist/cjs/env.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isBrowser = exports.isNode = exports.isReactNative = void 0;
+    function isReactNative() {
+      return typeof document === "undefined" && typeof navigator !== "undefined" && navigator.product === "ReactNative";
+    }
+    exports.isReactNative = isReactNative;
+    function isNode2() {
+      return typeof process !== "undefined" && typeof process.versions !== "undefined" && typeof process.versions.node !== "undefined";
+    }
+    exports.isNode = isNode2;
+    function isBrowser() {
+      return !isReactNative() && !isNode2();
+    }
+    exports.isBrowser = isBrowser;
+  }
+});
+
+// ../../node_modules/.pnpm/@walletconnect+environment@1.0.1/node_modules/@walletconnect/environment/dist/cjs/index.js
+var require_cjs = __commonJS({
+  "../../node_modules/.pnpm/@walletconnect+environment@1.0.1/node_modules/@walletconnect/environment/dist/cjs/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
+    tslib_1.__exportStar(require_crypto(), exports);
+    tslib_1.__exportStar(require_env(), exports);
+  }
+});
+
+// ../../node_modules/.pnpm/@walletconnect+jsonrpc-utils@1.0.8/node_modules/@walletconnect/jsonrpc-utils/dist/esm/env.js
+var env_exports = {};
+__export(env_exports, {
+  isNodeJs: () => isNodeJs
+});
+var import_environment, isNodeJs;
+var init_env = __esm({
+  "../../node_modules/.pnpm/@walletconnect+jsonrpc-utils@1.0.8/node_modules/@walletconnect/jsonrpc-utils/dist/esm/env.js"() {
+    "use strict";
+    import_environment = __toESM(require_cjs());
+    __reExport(env_exports, __toESM(require_cjs()));
+    isNodeJs = import_environment.isNode;
+  }
+});
+
+// ../../node_modules/.pnpm/@walletconnect+jsonrpc-utils@1.0.8/node_modules/@walletconnect/jsonrpc-utils/dist/esm/routing.js
+function isValidRoute(route) {
+  if (route.includes("*")) {
+    return isValidWildcardRoute(route);
+  }
+  if (/\W/g.test(route)) {
+    return false;
+  }
+  return true;
+}
+function isValidDefaultRoute(route) {
+  return route === "*";
+}
+function isValidWildcardRoute(route) {
+  if (isValidDefaultRoute(route)) {
+    return true;
+  }
+  if (!route.includes("*")) {
+    return false;
+  }
+  if (route.split("*").length !== 2) {
+    return false;
+  }
+  if (route.split("*").filter((x) => x.trim() === "").length !== 1) {
+    return false;
+  }
+  return true;
+}
+function isValidLeadingWildcardRoute(route) {
+  return !isValidDefaultRoute(route) && isValidWildcardRoute(route) && !route.split("*")[0].trim();
+}
+function isValidTrailingWildcardRoute(route) {
+  return !isValidDefaultRoute(route) && isValidWildcardRoute(route) && !route.split("*")[1].trim();
+}
+var init_routing = __esm({
+  "../../node_modules/.pnpm/@walletconnect+jsonrpc-utils@1.0.8/node_modules/@walletconnect/jsonrpc-utils/dist/esm/routing.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/.pnpm/@walletconnect+jsonrpc-types@1.0.4/node_modules/@walletconnect/jsonrpc-types/dist/index.es.js
+var e, o, n, r;
+var init_index_es = __esm({
+  "../../node_modules/.pnpm/@walletconnect+jsonrpc-types@1.0.4/node_modules/@walletconnect/jsonrpc-types/dist/index.es.js"() {
+    "use strict";
+    e = class {
+    };
+    o = class extends e {
+      constructor(c) {
+        super();
+      }
+    };
+    n = class extends e {
+      constructor() {
+        super();
+      }
+    };
+    r = class extends n {
+      constructor(c) {
+        super();
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@walletconnect+jsonrpc-utils@1.0.8/node_modules/@walletconnect/jsonrpc-utils/dist/esm/types.js
+var init_types = __esm({
+  "../../node_modules/.pnpm/@walletconnect+jsonrpc-utils@1.0.8/node_modules/@walletconnect/jsonrpc-utils/dist/esm/types.js"() {
+    "use strict";
+    init_index_es();
+  }
+});
+
+// ../../node_modules/.pnpm/@walletconnect+jsonrpc-utils@1.0.8/node_modules/@walletconnect/jsonrpc-utils/dist/esm/url.js
+function getUrlProtocol(url) {
+  const matches = url.match(new RegExp(/^\w+:/, "gi"));
+  if (!matches || !matches.length)
+    return;
+  return matches[0];
+}
+function matchRegexProtocol(url, regex) {
+  const protocol = getUrlProtocol(url);
+  if (typeof protocol === "undefined")
+    return false;
+  return new RegExp(regex).test(protocol);
+}
+function isHttpUrl(url) {
+  return matchRegexProtocol(url, HTTP_REGEX);
+}
+function isWsUrl(url) {
+  return matchRegexProtocol(url, WS_REGEX);
+}
+function isLocalhostUrl(url) {
+  return new RegExp("wss?://localhost(:d{2,5})?").test(url);
+}
+var HTTP_REGEX, WS_REGEX;
+var init_url = __esm({
+  "../../node_modules/.pnpm/@walletconnect+jsonrpc-utils@1.0.8/node_modules/@walletconnect/jsonrpc-utils/dist/esm/url.js"() {
+    "use strict";
+    HTTP_REGEX = "^https?:";
+    WS_REGEX = "^wss?:";
+  }
+});
+
+// ../../node_modules/.pnpm/@walletconnect+jsonrpc-utils@1.0.8/node_modules/@walletconnect/jsonrpc-utils/dist/esm/index.js
+var esm_exports = {};
+__export(esm_exports, {
+  DEFAULT_ERROR: () => DEFAULT_ERROR,
+  IBaseJsonRpcProvider: () => n,
+  IEvents: () => e,
+  IJsonRpcConnection: () => o,
+  IJsonRpcProvider: () => r,
+  INTERNAL_ERROR: () => INTERNAL_ERROR,
+  INVALID_PARAMS: () => INVALID_PARAMS,
+  INVALID_REQUEST: () => INVALID_REQUEST,
+  METHOD_NOT_FOUND: () => METHOD_NOT_FOUND,
+  PARSE_ERROR: () => PARSE_ERROR,
+  RESERVED_ERROR_CODES: () => RESERVED_ERROR_CODES,
+  SERVER_ERROR: () => SERVER_ERROR,
+  SERVER_ERROR_CODE_RANGE: () => SERVER_ERROR_CODE_RANGE,
+  STANDARD_ERROR_MAP: () => STANDARD_ERROR_MAP,
+  formatErrorMessage: () => formatErrorMessage,
+  formatJsonRpcError: () => formatJsonRpcError,
+  formatJsonRpcRequest: () => formatJsonRpcRequest,
+  formatJsonRpcResult: () => formatJsonRpcResult,
+  getBigIntRpcId: () => getBigIntRpcId,
+  getError: () => getError,
+  getErrorByCode: () => getErrorByCode,
+  isHttpUrl: () => isHttpUrl,
+  isJsonRpcError: () => isJsonRpcError,
+  isJsonRpcPayload: () => isJsonRpcPayload,
+  isJsonRpcRequest: () => isJsonRpcRequest,
+  isJsonRpcResponse: () => isJsonRpcResponse,
+  isJsonRpcResult: () => isJsonRpcResult,
+  isJsonRpcValidationInvalid: () => isJsonRpcValidationInvalid,
+  isLocalhostUrl: () => isLocalhostUrl,
+  isNodeJs: () => isNodeJs,
+  isReservedErrorCode: () => isReservedErrorCode,
+  isServerErrorCode: () => isServerErrorCode,
+  isValidDefaultRoute: () => isValidDefaultRoute,
+  isValidErrorCode: () => isValidErrorCode,
+  isValidLeadingWildcardRoute: () => isValidLeadingWildcardRoute,
+  isValidRoute: () => isValidRoute,
+  isValidTrailingWildcardRoute: () => isValidTrailingWildcardRoute,
+  isValidWildcardRoute: () => isValidWildcardRoute,
+  isWsUrl: () => isWsUrl,
+  parseConnectionError: () => parseConnectionError,
+  payloadId: () => payloadId,
+  validateJsonRpcError: () => validateJsonRpcError
+});
+var init_esm = __esm({
+  "../../node_modules/.pnpm/@walletconnect+jsonrpc-utils@1.0.8/node_modules/@walletconnect/jsonrpc-utils/dist/esm/index.js"() {
+    "use strict";
+    init_constants();
+    init_error();
+    init_env();
+    __reExport(esm_exports, env_exports);
+    init_format();
+    init_routing();
+    init_types();
+    init_url();
+    init_validators();
+  }
+});
+
+// ../../node_modules/.pnpm/strict-uri-encode@2.0.0/node_modules/strict-uri-encode/index.js
+var require_strict_uri_encode = __commonJS({
+  "../../node_modules/.pnpm/strict-uri-encode@2.0.0/node_modules/strict-uri-encode/index.js"(exports, module) {
+    "use strict";
+    module.exports = (str) => encodeURIComponent(str).replace(/[!'()*]/g, (x) => `%${x.charCodeAt(0).toString(16).toUpperCase()}`);
+  }
+});
+
+// ../../node_modules/.pnpm/decode-uri-component@0.2.2/node_modules/decode-uri-component/index.js
+var require_decode_uri_component = __commonJS({
+  "../../node_modules/.pnpm/decode-uri-component@0.2.2/node_modules/decode-uri-component/index.js"(exports, module) {
+    "use strict";
+    var token = "%[a-f0-9]{2}";
+    var singleMatcher = new RegExp("(" + token + ")|([^%]+?)", "gi");
+    var multiMatcher = new RegExp("(" + token + ")+", "gi");
+    function decodeComponents(components, split) {
+      try {
+        return [decodeURIComponent(components.join(""))];
+      } catch (err) {
+      }
+      if (components.length === 1) {
+        return components;
+      }
+      split = split || 1;
+      var left = components.slice(0, split);
+      var right = components.slice(split);
+      return Array.prototype.concat.call([], decodeComponents(left), decodeComponents(right));
+    }
+    function decode(input) {
+      try {
+        return decodeURIComponent(input);
+      } catch (err) {
+        var tokens = input.match(singleMatcher) || [];
+        for (var i = 1; i < tokens.length; i++) {
+          input = decodeComponents(tokens, i).join("");
+          tokens = input.match(singleMatcher) || [];
+        }
+        return input;
+      }
+    }
+    function customDecodeURIComponent(input) {
+      var replaceMap = {
+        "%FE%FF": "\uFFFD\uFFFD",
+        "%FF%FE": "\uFFFD\uFFFD"
+      };
+      var match = multiMatcher.exec(input);
+      while (match) {
+        try {
+          replaceMap[match[0]] = decodeURIComponent(match[0]);
+        } catch (err) {
+          var result = decode(match[0]);
+          if (result !== match[0]) {
+            replaceMap[match[0]] = result;
+          }
+        }
+        match = multiMatcher.exec(input);
+      }
+      replaceMap["%C2"] = "\uFFFD";
+      var entries = Object.keys(replaceMap);
+      for (var i = 0; i < entries.length; i++) {
+        var key = entries[i];
+        input = input.replace(new RegExp(key, "g"), replaceMap[key]);
+      }
+      return input;
+    }
+    module.exports = function(encodedURI) {
+      if (typeof encodedURI !== "string") {
+        throw new TypeError("Expected `encodedURI` to be of type `string`, got `" + typeof encodedURI + "`");
+      }
+      try {
+        encodedURI = encodedURI.replace(/\+/g, " ");
+        return decodeURIComponent(encodedURI);
+      } catch (err) {
+        return customDecodeURIComponent(encodedURI);
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/split-on-first@1.1.0/node_modules/split-on-first/index.js
+var require_split_on_first = __commonJS({
+  "../../node_modules/.pnpm/split-on-first@1.1.0/node_modules/split-on-first/index.js"(exports, module) {
+    "use strict";
+    module.exports = (string, separator) => {
+      if (!(typeof string === "string" && typeof separator === "string")) {
+        throw new TypeError("Expected the arguments to be of type `string`");
+      }
+      if (separator === "") {
+        return [string];
+      }
+      const separatorIndex = string.indexOf(separator);
+      if (separatorIndex === -1) {
+        return [string];
+      }
+      return [
+        string.slice(0, separatorIndex),
+        string.slice(separatorIndex + separator.length)
+      ];
+    };
+  }
+});
+
+// (disabled):../../node_modules/.pnpm/buffer@6.0.3/node_modules/buffer/index.js
+var require_buffer = __commonJS({
+  "(disabled):../../node_modules/.pnpm/buffer@6.0.3/node_modules/buffer/index.js"() {
+    "use strict";
+  }
+});
+
+export {
+  tslib_es6_exports,
+  init_tslib_es6,
+  require_strict_uri_encode,
+  require_decode_uri_component,
+  require_split_on_first,
+  require_buffer,
+  parseConnectionError,
+  require_cjs,
+  payloadId,
+  getBigIntRpcId,
+  formatJsonRpcRequest,
+  formatJsonRpcResult,
+  formatJsonRpcError,
+  r,
+  isWsUrl,
+  isLocalhostUrl,
+  isJsonRpcRequest,
+  isJsonRpcResponse,
+  isJsonRpcResult,
+  isJsonRpcError,
+  esm_exports,
+  init_esm
+};
+/*! Bundled license information:
+
+tslib/tslib.es6.js:
+  (*! *****************************************************************************
+  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.
+  ***************************************************************************** *)
+*/