diff --git a/assets/browser-480bf3e4.js b/assets/browser-8302b9c5.js similarity index 99% rename from assets/browser-480bf3e4.js rename to assets/browser-8302b9c5.js index ce4b762..e3fa0c6 100644 --- a/assets/browser-480bf3e4.js +++ b/assets/browser-8302b9c5.js @@ -1,4 +1,4 @@ -import { g as getDefaultExportFromCjs } from "./index-945462c7.js"; +import { k as getDefaultExportFromCjs } from "./index-f38a281b.js"; var browser = { exports: {} }; var ms; var hasRequiredMs; diff --git a/assets/browser-ponyfill-b3d524b9.js b/assets/browser-ponyfill-b3d524b9.js new file mode 100644 index 0000000..8ffaf3d --- /dev/null +++ b/assets/browser-ponyfill-b3d524b9.js @@ -0,0 +1,466 @@ +import { m as commonjsGlobal, k as getDefaultExportFromCjs } from "./index-f38a281b.js"; +var browserPonyfill = { exports: {} }; +(function(module, exports) { + var global = typeof self !== "undefined" ? self : commonjsGlobal; + var __self__ = function() { + function F() { + this.fetch = false; + this.DOMException = global.DOMException; + } + F.prototype = global; + return new F(); + }(); + (function(self2) { + (function(exports2) { + var support = { + searchParams: "URLSearchParams" in self2, + iterable: "Symbol" in self2 && "iterator" in Symbol, + blob: "FileReader" in self2 && "Blob" in self2 && function() { + try { + new Blob(); + return true; + } catch (e) { + return false; + } + }(), + formData: "FormData" in self2, + arrayBuffer: "ArrayBuffer" in self2 + }; + function isDataView(obj) { + return obj && DataView.prototype.isPrototypeOf(obj); + } + if (support.arrayBuffer) { + var viewClasses = [ + "[object Int8Array]", + "[object Uint8Array]", + "[object Uint8ClampedArray]", + "[object Int16Array]", + "[object Uint16Array]", + "[object Int32Array]", + "[object Uint32Array]", + "[object Float32Array]", + "[object Float64Array]" + ]; + var isArrayBufferView = ArrayBuffer.isView || function(obj) { + return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1; + }; + } + function normalizeName(name) { + if (typeof name !== "string") { + name = String(name); + } + if (/[^a-z0-9\-#$%&'*+.^_`|~]/i.test(name)) { + throw new TypeError("Invalid character in header field name"); + } + return name.toLowerCase(); + } + function normalizeValue(value) { + if (typeof value !== "string") { + value = String(value); + } + return value; + } + function iteratorFor(items) { + var iterator = { + next: function() { + var value = items.shift(); + return { done: value === void 0, value }; + } + }; + if (support.iterable) { + iterator[Symbol.iterator] = function() { + return iterator; + }; + } + return iterator; + } + function Headers(headers) { + this.map = {}; + if (headers instanceof Headers) { + headers.forEach(function(value, name) { + this.append(name, value); + }, this); + } else if (Array.isArray(headers)) { + headers.forEach(function(header) { + this.append(header[0], header[1]); + }, this); + } else if (headers) { + Object.getOwnPropertyNames(headers).forEach(function(name) { + this.append(name, headers[name]); + }, this); + } + } + Headers.prototype.append = function(name, value) { + name = normalizeName(name); + value = normalizeValue(value); + var oldValue = this.map[name]; + this.map[name] = oldValue ? oldValue + ", " + value : value; + }; + Headers.prototype["delete"] = function(name) { + delete this.map[normalizeName(name)]; + }; + Headers.prototype.get = function(name) { + name = normalizeName(name); + return this.has(name) ? this.map[name] : null; + }; + Headers.prototype.has = function(name) { + return this.map.hasOwnProperty(normalizeName(name)); + }; + Headers.prototype.set = function(name, value) { + this.map[normalizeName(name)] = normalizeValue(value); + }; + Headers.prototype.forEach = function(callback, thisArg) { + for (var name in this.map) { + if (this.map.hasOwnProperty(name)) { + callback.call(thisArg, this.map[name], name, this); + } + } + }; + Headers.prototype.keys = function() { + var items = []; + this.forEach(function(value, name) { + items.push(name); + }); + return iteratorFor(items); + }; + Headers.prototype.values = function() { + var items = []; + this.forEach(function(value) { + items.push(value); + }); + return iteratorFor(items); + }; + Headers.prototype.entries = function() { + var items = []; + this.forEach(function(value, name) { + items.push([name, value]); + }); + return iteratorFor(items); + }; + if (support.iterable) { + Headers.prototype[Symbol.iterator] = Headers.prototype.entries; + } + function consumed(body) { + if (body.bodyUsed) { + return Promise.reject(new TypeError("Already read")); + } + body.bodyUsed = true; + } + function fileReaderReady(reader) { + return new Promise(function(resolve, reject) { + reader.onload = function() { + resolve(reader.result); + }; + reader.onerror = function() { + reject(reader.error); + }; + }); + } + function readBlobAsArrayBuffer(blob) { + var reader = new FileReader(); + var promise = fileReaderReady(reader); + reader.readAsArrayBuffer(blob); + return promise; + } + function readBlobAsText(blob) { + var reader = new FileReader(); + var promise = fileReaderReady(reader); + reader.readAsText(blob); + return promise; + } + function readArrayBufferAsText(buf) { + var view = new Uint8Array(buf); + var chars = new Array(view.length); + for (var i = 0; i < view.length; i++) { + chars[i] = String.fromCharCode(view[i]); + } + return chars.join(""); + } + function bufferClone(buf) { + if (buf.slice) { + return buf.slice(0); + } else { + var view = new Uint8Array(buf.byteLength); + view.set(new Uint8Array(buf)); + return view.buffer; + } + } + function Body() { + this.bodyUsed = false; + this._initBody = function(body) { + this._bodyInit = body; + if (!body) { + this._bodyText = ""; + } else if (typeof body === "string") { + this._bodyText = body; + } else if (support.blob && Blob.prototype.isPrototypeOf(body)) { + this._bodyBlob = body; + } else if (support.formData && FormData.prototype.isPrototypeOf(body)) { + this._bodyFormData = body; + } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) { + this._bodyText = body.toString(); + } else if (support.arrayBuffer && support.blob && isDataView(body)) { + this._bodyArrayBuffer = bufferClone(body.buffer); + this._bodyInit = new Blob([this._bodyArrayBuffer]); + } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) { + this._bodyArrayBuffer = bufferClone(body); + } else { + this._bodyText = body = Object.prototype.toString.call(body); + } + if (!this.headers.get("content-type")) { + if (typeof body === "string") { + this.headers.set("content-type", "text/plain;charset=UTF-8"); + } else if (this._bodyBlob && this._bodyBlob.type) { + this.headers.set("content-type", this._bodyBlob.type); + } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) { + this.headers.set("content-type", "application/x-www-form-urlencoded;charset=UTF-8"); + } + } + }; + if (support.blob) { + this.blob = function() { + var rejected = consumed(this); + if (rejected) { + return rejected; + } + if (this._bodyBlob) { + return Promise.resolve(this._bodyBlob); + } else if (this._bodyArrayBuffer) { + return Promise.resolve(new Blob([this._bodyArrayBuffer])); + } else if (this._bodyFormData) { + throw new Error("could not read FormData body as blob"); + } else { + return Promise.resolve(new Blob([this._bodyText])); + } + }; + this.arrayBuffer = function() { + if (this._bodyArrayBuffer) { + return consumed(this) || Promise.resolve(this._bodyArrayBuffer); + } else { + return this.blob().then(readBlobAsArrayBuffer); + } + }; + } + this.text = function() { + var rejected = consumed(this); + if (rejected) { + return rejected; + } + if (this._bodyBlob) { + return readBlobAsText(this._bodyBlob); + } else if (this._bodyArrayBuffer) { + return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer)); + } else if (this._bodyFormData) { + throw new Error("could not read FormData body as text"); + } else { + return Promise.resolve(this._bodyText); + } + }; + if (support.formData) { + this.formData = function() { + return this.text().then(decode); + }; + } + this.json = function() { + return this.text().then(JSON.parse); + }; + return this; + } + var methods = ["DELETE", "GET", "HEAD", "OPTIONS", "POST", "PUT"]; + function normalizeMethod(method) { + var upcased = method.toUpperCase(); + return methods.indexOf(upcased) > -1 ? upcased : method; + } + function Request(input, options) { + options = options || {}; + var body = options.body; + if (input instanceof Request) { + if (input.bodyUsed) { + throw new TypeError("Already read"); + } + this.url = input.url; + this.credentials = input.credentials; + if (!options.headers) { + this.headers = new Headers(input.headers); + } + this.method = input.method; + this.mode = input.mode; + this.signal = input.signal; + if (!body && input._bodyInit != null) { + body = input._bodyInit; + input.bodyUsed = true; + } + } else { + this.url = String(input); + } + this.credentials = options.credentials || this.credentials || "same-origin"; + if (options.headers || !this.headers) { + this.headers = new Headers(options.headers); + } + this.method = normalizeMethod(options.method || this.method || "GET"); + this.mode = options.mode || this.mode || null; + this.signal = options.signal || this.signal; + this.referrer = null; + if ((this.method === "GET" || this.method === "HEAD") && body) { + throw new TypeError("Body not allowed for GET or HEAD requests"); + } + this._initBody(body); + } + Request.prototype.clone = function() { + return new Request(this, { body: this._bodyInit }); + }; + function decode(body) { + var form = new FormData(); + body.trim().split("&").forEach(function(bytes) { + if (bytes) { + var split = bytes.split("="); + var name = split.shift().replace(/\+/g, " "); + var value = split.join("=").replace(/\+/g, " "); + form.append(decodeURIComponent(name), decodeURIComponent(value)); + } + }); + return form; + } + function parseHeaders(rawHeaders) { + var headers = new Headers(); + var preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, " "); + preProcessedHeaders.split(/\r?\n/).forEach(function(line) { + var parts = line.split(":"); + var key = parts.shift().trim(); + if (key) { + var value = parts.join(":").trim(); + headers.append(key, value); + } + }); + return headers; + } + Body.call(Request.prototype); + function Response(bodyInit, options) { + if (!options) { + options = {}; + } + this.type = "default"; + this.status = options.status === void 0 ? 200 : options.status; + this.ok = this.status >= 200 && this.status < 300; + this.statusText = "statusText" in options ? options.statusText : "OK"; + this.headers = new Headers(options.headers); + this.url = options.url || ""; + this._initBody(bodyInit); + } + Body.call(Response.prototype); + Response.prototype.clone = function() { + return new Response(this._bodyInit, { + status: this.status, + statusText: this.statusText, + headers: new Headers(this.headers), + url: this.url + }); + }; + Response.error = function() { + var response = new Response(null, { status: 0, statusText: "" }); + response.type = "error"; + return response; + }; + var redirectStatuses = [301, 302, 303, 307, 308]; + Response.redirect = function(url, status) { + if (redirectStatuses.indexOf(status) === -1) { + throw new RangeError("Invalid status code"); + } + return new Response(null, { status, headers: { location: url } }); + }; + exports2.DOMException = self2.DOMException; + try { + new exports2.DOMException(); + } catch (err) { + exports2.DOMException = function(message, name) { + this.message = message; + this.name = name; + var error = Error(message); + this.stack = error.stack; + }; + exports2.DOMException.prototype = Object.create(Error.prototype); + exports2.DOMException.prototype.constructor = exports2.DOMException; + } + function fetch(input, init) { + return new Promise(function(resolve, reject) { + var request = new Request(input, init); + if (request.signal && request.signal.aborted) { + return reject(new exports2.DOMException("Aborted", "AbortError")); + } + var xhr = new XMLHttpRequest(); + function abortXhr() { + xhr.abort(); + } + xhr.onload = function() { + var options = { + status: xhr.status, + statusText: xhr.statusText, + headers: parseHeaders(xhr.getAllResponseHeaders() || "") + }; + options.url = "responseURL" in xhr ? xhr.responseURL : options.headers.get("X-Request-URL"); + var body = "response" in xhr ? xhr.response : xhr.responseText; + resolve(new Response(body, options)); + }; + xhr.onerror = function() { + reject(new TypeError("Network request failed")); + }; + xhr.ontimeout = function() { + reject(new TypeError("Network request failed")); + }; + xhr.onabort = function() { + reject(new exports2.DOMException("Aborted", "AbortError")); + }; + xhr.open(request.method, request.url, true); + if (request.credentials === "include") { + xhr.withCredentials = true; + } else if (request.credentials === "omit") { + xhr.withCredentials = false; + } + if ("responseType" in xhr && support.blob) { + xhr.responseType = "blob"; + } + request.headers.forEach(function(value, name) { + xhr.setRequestHeader(name, value); + }); + if (request.signal) { + request.signal.addEventListener("abort", abortXhr); + xhr.onreadystatechange = function() { + if (xhr.readyState === 4) { + request.signal.removeEventListener("abort", abortXhr); + } + }; + } + xhr.send(typeof request._bodyInit === "undefined" ? null : request._bodyInit); + }); + } + fetch.polyfill = true; + if (!self2.fetch) { + self2.fetch = fetch; + self2.Headers = Headers; + self2.Request = Request; + self2.Response = Response; + } + exports2.Headers = Headers; + exports2.Request = Request; + exports2.Response = Response; + exports2.fetch = fetch; + Object.defineProperty(exports2, "__esModule", { value: true }); + return exports2; + })({}); + })(__self__); + __self__.fetch.ponyfill = true; + delete __self__.fetch.polyfill; + var ctx = __self__; + exports = ctx.fetch; + exports.default = ctx.fetch; + exports.fetch = ctx.fetch; + exports.Headers = ctx.Headers; + exports.Request = ctx.Request; + exports.Response = ctx.Response; + module.exports = exports; +})(browserPonyfill, browserPonyfill.exports); +var browserPonyfillExports = browserPonyfill.exports; +const m = /* @__PURE__ */ getDefaultExportFromCjs(browserPonyfillExports); +export { + m +}; diff --git a/assets/events-b5445255.js b/assets/events-ac009f6f.js similarity index 92% rename from assets/events-b5445255.js rename to assets/events-ac009f6f.js index 262b6b1..0b96474 100644 --- a/assets/events-b5445255.js +++ b/assets/events-ac009f6f.js @@ -1,32 +1,4 @@ -import { g as getDefaultExportFromCjs } from "./index-945462c7.js"; -var inherits_browser = { exports: {} }; -if (typeof Object.create === "function") { - inherits_browser.exports = function inherits(ctor, superCtor) { - if (superCtor) { - ctor.super_ = superCtor; - ctor.prototype = Object.create(superCtor.prototype, { - constructor: { - value: ctor, - enumerable: false, - writable: true, - configurable: true - } - }); - } - }; -} else { - inherits_browser.exports = function inherits(ctor, superCtor) { - if (superCtor) { - ctor.super_ = superCtor; - var TempCtor = function() { - }; - TempCtor.prototype = superCtor.prototype; - ctor.prototype = new TempCtor(); - ctor.prototype.constructor = ctor; - } - }; -} -var inherits_browserExports = inherits_browser.exports; +import { k as getDefaultExportFromCjs } from "./index-f38a281b.js"; var events = { exports: {} }; var R = typeof Reflect === "object" ? Reflect : null; var ReflectApply = R && typeof R.apply === "function" ? R.apply : function ReflectApply2(target, receiver, args) { @@ -396,6 +368,5 @@ var eventsExports = events.exports; const Jg = /* @__PURE__ */ getDefaultExportFromCjs(eventsExports); export { Jg as J, - eventsExports as e, - inherits_browserExports as i + eventsExports as e }; diff --git a/assets/index-79289e75.js b/assets/index-5a9d2881.js similarity index 99% rename from assets/index-79289e75.js rename to assets/index-5a9d2881.js index c15f4c7..ae4b842 100644 --- a/assets/index-79289e75.js +++ b/assets/index-5a9d2881.js @@ -1,4 +1,4 @@ -import { b as getAugmentedNamespace, g as getDefaultExportFromCjs, d as bytesToHex, s as sha256, E as EventEmitter } from "./index-945462c7.js"; +import { T as getAugmentedNamespace, k as getDefaultExportFromCjs, U as bytesToHex, V as sha256, O } from "./index-f38a281b.js"; import { D, g, c as clsx, h, y } from "./hooks.module-1f3364a3.js"; const crypto$1 = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : void 0; const crypto$2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ @@ -3725,7 +3725,7 @@ function getErrorObject(error) { } return error; } -class ProviderEventEmitter extends EventEmitter { +class ProviderEventEmitter extends O { } var __rest = globalThis && globalThis.__rest || function(s, e) { var t = {}; diff --git a/assets/index-9e74aad3.js b/assets/index-9e74aad3.js new file mode 100644 index 0000000..d6c2323 --- /dev/null +++ b/assets/index-9e74aad3.js @@ -0,0 +1,6802 @@ +import { O, e as ea$2, Q as Q$2, z as z$1, a as ep, r as rm, b as ed$1, W as W$1, c as reactExports, d as eh$1, f as createRoot, g as rP, h as rT, i as rj, j as rC, k as getDefaultExportFromCjs, l as rh, _ as _BN, m as commonjsGlobal, n as rl, o as rd, p as eD, q as ej, s as q$1, t as rp, u as r_, v as rA, w as rS, x as rs, y as W$2, A as rN, B as rc, C as rf, G as G$1, D as eM, E as ef$1, F as rx, H as decode, I as et$1, J as rD, K as ey, L as ev, M as ee$1, N as eC } from "./index-f38a281b.js"; +import { m } from "./browser-ponyfill-b3d524b9.js"; +function e$6(e2, t3, r2, n11, i2, o2, s2) { + try { + var u2 = e2[o2](s2); + var a2 = u2.value; + } catch (e3) { + r2(e3); + return; + } + if (u2.done) { + t3(a2); + } else { + Promise.resolve(a2).then(n11, i2); + } +} +function t$6(t3) { + return function() { + var r2 = this, n11 = arguments; + return new Promise(function(i2, o2) { + var s2 = t3.apply(r2, n11); + function u2(t4) { + e$6(s2, i2, o2, u2, a2, "next", t4); + } + function a2(t4) { + e$6(s2, i2, o2, u2, a2, "throw", t4); + } + u2(void 0); + }); + }; +} +function r$6(e2, t3) { + if (!(e2 instanceof t3)) { + throw new TypeError("Cannot call a class as a function"); + } +} +function n$6(e2, t3) { + for (var r2 = 0; r2 < t3.length; r2++) { + var n11 = t3[r2]; + n11.enumerable = n11.enumerable || false; + n11.configurable = true; + if ("value" in n11) + n11.writable = true; + Object.defineProperty(e2, n11.key, n11); + } +} +function i$6(e2, t3, r2) { + if (t3) + n$6(e2.prototype, t3); + if (r2) + n$6(e2, r2); + return e2; +} +function o$6(e2, t3, r2) { + if (t3 in e2) { + Object.defineProperty(e2, t3, { value: r2, enumerable: true, configurable: true, writable: true }); + } else { + e2[t3] = r2; + } + return e2; +} +function s$6(e2) { + for (var t3 = 1; t3 < arguments.length; t3++) { + var r2 = arguments[t3] != null ? arguments[t3] : {}; + var n11 = Object.keys(r2); + if (typeof Object.getOwnPropertySymbols === "function") { + n11 = n11.concat(Object.getOwnPropertySymbols(r2).filter(function(e3) { + return Object.getOwnPropertyDescriptor(r2, e3).enumerable; + })); + } + n11.forEach(function(t4) { + o$6(e2, t4, r2[t4]); + }); + } + return e2; +} +function u$6(e2, t3) { + var r2 = Object.keys(e2); + if (Object.getOwnPropertySymbols) { + var n11 = Object.getOwnPropertySymbols(e2); + if (t3) { + n11 = n11.filter(function(t4) { + return Object.getOwnPropertyDescriptor(e2, t4).enumerable; + }); + } + r2.push.apply(r2, n11); + } + return r2; +} +function a$6(e2, t3) { + t3 = t3 != null ? t3 : {}; + if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(e2, Object.getOwnPropertyDescriptors(t3)); + } else { + u$6(Object(t3)).forEach(function(r2) { + Object.defineProperty(e2, r2, Object.getOwnPropertyDescriptor(t3, r2)); + }); + } + return e2; +} +function c$6(e2) { + "@swc/helpers - typeof"; + return e2 && typeof Symbol !== "undefined" && e2.constructor === Symbol ? "symbol" : typeof e2; +} +function l$5(e2, t3) { + var r2, n11, i2, o2, s2 = { label: 0, sent: function() { + if (i2[0] & 1) + throw i2[1]; + return i2[1]; + }, trys: [], ops: [] }; + return o2 = { next: u2(0), "throw": u2(1), "return": u2(2) }, typeof Symbol === "function" && (o2[Symbol.iterator] = function() { + return this; + }), o2; + function u2(e3) { + return function(t4) { + return a2([e3, t4]); + }; + } + function a2(o3) { + if (r2) + throw new TypeError("Generator is already executing."); + while (s2) + try { + if (r2 = 1, n11 && (i2 = o3[0] & 2 ? n11["return"] : o3[0] ? n11["throw"] || ((i2 = n11["return"]) && i2.call(n11), 0) : n11.next) && !(i2 = i2.call(n11, o3[1])).done) + return i2; + if (n11 = 0, i2) + o3 = [o3[0] & 2, i2.value]; + switch (o3[0]) { + case 0: + case 1: + i2 = o3; + break; + case 4: + s2.label++; + return { value: o3[1], done: false }; + case 5: + s2.label++; + n11 = o3[1]; + o3 = [0]; + continue; + case 7: + o3 = s2.ops.pop(); + s2.trys.pop(); + continue; + default: + if (!(i2 = s2.trys, i2 = i2.length > 0 && i2[i2.length - 1]) && (o3[0] === 6 || o3[0] === 2)) { + s2 = 0; + continue; + } + if (o3[0] === 3 && (!i2 || o3[1] > i2[0] && o3[1] < i2[3])) { + s2.label = o3[1]; + break; + } + if (o3[0] === 6 && s2.label < i2[1]) { + s2.label = i2[1]; + i2 = o3; + break; + } + if (i2 && s2.label < i2[2]) { + s2.label = i2[2]; + s2.ops.push(o3); + break; + } + if (i2[2]) + s2.ops.pop(); + s2.trys.pop(); + continue; + } + o3 = t3.call(e2, s2); + } catch (e3) { + o3 = [6, e3]; + n11 = 0; + } finally { + r2 = i2 = 0; + } + if (o3[0] & 5) + throw o3[1]; + return { value: o3[0] ? o3[1] : void 0, done: true }; + } +} +var f$5 = Object.defineProperty; +var p$4 = function(e2, t3, r2) { + return t3 in e2 ? f$5(e2, t3, { enumerable: true, configurable: true, writable: true, value: r2 }) : e2[t3] = r2; +}; +var b$4 = function(e2, t3, r2) { + return p$4(e2, (typeof t3 === "undefined" ? "undefined" : c$6(t3)) != "symbol" ? t3 + "" : t3, r2), r2; +}; +var P$1 = { Accept: "application/json", "Content-Type": "application/json" }, j = "POST", k$2 = { headers: P$1, method: j }, E = function() { + function e2(t3) { + r$6(this, e2); + this.url = t3; + b$4(this, "events", new O()); + b$4(this, "isAvailable", false); + b$4(this, "registering", false); + if (!ea$2(t3)) + throw new Error("Provided URL is not compatible with HTTP connection: ".concat(t3)); + this.url = t3; + } + i$6(e2, [{ key: "connected", get: function e3() { + return this.isAvailable; + } }, { key: "connecting", get: function e3() { + return this.registering; + } }, { key: "open", value: function e3() { + var e4 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this.url; + var r2 = this; + return t$6(function() { + return l$5(this, function(t3) { + switch (t3.label) { + case 0: + return [4, r2.register(e4)]; + case 1: + t3.sent(); + return [2]; + } + }); + })(); + } }, { key: "close", value: function e3() { + var e4 = this; + return t$6(function() { + return l$5(this, function(t3) { + if (!e4.isAvailable) + throw new Error("Connection already closed"); + e4.onClose(); + return [2]; + }); + })(); + } }, { key: "request", value: function e3(e3) { + var r2 = this; + return t$6(function() { + var t3, n11, i2, o2, u2; + return l$5(this, function(c2) { + switch (c2.label) { + case 0: + rm.debug("HttpClient ~ request ~ payload:", e3); + t3 = r2.isAvailable; + if (t3) + return [3, 2]; + return [4, r2.register()]; + case 1: + t3 = c2.sent(); + c2.label = 2; + case 2: + c2.label = 3; + case 3: + c2.trys.push([3, 6, , 7]); + n11 = ed$1(e3); + return [4, m(r2.url, a$6(s$6({}, k$2), { body: n11 }))]; + case 4: + return [4, c2.sent().json()]; + case 5: + i2 = c2.sent(), o2 = typeof i2 == "string" ? ep(i2) : i2; + return [2, (rm.debug("HttpClient ~ request ~ result:", o2), o2)]; + case 6: + u2 = c2.sent(); + return [2, r2.formatError(e3.id, u2)]; + case 7: + return [2]; + } + }); + })(); + } }, { key: "formatError", value: function e3(e3, t3) { + var r2 = this.parseError(t3), n11 = r2.message || r2.toString(); + return Q$2(e3, n11); + } }, { key: "register", value: function e3() { + var e4 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : this.url; + var r2 = this; + return t$6(function() { + var t3, n11, i2; + return l$5(this, function(o2) { + switch (o2.label) { + case 0: + if (!ea$2(e4)) + throw new Error("Provided URL is not compatible with HTTP connection: ".concat(e4)); + if (r2.registering) + return [2, new Promise(function(e5, t4) { + r2.events.once("register_error", function(e6) { + t4(e6); + }), r2.events.once("open", function() { + if (c$6(r2.isAvailable) > "u") + return t4(new Error("HTTP connection is missing or invalid")); + e5(); + }); + })]; + r2.url = e4, r2.registering = true; + o2.label = 1; + case 1: + o2.trys.push([1, 3, , 4]); + t3 = ed$1({ id: 1, jsonrpc: "2.0", method: "test", params: [] }); + return [4, m(e4, a$6(s$6({}, k$2), { body: t3 }))]; + case 2: + o2.sent(), r2.onOpen(); + return [3, 4]; + case 3: + n11 = o2.sent(); + i2 = r2.parseError(n11); + throw r2.events.emit("register_error", i2), r2.onClose(), i2; + case 4: + return [2]; + } + }); + })(); + } }, { key: "onOpen", value: function e3() { + this.isAvailable = true, this.registering = false, this.events.emit("open"); + } }, { key: "onClose", value: function e3() { + this.isAvailable = false, this.registering = false, this.events.emit("open"); + } }, { key: "parseError", value: function e3(e3) { + var t3 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this.url; + return z$1(e3, t3, "HTTP"); + } }]); + return e2; +}(); +var __defProp = Object.defineProperty; +var __getOwnPropSymbols = Object.getOwnPropertySymbols; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __propIsEnum = Object.prototype.propertyIsEnumerable; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __spreadValues = (a2, b2) => { + for (var prop in b2 || (b2 = {})) + if (__hasOwnProp.call(b2, prop)) + __defNormalProp(a2, prop, b2[prop]); + if (__getOwnPropSymbols) + for (var prop of __getOwnPropSymbols(b2)) { + if (__propIsEnum.call(b2, prop)) + __defNormalProp(a2, prop, b2[prop]); + } + return a2; +}; +var __objRest = (source, exclude) => { + var target = {}; + for (var prop in source) + if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0) + target[prop] = source[prop]; + if (source != null && __getOwnPropSymbols) + for (var prop of __getOwnPropSymbols(source)) { + if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop)) + target[prop] = source[prop]; + } + return target; +}; +/** + * @license QR Code generator library (TypeScript) + * Copyright (c) Project Nayuki. + * SPDX-License-Identifier: MIT + */ +var qrcodegen; +((qrcodegen2) => { + const _QrCode = class { + constructor(version2, errorCorrectionLevel, dataCodewords, msk) { + this.version = version2; + this.errorCorrectionLevel = errorCorrectionLevel; + this.modules = []; + this.isFunction = []; + if (version2 < _QrCode.MIN_VERSION || version2 > _QrCode.MAX_VERSION) + throw new RangeError("Version value out of range"); + if (msk < -1 || msk > 7) + throw new RangeError("Mask value out of range"); + this.size = version2 * 4 + 17; + let row = []; + for (let i2 = 0; i2 < this.size; i2++) + row.push(false); + for (let i2 = 0; i2 < this.size; i2++) { + this.modules.push(row.slice()); + this.isFunction.push(row.slice()); + } + this.drawFunctionPatterns(); + const allCodewords = this.addEccAndInterleave(dataCodewords); + this.drawCodewords(allCodewords); + if (msk == -1) { + let minPenalty = 1e9; + for (let i2 = 0; i2 < 8; i2++) { + this.applyMask(i2); + this.drawFormatBits(i2); + const penalty = this.getPenaltyScore(); + if (penalty < minPenalty) { + msk = i2; + minPenalty = penalty; + } + this.applyMask(i2); + } + } + assert(0 <= msk && msk <= 7); + this.mask = msk; + this.applyMask(msk); + this.drawFormatBits(msk); + this.isFunction = []; + } + static encodeText(text, ecl) { + const segs = qrcodegen2.QrSegment.makeSegments(text); + return _QrCode.encodeSegments(segs, ecl); + } + static encodeBinary(data, ecl) { + const seg = qrcodegen2.QrSegment.makeBytes(data); + return _QrCode.encodeSegments([seg], ecl); + } + static encodeSegments(segs, ecl, minVersion = 1, maxVersion = 40, mask = -1, boostEcl = true) { + if (!(_QrCode.MIN_VERSION <= minVersion && minVersion <= maxVersion && maxVersion <= _QrCode.MAX_VERSION) || mask < -1 || mask > 7) + throw new RangeError("Invalid value"); + let version2; + let dataUsedBits; + for (version2 = minVersion; ; version2++) { + const dataCapacityBits2 = _QrCode.getNumDataCodewords(version2, ecl) * 8; + const usedBits = QrSegment.getTotalBits(segs, version2); + if (usedBits <= dataCapacityBits2) { + dataUsedBits = usedBits; + break; + } + if (version2 >= maxVersion) + throw new RangeError("Data too long"); + } + for (const newEcl of [_QrCode.Ecc.MEDIUM, _QrCode.Ecc.QUARTILE, _QrCode.Ecc.HIGH]) { + if (boostEcl && dataUsedBits <= _QrCode.getNumDataCodewords(version2, newEcl) * 8) + ecl = newEcl; + } + let bb = []; + for (const seg of segs) { + appendBits(seg.mode.modeBits, 4, bb); + appendBits(seg.numChars, seg.mode.numCharCountBits(version2), bb); + for (const b2 of seg.getData()) + bb.push(b2); + } + assert(bb.length == dataUsedBits); + const dataCapacityBits = _QrCode.getNumDataCodewords(version2, ecl) * 8; + assert(bb.length <= dataCapacityBits); + appendBits(0, Math.min(4, dataCapacityBits - bb.length), bb); + appendBits(0, (8 - bb.length % 8) % 8, bb); + assert(bb.length % 8 == 0); + for (let padByte = 236; bb.length < dataCapacityBits; padByte ^= 236 ^ 17) + appendBits(padByte, 8, bb); + let dataCodewords = []; + while (dataCodewords.length * 8 < bb.length) + dataCodewords.push(0); + bb.forEach((b2, i2) => dataCodewords[i2 >>> 3] |= b2 << 7 - (i2 & 7)); + return new _QrCode(version2, ecl, dataCodewords, mask); + } + getModule(x, y2) { + return 0 <= x && x < this.size && 0 <= y2 && y2 < this.size && this.modules[y2][x]; + } + getModules() { + return this.modules; + } + drawFunctionPatterns() { + for (let i2 = 0; i2 < this.size; i2++) { + this.setFunctionModule(6, i2, i2 % 2 == 0); + this.setFunctionModule(i2, 6, i2 % 2 == 0); + } + this.drawFinderPattern(3, 3); + this.drawFinderPattern(this.size - 4, 3); + this.drawFinderPattern(3, this.size - 4); + const alignPatPos = this.getAlignmentPatternPositions(); + const numAlign = alignPatPos.length; + for (let i2 = 0; i2 < numAlign; i2++) { + for (let j2 = 0; j2 < numAlign; j2++) { + if (!(i2 == 0 && j2 == 0 || i2 == 0 && j2 == numAlign - 1 || i2 == numAlign - 1 && j2 == 0)) + this.drawAlignmentPattern(alignPatPos[i2], alignPatPos[j2]); + } + } + this.drawFormatBits(0); + this.drawVersion(); + } + drawFormatBits(mask) { + const data = this.errorCorrectionLevel.formatBits << 3 | mask; + let rem = data; + for (let i2 = 0; i2 < 10; i2++) + rem = rem << 1 ^ (rem >>> 9) * 1335; + const bits = (data << 10 | rem) ^ 21522; + assert(bits >>> 15 == 0); + for (let i2 = 0; i2 <= 5; i2++) + this.setFunctionModule(8, i2, getBit(bits, i2)); + this.setFunctionModule(8, 7, getBit(bits, 6)); + this.setFunctionModule(8, 8, getBit(bits, 7)); + this.setFunctionModule(7, 8, getBit(bits, 8)); + for (let i2 = 9; i2 < 15; i2++) + this.setFunctionModule(14 - i2, 8, getBit(bits, i2)); + for (let i2 = 0; i2 < 8; i2++) + this.setFunctionModule(this.size - 1 - i2, 8, getBit(bits, i2)); + for (let i2 = 8; i2 < 15; i2++) + this.setFunctionModule(8, this.size - 15 + i2, getBit(bits, i2)); + this.setFunctionModule(8, this.size - 8, true); + } + drawVersion() { + if (this.version < 7) + return; + let rem = this.version; + for (let i2 = 0; i2 < 12; i2++) + rem = rem << 1 ^ (rem >>> 11) * 7973; + const bits = this.version << 12 | rem; + assert(bits >>> 18 == 0); + for (let i2 = 0; i2 < 18; i2++) { + const color = getBit(bits, i2); + const a2 = this.size - 11 + i2 % 3; + const b2 = Math.floor(i2 / 3); + this.setFunctionModule(a2, b2, color); + this.setFunctionModule(b2, a2, color); + } + } + drawFinderPattern(x, y2) { + for (let dy = -4; dy <= 4; dy++) { + for (let dx = -4; dx <= 4; dx++) { + const dist = Math.max(Math.abs(dx), Math.abs(dy)); + const xx = x + dx; + const yy = y2 + dy; + if (0 <= xx && xx < this.size && 0 <= yy && yy < this.size) + this.setFunctionModule(xx, yy, dist != 2 && dist != 4); + } + } + } + drawAlignmentPattern(x, y2) { + for (let dy = -2; dy <= 2; dy++) { + for (let dx = -2; dx <= 2; dx++) + this.setFunctionModule(x + dx, y2 + dy, Math.max(Math.abs(dx), Math.abs(dy)) != 1); + } + } + setFunctionModule(x, y2, isDark) { + this.modules[y2][x] = isDark; + this.isFunction[y2][x] = true; + } + addEccAndInterleave(data) { + const ver = this.version; + const ecl = this.errorCorrectionLevel; + if (data.length != _QrCode.getNumDataCodewords(ver, ecl)) + throw new RangeError("Invalid argument"); + const numBlocks = _QrCode.NUM_ERROR_CORRECTION_BLOCKS[ecl.ordinal][ver]; + const blockEccLen = _QrCode.ECC_CODEWORDS_PER_BLOCK[ecl.ordinal][ver]; + const rawCodewords = Math.floor(_QrCode.getNumRawDataModules(ver) / 8); + const numShortBlocks = numBlocks - rawCodewords % numBlocks; + const shortBlockLen = Math.floor(rawCodewords / numBlocks); + let blocks = []; + const rsDiv = _QrCode.reedSolomonComputeDivisor(blockEccLen); + for (let i2 = 0, k2 = 0; i2 < numBlocks; i2++) { + let dat = data.slice(k2, k2 + shortBlockLen - blockEccLen + (i2 < numShortBlocks ? 0 : 1)); + k2 += dat.length; + const ecc = _QrCode.reedSolomonComputeRemainder(dat, rsDiv); + if (i2 < numShortBlocks) + dat.push(0); + blocks.push(dat.concat(ecc)); + } + let result = []; + for (let i2 = 0; i2 < blocks[0].length; i2++) { + blocks.forEach((block, j2) => { + if (i2 != shortBlockLen - blockEccLen || j2 >= numShortBlocks) + result.push(block[i2]); + }); + } + assert(result.length == rawCodewords); + return result; + } + drawCodewords(data) { + if (data.length != Math.floor(_QrCode.getNumRawDataModules(this.version) / 8)) + throw new RangeError("Invalid argument"); + let i2 = 0; + for (let right = this.size - 1; right >= 1; right -= 2) { + if (right == 6) + right = 5; + for (let vert = 0; vert < this.size; vert++) { + for (let j2 = 0; j2 < 2; j2++) { + const x = right - j2; + const upward = (right + 1 & 2) == 0; + const y2 = upward ? this.size - 1 - vert : vert; + if (!this.isFunction[y2][x] && i2 < data.length * 8) { + this.modules[y2][x] = getBit(data[i2 >>> 3], 7 - (i2 & 7)); + i2++; + } + } + } + } + assert(i2 == data.length * 8); + } + applyMask(mask) { + if (mask < 0 || mask > 7) + throw new RangeError("Mask value out of range"); + for (let y2 = 0; y2 < this.size; y2++) { + for (let x = 0; x < this.size; x++) { + let invert; + switch (mask) { + case 0: + invert = (x + y2) % 2 == 0; + break; + case 1: + invert = y2 % 2 == 0; + break; + case 2: + invert = x % 3 == 0; + break; + case 3: + invert = (x + y2) % 3 == 0; + break; + case 4: + invert = (Math.floor(x / 3) + Math.floor(y2 / 2)) % 2 == 0; + break; + case 5: + invert = x * y2 % 2 + x * y2 % 3 == 0; + break; + case 6: + invert = (x * y2 % 2 + x * y2 % 3) % 2 == 0; + break; + case 7: + invert = ((x + y2) % 2 + x * y2 % 3) % 2 == 0; + break; + default: + throw new Error("Unreachable"); + } + if (!this.isFunction[y2][x] && invert) + this.modules[y2][x] = !this.modules[y2][x]; + } + } + } + getPenaltyScore() { + let result = 0; + for (let y2 = 0; y2 < this.size; y2++) { + let runColor = false; + let runX = 0; + let runHistory = [0, 0, 0, 0, 0, 0, 0]; + for (let x = 0; x < this.size; x++) { + if (this.modules[y2][x] == runColor) { + runX++; + if (runX == 5) + result += _QrCode.PENALTY_N1; + else if (runX > 5) + result++; + } else { + this.finderPenaltyAddHistory(runX, runHistory); + if (!runColor) + result += this.finderPenaltyCountPatterns(runHistory) * _QrCode.PENALTY_N3; + runColor = this.modules[y2][x]; + runX = 1; + } + } + result += this.finderPenaltyTerminateAndCount(runColor, runX, runHistory) * _QrCode.PENALTY_N3; + } + for (let x = 0; x < this.size; x++) { + let runColor = false; + let runY = 0; + let runHistory = [0, 0, 0, 0, 0, 0, 0]; + for (let y2 = 0; y2 < this.size; y2++) { + if (this.modules[y2][x] == runColor) { + runY++; + if (runY == 5) + result += _QrCode.PENALTY_N1; + else if (runY > 5) + result++; + } else { + this.finderPenaltyAddHistory(runY, runHistory); + if (!runColor) + result += this.finderPenaltyCountPatterns(runHistory) * _QrCode.PENALTY_N3; + runColor = this.modules[y2][x]; + runY = 1; + } + } + result += this.finderPenaltyTerminateAndCount(runColor, runY, runHistory) * _QrCode.PENALTY_N3; + } + for (let y2 = 0; y2 < this.size - 1; y2++) { + for (let x = 0; x < this.size - 1; x++) { + const color = this.modules[y2][x]; + if (color == this.modules[y2][x + 1] && color == this.modules[y2 + 1][x] && color == this.modules[y2 + 1][x + 1]) + result += _QrCode.PENALTY_N2; + } + } + let dark = 0; + for (const row of this.modules) + dark = row.reduce((sum, color) => sum + (color ? 1 : 0), dark); + const total = this.size * this.size; + const k2 = Math.ceil(Math.abs(dark * 20 - total * 10) / total) - 1; + assert(0 <= k2 && k2 <= 9); + result += k2 * _QrCode.PENALTY_N4; + assert(0 <= result && result <= 2568888); + return result; + } + getAlignmentPatternPositions() { + if (this.version == 1) + return []; + else { + const numAlign = Math.floor(this.version / 7) + 2; + const step = this.version == 32 ? 26 : Math.ceil((this.version * 4 + 4) / (numAlign * 2 - 2)) * 2; + let result = [6]; + for (let pos = this.size - 7; result.length < numAlign; pos -= step) + result.splice(1, 0, pos); + return result; + } + } + static getNumRawDataModules(ver) { + if (ver < _QrCode.MIN_VERSION || ver > _QrCode.MAX_VERSION) + throw new RangeError("Version number out of range"); + let result = (16 * ver + 128) * ver + 64; + if (ver >= 2) { + const numAlign = Math.floor(ver / 7) + 2; + result -= (25 * numAlign - 10) * numAlign - 55; + if (ver >= 7) + result -= 36; + } + assert(208 <= result && result <= 29648); + return result; + } + static getNumDataCodewords(ver, ecl) { + return Math.floor(_QrCode.getNumRawDataModules(ver) / 8) - _QrCode.ECC_CODEWORDS_PER_BLOCK[ecl.ordinal][ver] * _QrCode.NUM_ERROR_CORRECTION_BLOCKS[ecl.ordinal][ver]; + } + static reedSolomonComputeDivisor(degree) { + if (degree < 1 || degree > 255) + throw new RangeError("Degree out of range"); + let result = []; + for (let i2 = 0; i2 < degree - 1; i2++) + result.push(0); + result.push(1); + let root = 1; + for (let i2 = 0; i2 < degree; i2++) { + for (let j2 = 0; j2 < result.length; j2++) { + result[j2] = _QrCode.reedSolomonMultiply(result[j2], root); + if (j2 + 1 < result.length) + result[j2] ^= result[j2 + 1]; + } + root = _QrCode.reedSolomonMultiply(root, 2); + } + return result; + } + static reedSolomonComputeRemainder(data, divisor) { + let result = divisor.map((_2) => 0); + for (const b2 of data) { + const factor = b2 ^ result.shift(); + result.push(0); + divisor.forEach((coef, i2) => result[i2] ^= _QrCode.reedSolomonMultiply(coef, factor)); + } + return result; + } + static reedSolomonMultiply(x, y2) { + if (x >>> 8 != 0 || y2 >>> 8 != 0) + throw new RangeError("Byte out of range"); + let z2 = 0; + for (let i2 = 7; i2 >= 0; i2--) { + z2 = z2 << 1 ^ (z2 >>> 7) * 285; + z2 ^= (y2 >>> i2 & 1) * x; + } + assert(z2 >>> 8 == 0); + return z2; + } + finderPenaltyCountPatterns(runHistory) { + const n11 = runHistory[1]; + assert(n11 <= this.size * 3); + const core = n11 > 0 && runHistory[2] == n11 && runHistory[3] == n11 * 3 && runHistory[4] == n11 && runHistory[5] == n11; + return (core && runHistory[0] >= n11 * 4 && runHistory[6] >= n11 ? 1 : 0) + (core && runHistory[6] >= n11 * 4 && runHistory[0] >= n11 ? 1 : 0); + } + finderPenaltyTerminateAndCount(currentRunColor, currentRunLength, runHistory) { + if (currentRunColor) { + this.finderPenaltyAddHistory(currentRunLength, runHistory); + currentRunLength = 0; + } + currentRunLength += this.size; + this.finderPenaltyAddHistory(currentRunLength, runHistory); + return this.finderPenaltyCountPatterns(runHistory); + } + finderPenaltyAddHistory(currentRunLength, runHistory) { + if (runHistory[0] == 0) + currentRunLength += this.size; + runHistory.pop(); + runHistory.unshift(currentRunLength); + } + }; + let QrCode = _QrCode; + QrCode.MIN_VERSION = 1; + QrCode.MAX_VERSION = 40; + QrCode.PENALTY_N1 = 3; + QrCode.PENALTY_N2 = 3; + QrCode.PENALTY_N3 = 40; + QrCode.PENALTY_N4 = 10; + QrCode.ECC_CODEWORDS_PER_BLOCK = [ + [-1, 7, 10, 15, 20, 26, 18, 20, 24, 30, 18, 20, 24, 26, 30, 22, 24, 28, 30, 28, 28, 28, 28, 30, 30, 26, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30], + [-1, 10, 16, 26, 18, 24, 16, 18, 22, 22, 26, 30, 22, 22, 24, 24, 28, 28, 26, 26, 26, 26, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28], + [-1, 13, 22, 18, 26, 18, 24, 18, 22, 20, 24, 28, 26, 24, 20, 30, 24, 28, 28, 26, 30, 28, 30, 30, 30, 30, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30], + [-1, 17, 28, 22, 16, 22, 28, 26, 26, 24, 28, 24, 28, 22, 24, 24, 30, 28, 28, 26, 28, 30, 24, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30] + ]; + QrCode.NUM_ERROR_CORRECTION_BLOCKS = [ + [-1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 4, 4, 4, 4, 4, 6, 6, 6, 6, 7, 8, 8, 9, 9, 10, 12, 12, 12, 13, 14, 15, 16, 17, 18, 19, 19, 20, 21, 22, 24, 25], + [-1, 1, 1, 1, 2, 2, 4, 4, 4, 5, 5, 5, 8, 9, 9, 10, 10, 11, 13, 14, 16, 17, 17, 18, 20, 21, 23, 25, 26, 28, 29, 31, 33, 35, 37, 38, 40, 43, 45, 47, 49], + [-1, 1, 1, 2, 2, 4, 4, 6, 6, 8, 8, 8, 10, 12, 16, 12, 17, 16, 18, 21, 20, 23, 23, 25, 27, 29, 34, 34, 35, 38, 40, 43, 45, 48, 51, 53, 56, 59, 62, 65, 68], + [-1, 1, 1, 2, 4, 4, 4, 5, 6, 8, 8, 11, 11, 16, 16, 18, 16, 19, 21, 25, 25, 25, 34, 30, 32, 35, 37, 40, 42, 45, 48, 51, 54, 57, 60, 63, 66, 70, 74, 77, 81] + ]; + qrcodegen2.QrCode = QrCode; + function appendBits(val, len, bb) { + if (len < 0 || len > 31 || val >>> len != 0) + throw new RangeError("Value out of range"); + for (let i2 = len - 1; i2 >= 0; i2--) + bb.push(val >>> i2 & 1); + } + function getBit(x, i2) { + return (x >>> i2 & 1) != 0; + } + function assert(cond) { + if (!cond) + throw new Error("Assertion error"); + } + const _QrSegment = class { + constructor(mode, numChars, bitData) { + this.mode = mode; + this.numChars = numChars; + this.bitData = bitData; + if (numChars < 0) + throw new RangeError("Invalid argument"); + this.bitData = bitData.slice(); + } + static makeBytes(data) { + let bb = []; + for (const b2 of data) + appendBits(b2, 8, bb); + return new _QrSegment(_QrSegment.Mode.BYTE, data.length, bb); + } + static makeNumeric(digits) { + if (!_QrSegment.isNumeric(digits)) + throw new RangeError("String contains non-numeric characters"); + let bb = []; + for (let i2 = 0; i2 < digits.length; ) { + const n11 = Math.min(digits.length - i2, 3); + appendBits(parseInt(digits.substr(i2, n11), 10), n11 * 3 + 1, bb); + i2 += n11; + } + return new _QrSegment(_QrSegment.Mode.NUMERIC, digits.length, bb); + } + static makeAlphanumeric(text) { + if (!_QrSegment.isAlphanumeric(text)) + throw new RangeError("String contains unencodable characters in alphanumeric mode"); + let bb = []; + let i2; + for (i2 = 0; i2 + 2 <= text.length; i2 += 2) { + let temp = _QrSegment.ALPHANUMERIC_CHARSET.indexOf(text.charAt(i2)) * 45; + temp += _QrSegment.ALPHANUMERIC_CHARSET.indexOf(text.charAt(i2 + 1)); + appendBits(temp, 11, bb); + } + if (i2 < text.length) + appendBits(_QrSegment.ALPHANUMERIC_CHARSET.indexOf(text.charAt(i2)), 6, bb); + return new _QrSegment(_QrSegment.Mode.ALPHANUMERIC, text.length, bb); + } + static makeSegments(text) { + if (text == "") + return []; + else if (_QrSegment.isNumeric(text)) + return [_QrSegment.makeNumeric(text)]; + else if (_QrSegment.isAlphanumeric(text)) + return [_QrSegment.makeAlphanumeric(text)]; + else + return [_QrSegment.makeBytes(_QrSegment.toUtf8ByteArray(text))]; + } + static makeEci(assignVal) { + let bb = []; + if (assignVal < 0) + throw new RangeError("ECI assignment value out of range"); + else if (assignVal < 1 << 7) + appendBits(assignVal, 8, bb); + else if (assignVal < 1 << 14) { + appendBits(2, 2, bb); + appendBits(assignVal, 14, bb); + } else if (assignVal < 1e6) { + appendBits(6, 3, bb); + appendBits(assignVal, 21, bb); + } else + throw new RangeError("ECI assignment value out of range"); + return new _QrSegment(_QrSegment.Mode.ECI, 0, bb); + } + static isNumeric(text) { + return _QrSegment.NUMERIC_REGEX.test(text); + } + static isAlphanumeric(text) { + return _QrSegment.ALPHANUMERIC_REGEX.test(text); + } + getData() { + return this.bitData.slice(); + } + static getTotalBits(segs, version2) { + let result = 0; + for (const seg of segs) { + const ccbits = seg.mode.numCharCountBits(version2); + if (seg.numChars >= 1 << ccbits) + return Infinity; + result += 4 + ccbits + seg.bitData.length; + } + return result; + } + static toUtf8ByteArray(str) { + str = encodeURI(str); + let result = []; + for (let i2 = 0; i2 < str.length; i2++) { + if (str.charAt(i2) != "%") + result.push(str.charCodeAt(i2)); + else { + result.push(parseInt(str.substr(i2 + 1, 2), 16)); + i2 += 2; + } + } + return result; + } + }; + let QrSegment = _QrSegment; + QrSegment.NUMERIC_REGEX = /^[0-9]*$/; + QrSegment.ALPHANUMERIC_REGEX = /^[A-Z0-9 $%*+.\/:-]*$/; + QrSegment.ALPHANUMERIC_CHARSET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:"; + qrcodegen2.QrSegment = QrSegment; +})(qrcodegen || (qrcodegen = {})); +((qrcodegen2) => { + ((QrCode2) => { + const _Ecc = class { + constructor(ordinal, formatBits) { + this.ordinal = ordinal; + this.formatBits = formatBits; + } + }; + let Ecc = _Ecc; + Ecc.LOW = new _Ecc(0, 1); + Ecc.MEDIUM = new _Ecc(1, 0); + Ecc.QUARTILE = new _Ecc(2, 3); + Ecc.HIGH = new _Ecc(3, 2); + QrCode2.Ecc = Ecc; + })(qrcodegen2.QrCode || (qrcodegen2.QrCode = {})); +})(qrcodegen || (qrcodegen = {})); +((qrcodegen2) => { + ((QrSegment2) => { + const _Mode = class { + constructor(modeBits, numBitsCharCount) { + this.modeBits = modeBits; + this.numBitsCharCount = numBitsCharCount; + } + numCharCountBits(ver) { + return this.numBitsCharCount[Math.floor((ver + 7) / 17)]; + } + }; + let Mode = _Mode; + Mode.NUMERIC = new _Mode(1, [10, 12, 14]); + Mode.ALPHANUMERIC = new _Mode(2, [9, 11, 13]); + Mode.BYTE = new _Mode(4, [8, 16, 16]); + Mode.KANJI = new _Mode(8, [8, 10, 12]); + Mode.ECI = new _Mode(7, [0, 0, 0]); + QrSegment2.Mode = Mode; + })(qrcodegen2.QrSegment || (qrcodegen2.QrSegment = {})); +})(qrcodegen || (qrcodegen = {})); +var qrcodegen_default = qrcodegen; +/** + * @license qrcode.react + * Copyright (c) Paul O'Shannessy + * SPDX-License-Identifier: ISC + */ +var ERROR_LEVEL_MAP = { + L: qrcodegen_default.QrCode.Ecc.LOW, + M: qrcodegen_default.QrCode.Ecc.MEDIUM, + Q: qrcodegen_default.QrCode.Ecc.QUARTILE, + H: qrcodegen_default.QrCode.Ecc.HIGH +}; +var DEFAULT_SIZE = 128; +var DEFAULT_LEVEL = "L"; +var DEFAULT_BGCOLOR = "#FFFFFF"; +var DEFAULT_FGCOLOR = "#000000"; +var DEFAULT_INCLUDEMARGIN = false; +var MARGIN_SIZE = 4; +var DEFAULT_IMG_SCALE = 0.1; +function generatePath(modules, margin = 0) { + const ops = []; + modules.forEach(function(row, y2) { + let start = null; + row.forEach(function(cell, x) { + if (!cell && start !== null) { + ops.push(`M${start + margin} ${y2 + margin}h${x - start}v1H${start + margin}z`); + start = null; + return; + } + if (x === row.length - 1) { + if (!cell) { + return; + } + if (start === null) { + ops.push(`M${x + margin},${y2 + margin} h1v1H${x + margin}z`); + } else { + ops.push(`M${start + margin},${y2 + margin} h${x + 1 - start}v1H${start + margin}z`); + } + return; + } + if (cell && start === null) { + start = x; + } + }); + }); + return ops.join(""); +} +function excavateModules(modules, excavation) { + return modules.slice().map((row, y2) => { + if (y2 < excavation.y || y2 >= excavation.y + excavation.h) { + return row; + } + return row.map((cell, x) => { + if (x < excavation.x || x >= excavation.x + excavation.w) { + return cell; + } + return false; + }); + }); +} +function getImageSettings(cells, size, includeMargin, imageSettings) { + if (imageSettings == null) { + return null; + } + const margin = includeMargin ? MARGIN_SIZE : 0; + const numCells = cells.length + margin * 2; + const defaultSize = Math.floor(size * DEFAULT_IMG_SCALE); + const scale = numCells / size; + const w = (imageSettings.width || defaultSize) * scale; + const h2 = (imageSettings.height || defaultSize) * scale; + const x = imageSettings.x == null ? cells.length / 2 - w / 2 : imageSettings.x * scale; + const y2 = imageSettings.y == null ? cells.length / 2 - h2 / 2 : imageSettings.y * scale; + let excavation = null; + if (imageSettings.excavate) { + let floorX = Math.floor(x); + let floorY = Math.floor(y2); + let ceilW = Math.ceil(w + x - floorX); + let ceilH = Math.ceil(h2 + y2 - floorY); + excavation = { x: floorX, y: floorY, w: ceilW, h: ceilH }; + } + return { x, y: y2, h: h2, w, excavation }; +} +(function() { + try { + new Path2D().addPath(new Path2D()); + } catch (e2) { + return false; + } + return true; +})(); +function QRCodeSVG(props) { + const _a = props, { + value, + size = DEFAULT_SIZE, + level = DEFAULT_LEVEL, + bgColor = DEFAULT_BGCOLOR, + fgColor = DEFAULT_FGCOLOR, + includeMargin = DEFAULT_INCLUDEMARGIN, + imageSettings + } = _a, otherProps = __objRest(_a, [ + "value", + "size", + "level", + "bgColor", + "fgColor", + "includeMargin", + "imageSettings" + ]); + let cells = qrcodegen_default.QrCode.encodeText(value, ERROR_LEVEL_MAP[level]).getModules(); + const margin = includeMargin ? MARGIN_SIZE : 0; + const numCells = cells.length + margin * 2; + const calculatedImageSettings = getImageSettings(cells, size, includeMargin, imageSettings); + let image = null; + if (imageSettings != null && calculatedImageSettings != null) { + if (calculatedImageSettings.excavation != null) { + cells = excavateModules(cells, calculatedImageSettings.excavation); + } + image = /* @__PURE__ */ W$1.createElement("image", { + xlinkHref: imageSettings.src, + height: calculatedImageSettings.h, + width: calculatedImageSettings.w, + x: calculatedImageSettings.x + margin, + y: calculatedImageSettings.y + margin, + preserveAspectRatio: "none" + }); + } + const fgPath = generatePath(cells, margin); + return /* @__PURE__ */ W$1.createElement("svg", __spreadValues({ + height: size, + width: size, + viewBox: `0 0 ${numCells} ${numCells}` + }, otherProps), /* @__PURE__ */ W$1.createElement("path", { + fill: bgColor, + d: `M0,0 h${numCells}v${numCells}H0z`, + shapeRendering: "crispEdges" + }), /* @__PURE__ */ W$1.createElement("path", { + fill: fgColor, + d: fgPath, + shapeRendering: "crispEdges" + }), image); +} +function n$5(n11, e2) { + if (e2 == null || e2 > n11.length) + e2 = n11.length; + for (var a2 = 0, t3 = new Array(e2); a2 < e2; a2++) + t3[a2] = n11[a2]; + return t3; +} +function e$5(n11) { + if (Array.isArray(n11)) + return n11; +} +function a$5(n11, e2, a2, t3, i2, r2, o2) { + try { + var d2 = n11[r2](o2); + var l2 = d2.value; + } catch (n12) { + a2(n12); + return; + } + if (d2.done) { + e2(l2); + } else { + Promise.resolve(l2).then(t3, i2); + } +} +function t$5(n11) { + return function() { + var e2 = this, t3 = arguments; + return new Promise(function(i2, r2) { + var o2 = n11.apply(e2, t3); + function d2(n12) { + a$5(o2, i2, r2, d2, l2, "next", n12); + } + function l2(n12) { + a$5(o2, i2, r2, d2, l2, "throw", n12); + } + d2(void 0); + }); + }; +} +function i$5(n11, e2, a2) { + if (e2 in n11) { + Object.defineProperty(n11, e2, { value: a2, enumerable: true, configurable: true, writable: true }); + } else { + n11[e2] = a2; + } + return n11; +} +function r$5(n11, e2) { + var a2 = n11 == null ? null : typeof Symbol !== "undefined" && n11[Symbol.iterator] || n11["@@iterator"]; + if (a2 == null) + return; + var t3 = []; + var i2 = true; + var r2 = false; + var o2, d2; + try { + for (a2 = a2.call(n11); !(i2 = (o2 = a2.next()).done); i2 = true) { + t3.push(o2.value); + if (e2 && t3.length === e2) + break; + } + } catch (n12) { + r2 = true; + d2 = n12; + } finally { + try { + if (!i2 && a2["return"] != null) + a2["return"](); + } finally { + if (r2) + throw d2; + } + } + return t3; +} +function o$5() { + throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} +function d$2(n11) { + for (var e2 = 1; e2 < arguments.length; e2++) { + var a2 = arguments[e2] != null ? arguments[e2] : {}; + var t3 = Object.keys(a2); + if (typeof Object.getOwnPropertySymbols === "function") { + t3 = t3.concat(Object.getOwnPropertySymbols(a2).filter(function(n12) { + return Object.getOwnPropertyDescriptor(a2, n12).enumerable; + })); + } + t3.forEach(function(e3) { + i$5(n11, e3, a2[e3]); + }); + } + return n11; +} +function l$4(n11, e2) { + if (n11 == null) + return {}; + var a2 = c$5(n11, e2); + var t3, i2; + if (Object.getOwnPropertySymbols) { + var r2 = Object.getOwnPropertySymbols(n11); + for (i2 = 0; i2 < r2.length; i2++) { + t3 = r2[i2]; + if (e2.indexOf(t3) >= 0) + continue; + if (!Object.prototype.propertyIsEnumerable.call(n11, t3)) + continue; + a2[t3] = n11[t3]; + } + } + return a2; +} +function c$5(n11, e2) { + if (n11 == null) + return {}; + var a2 = {}; + var t3 = Object.keys(n11); + var i2, r2; + for (r2 = 0; r2 < t3.length; r2++) { + i2 = t3[r2]; + if (e2.indexOf(i2) >= 0) + continue; + a2[i2] = n11[i2]; + } + return a2; +} +function s$5(n11, a2) { + return e$5(n11) || r$5(n11, a2) || p$3(n11, a2) || o$5(); +} +function p$3(e2, a2) { + if (!e2) + return; + if (typeof e2 === "string") + return n$5(e2, a2); + var t3 = Object.prototype.toString.call(e2).slice(8, -1); + if (t3 === "Object" && e2.constructor) + t3 = e2.constructor.name; + if (t3 === "Map" || t3 === "Set") + return Array.from(t3); + if (t3 === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t3)) + return n$5(e2, a2); +} +function u$5(n11, e2) { + var a2, t3, i2, r2, o2 = { label: 0, sent: function() { + if (i2[0] & 1) + throw i2[1]; + return i2[1]; + }, trys: [], ops: [] }; + return r2 = { next: d2(0), "throw": d2(1), "return": d2(2) }, typeof Symbol === "function" && (r2[Symbol.iterator] = function() { + return this; + }), r2; + function d2(n12) { + return function(e3) { + return l2([n12, e3]); + }; + } + function l2(r3) { + if (a2) + throw new TypeError("Generator is already executing."); + while (o2) + try { + if (a2 = 1, t3 && (i2 = r3[0] & 2 ? t3["return"] : r3[0] ? t3["throw"] || ((i2 = t3["return"]) && i2.call(t3), 0) : t3.next) && !(i2 = i2.call(t3, r3[1])).done) + return i2; + if (t3 = 0, i2) + r3 = [r3[0] & 2, i2.value]; + switch (r3[0]) { + case 0: + case 1: + i2 = r3; + break; + case 4: + o2.label++; + return { value: r3[1], done: false }; + case 5: + o2.label++; + t3 = r3[1]; + r3 = [0]; + continue; + case 7: + r3 = o2.ops.pop(); + o2.trys.pop(); + continue; + default: + if (!(i2 = o2.trys, i2 = i2.length > 0 && i2[i2.length - 1]) && (r3[0] === 6 || r3[0] === 2)) { + o2 = 0; + continue; + } + if (r3[0] === 3 && (!i2 || r3[1] > i2[0] && r3[1] < i2[3])) { + o2.label = r3[1]; + break; + } + if (r3[0] === 6 && o2.label < i2[1]) { + o2.label = i2[1]; + i2 = r3; + break; + } + if (i2 && o2.label < i2[2]) { + o2.label = i2[2]; + o2.ops.push(r3); + break; + } + if (i2[2]) + o2.ops.pop(); + o2.trys.pop(); + continue; + } + r3 = e2.call(n11, o2); + } catch (n12) { + r3 = [6, n12]; + t3 = 0; + } finally { + a2 = i2 = 0; + } + if (r3[0] & 5) + throw r3[1]; + return { value: r3[0] ? r3[1] : void 0, done: true }; + } +} +var f$4 = "#binanceW3W-wrapper :is(.pointer-events-auto) {\n pointer-events: auto;\n}\n\n#binanceW3W-wrapper :is(.fixed) {\n position: fixed;\n}\n\n#binanceW3W-wrapper :is(.absolute) {\n position: absolute;\n}\n\n#binanceW3W-wrapper :is(.relative) {\n position: relative;\n}\n\n#binanceW3W-wrapper :is(.bottom-0) {\n bottom: 0px;\n}\n\n#binanceW3W-wrapper :is(.left-0) {\n left: 0px;\n}\n\n#binanceW3W-wrapper :is(.top-0) {\n top: 0px;\n}\n\n#binanceW3W-wrapper :is(.m-auto) {\n margin: auto;\n}\n\n#binanceW3W-wrapper :is(.mx-\\[4px\\]) {\n margin-left: 4px;\n margin-right: 4px;\n}\n\n#binanceW3W-wrapper :is(.mb-4) {\n margin-bottom: 1rem;\n}\n\n#binanceW3W-wrapper :is(.mb-6) {\n margin-bottom: 1.5rem;\n}\n\n#binanceW3W-wrapper :is(.ml-1) {\n margin-left: 0.25rem;\n}\n\n#binanceW3W-wrapper :is(.mt-6) {\n margin-top: 1.5rem;\n}\n\n#binanceW3W-wrapper :is(.mt-\\[35px\\]) {\n margin-top: 35px;\n}\n\n#binanceW3W-wrapper :is(.flex) {\n display: flex;\n}\n\n#binanceW3W-wrapper :is(.grid) {\n display: grid;\n}\n\n#binanceW3W-wrapper :is(.h-\\[200px\\]) {\n height: 200px;\n}\n\n#binanceW3W-wrapper :is(.h-\\[24px\\]) {\n height: 24px;\n}\n\n#binanceW3W-wrapper :is(.h-\\[40px\\]) {\n height: 40px;\n}\n\n#binanceW3W-wrapper :is(.h-\\[52px\\]) {\n height: 52px;\n}\n\n#binanceW3W-wrapper :is(.h-full) {\n height: 100%;\n}\n\n#binanceW3W-wrapper :is(.w-\\[150px\\]) {\n width: 150px;\n}\n\n#binanceW3W-wrapper :is(.w-\\[200px\\]) {\n width: 200px;\n}\n\n#binanceW3W-wrapper :is(.w-\\[20px\\]) {\n width: 20px;\n}\n\n#binanceW3W-wrapper :is(.w-\\[24px\\]) {\n width: 24px;\n}\n\n#binanceW3W-wrapper :is(.w-\\[343px\\]) {\n width: 343px;\n}\n\n#binanceW3W-wrapper :is(.w-\\[60px\\]) {\n width: 60px;\n}\n\n#binanceW3W-wrapper :is(.w-\\[75px\\]) {\n width: 75px;\n}\n\n#binanceW3W-wrapper :is(.w-full) {\n width: 100%;\n}\n\n#binanceW3W-wrapper :is(.transform) {\n transform: translate(var(--tw-translate-x), var(--tw-translate-y)) rotate(var(--tw-rotate)) skewX(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y));\n}\n\n#binanceW3W-wrapper :is(.cursor-pointer) {\n cursor: pointer;\n}\n\n#binanceW3W-wrapper :is(.grid-flow-col) {\n grid-auto-flow: column;\n}\n\n#binanceW3W-wrapper :is(.grid-cols-2) {\n grid-template-columns: repeat(2, minmax(0, 1fr));\n}\n\n#binanceW3W-wrapper :is(.items-center) {\n align-items: center;\n}\n\n#binanceW3W-wrapper :is(.justify-end) {\n justify-content: flex-end;\n}\n\n#binanceW3W-wrapper :is(.justify-center) {\n justify-content: center;\n}\n\n#binanceW3W-wrapper :is(.justify-between) {\n justify-content: space-between;\n}\n\n#binanceW3W-wrapper :is(.gap-x-4) {\n -moz-column-gap: 1rem;\n column-gap: 1rem;\n}\n\n#binanceW3W-wrapper :is(.gap-y-2) {\n row-gap: 0.5rem;\n}\n\n#binanceW3W-wrapper :is(.rounded) {\n border-radius: 0.25rem;\n}\n\n#binanceW3W-wrapper :is(.rounded-2xl) {\n border-radius: 1rem;\n}\n\n#binanceW3W-wrapper :is(.rounded-lg) {\n border-radius: 0.5rem;\n}\n\n#binanceW3W-wrapper :is(.rounded-t-2xl) {\n border-top-left-radius: 1rem;\n border-top-right-radius: 1rem;\n}\n\n#binanceW3W-wrapper :is(.border) {\n border-width: 1px;\n}\n\n#binanceW3W-wrapper :is(.border-b) {\n border-bottom-width: 1px;\n}\n\n#binanceW3W-wrapper :is(.border-gray-300) {\n --tw-border-opacity: 1;\n border-color: rgb(209 213 219 / var(--tw-border-opacity));\n}\n\n#binanceW3W-wrapper :is(.bg-black\\/\\[\\.80\\]) {\n background-color: rgb(0 0 0 / .80);\n}\n\n#binanceW3W-wrapper :is(.bg-white) {\n --tw-bg-opacity: 1;\n background-color: rgb(255 255 255 / var(--tw-bg-opacity));\n}\n\n#binanceW3W-wrapper :is(.p-\\[12px\\]) {\n padding: 12px;\n}\n\n#binanceW3W-wrapper :is(.px-4) {\n padding-left: 1rem;\n padding-right: 1rem;\n}\n\n#binanceW3W-wrapper :is(.px-6) {\n padding-left: 1.5rem;\n padding-right: 1.5rem;\n}\n\n#binanceW3W-wrapper :is(.py-3) {\n padding-top: 0.75rem;\n padding-bottom: 0.75rem;\n}\n\n#binanceW3W-wrapper :is(.py-4) {\n padding-top: 1rem;\n padding-bottom: 1rem;\n}\n\n#binanceW3W-wrapper :is(.pb-6) {\n padding-bottom: 1.5rem;\n}\n\n#binanceW3W-wrapper :is(.pt-\\[20px\\]) {\n padding-top: 20px;\n}\n\n#binanceW3W-wrapper :is(.text-center) {\n text-align: center;\n}\n\n#binanceW3W-wrapper :is(.text-base) {\n font-size: 1rem;\n line-height: 1.5rem;\n}\n\n#binanceW3W-wrapper :is(.font-medium) {\n font-weight: 500;\n}\n\n#binanceW3W-wrapper :is(.text-\\[\\#1E2329\\]) {\n --tw-text-opacity: 1;\n color: rgb(30 35 41 / var(--tw-text-opacity));\n}\n\n#binanceW3W-wrapper :is(.text-\\[\\#929AA5\\]) {\n --tw-text-opacity: 1;\n color: rgb(146 154 165 / var(--tw-text-opacity));\n}\n\n#binanceW3W-wrapper :is(.shadow-inner) {\n --tw-shadow: inset 0 2px 4px 0 rgb(0 0 0 / 0.05);\n --tw-shadow-colored: inset 0 2px 4px 0 var(--tw-shadow-color);\n box-shadow: var(--tw-ring-offset-shadow, 0 0 #0000), var(--tw-ring-shadow, 0 0 #0000), var(--tw-shadow);\n}\n\n#binanceW3W-wrapper :is(.duration-300) {\n transition-duration: 300ms;\n}\n\n#binanceW3W-wrapper :is(.ease-in-out) {\n transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);\n}\n\n#binanceW3W-wrapper :is(.will-change-auto) {\n will-change: auto;\n}\n\n#binanceW3W-wrapper :is(.will-change-transform) {\n will-change: transform;\n}\n\n.w3w-body3 {\n font-size: 14px;\n font-style: normal;\n font-weight: 400;\n line-height: 20px;\n}\n\n.w3w-subtitle1 {\n font-size: 20px;\n font-style: normal;\n font-weight: 600;\n line-height: 28px;\n}\n\n.w3w-subtitle3 {\n font-size: 16px;\n font-style: normal;\n font-weight: 500;\n line-height: 24px;\n /* 150% */\n}\n\n.w3w-caption2 {\n font-size: 12px;\n font-style: normal;\n font-weight: 400;\n line-height: 16px;\n}\n\n.w3w-t-black {\n color: #0b0e11;\n}\n\n.w3w-t-brand {\n color: #c99400;\n}\n\n.w3w-t-primary {\n color: #202630;\n}\n\n.w3w-t-secondary {\n color: #474d57;\n}\n\n.w3w-bg-primary {\n background: #fcd535;\n}\n\n@media (min-width: 768px) {\n .md\\:w3w-subtitle1 {\n font-size: 20px;\n font-style: normal;\n font-weight: 600;\n line-height: 28px;\n }\n\n #binanceW3W-wrapper :is(.md\\:w-\\[400px\\]) {\n width: 400px;\n }\n\n #binanceW3W-wrapper :is(.md\\:font-semibold) {\n font-weight: 600;\n }\n}\n\n@media (min-width: 1024px) {\n #binanceW3W-wrapper :is(.lg\\:p-8) {\n padding: 2rem;\n }\n\n #binanceW3W-wrapper :is(.lg\\:pt-6) {\n padding-top: 1.5rem;\n }\n\n #binanceW3W-wrapper :is(.lg\\:text-xl) {\n font-size: 1.25rem;\n line-height: 1.75rem;\n }\n}\n"; +var b$3 = "\n".concat(f$4, "\n\n:root {\n --animation-duration: 300ms;\n}\n\n@keyframes w3w-fadeIn {\n from {\n opacity: 0;\n }\n to {\n opacity: 1;\n }\n}\n\n@keyframes w3w-fadeOut {\n from {\n opacity: 1;\n }\n to {\n opacity: 0;\n }\n}\n\n.w3w-animated {\n animation-duration: var(--animation-duration);\n animation-fill-mode: both;\n}\n\n.w3w-fadeIn {\n animation-name: w3w-fadeIn;\n}\n\n.w3w-fadeOut {\n animation-name: w3w-fadeOut;\n}\n\n#binanceW3W-wrapper {\n -webkit-user-select: none;\n align-items: center;\n display: flex;\n height: 100%;\n justify-content: center;\n left: 0;\n pointer-events: none;\n position: fixed;\n top: 0;\n user-select: none;\n width: 100%;\n z-index: 99999999999999;\n}\n"); +var h$4 = reactExports.createContext({}), y$4 = function() { + return reactExports.useContext(h$4); +}; +var C = "binanceW3W-wrapper", A = "binanceW3W-qrcode-modal", M = { googlePlay: "https://app.appsflyer.com/com.binance.dev?pid=https%3A%2F%2Fwww.binance.com%2Fen&c=https%3A%2F%2Fwww.binance.com%2Fen", appleStore: "https://app.appsflyer.com/id1436799971?pid=https%3A%2F%2Fwww.binance.com%2Fen&c=https%3A%2F%2Fwww.binance.com%2Fen" }, S = "PHN2ZyB3aWR0aD0iNTYiIGhlaWdodD0iNTYiIHZpZXdCb3g9IjAgMCA1NiA1NiIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHJlY3QgeD0iMiIgeT0iMiIgd2lkdGg9IjUyIiBoZWlnaHQ9IjUyIiByeD0iMTAiIGZpbGw9IiMxNDE1MUEiIHN0cm9rZT0id2hpdGUiIHN0cm9rZS13aWR0aD0iNCIvPgo8cGF0aCBkPSJNMTIgMjhMMTUuNjEyOSAyNC4zODcxTDE5LjIyNTggMjhMMTUuNjEyOSAzMS42MTI5TDEyIDI4WiIgZmlsbD0iI0YwQjkwQiIvPgo8cGF0aCBkPSJNMTguMTkzNSAyMS44MDY1TDI4IDEyTDM3LjgwNjUgMjEuODA2NUwzNC4xOTM2IDI1LjQxOTRMMjggMTkuMjI1OEwyMS44MDY1IDI1LjQxOTRMMTguMTkzNSAyMS44MDY1WiIgZmlsbD0iI0YwQjkwQiIvPgo8cGF0aCBkPSJNMjQuMzg3MSAyOEwyOCAyNC4zODcxTDMxLjYxMjkgMjhMMjggMzEuNjEyOUwyNC4zODcxIDI4WiIgZmlsbD0iI0YwQjkwQiIvPgo8cGF0aCBkPSJNMjEuODA2NSAzMC41ODA2TDE4LjE5MzUgMzQuMTkzNUwyOCA0NEwzNy44MDY1IDM0LjE5MzVMMzQuMTkzNiAzMC41ODA2TDI4IDM2Ljc3NDJMMjEuODA2NSAzMC41ODA2WiIgZmlsbD0iI0YwQjkwQiIvPgo8cGF0aCBkPSJNMzYuNzc0MiAyOEw0MC4zODcxIDI0LjM4NzFMNDQgMjhMNDAuMzg3MSAzMS42MTI5TDM2Ljc3NDIgMjhaIiBmaWxsPSIjRjBCOTBCIi8+Cjwvc3ZnPgo=", I$1 = "data:image/svg+xml;base64,".concat(S); +var z = function() { + var n11 = s$5(reactExports.useState(), 2), e2 = n11[0], a2 = n11[1], t3 = s$5(reactExports.useState(false), 2), i2 = t3[0], r2 = t3[1]; + return reactExports.useEffect(function() { + var n12 = rP(), e3 = rT(); + a2(n12), r2(e3); + }, []), { isMobile: e2, isAndroid: i2 }; +}; +var P = ["en", "ar", "bg-BG", "zh-CN", "zh-TW", "cs-CZ", "fr-FR", "de-DE", "el-GR", "id-ID", "it-IT", "kk-KZ", "lv-LV", "pl-PL", "pt-BR", "pt-PT", "ro-RO", "ru-RU", "sk-SK", "sl-SI", "es-LA", "es-ES", "sv-SE", "tr-TR", "uk-UA", "vi-VN", "da-DK", "my-MM", "lo-LA", "si-LK"]; +var H = { "sdk-download-android": "تنزيل لنظام Android", "sdk-connect": "اتصال", "sdk-download-ios": "تنزيل لنظام iOS", "sdk-install": "تثبيت", "sdk-modal-instruct-1": "1. افتح تطبيق Binance", "sdk-modal-instruct-2": "2. اضغط {{icon}} على الشاشة الرئيسية", "sdk-modal-title": "الربط مع Binance (بينانس)", "sdk-no-app": "ليس لديك تطبيق Binance حتّى الآن؟" }; +var F$1 = { "sdk-download-android": "Изтегляне за Android", "sdk-connect": "Свържи", "sdk-download-ios": "Изтегляне за iOS", "sdk-install": "Инсталиране", "sdk-modal-instruct-1": "1. Отворете приложението Binance", "sdk-modal-instruct-2": "2. Докоснете {{icon}} на началния екран", "sdk-modal-title": "Свържете се с Binance", "sdk-no-app": "Все още нямате приложението Binance?" }; +var Z = { "sdk-download-android": "Stáhnout pro Android", "sdk-connect": "Připojit", "sdk-download-ios": "Stáhnout pro iOS", "sdk-install": "Instalovat", "sdk-modal-instruct-1": "1. Otevřete aplikaci Binance", "sdk-modal-instruct-2": "2. Klepněte na {{icon}} na domovské obrazovce", "sdk-modal-title": "Připojit platformu Binance", "sdk-no-app": "Ještě nemáte aplikaci Binance?" }; +var V$1 = { "sdk-download-android": "Download til Android", "sdk-connect": "Forbind", "sdk-download-ios": "Download til iOS", "sdk-install": "Installer", "sdk-modal-instruct-1": "1. Åbn Binance-appen", "sdk-modal-instruct-2": "2. Tryk på {{icon}} på startskærmen", "sdk-modal-title": "Forbind til Binance", "sdk-no-app": "Har du ikke Binance-appen endnu?" }; +var R = { "sdk-download-android": "Für Android herunterladen", "sdk-connect": "Verbinden", "sdk-download-ios": "Für iOS herunterladen", "sdk-install": "Installieren", "sdk-modal-instruct-1": "1. Binance-App öffnen", "sdk-modal-instruct-2": "2. Tippe auf dem Startbildschirm auf {{icon}}", "sdk-modal-title": "Mit Binance verknüpfen", "sdk-no-app": "Du hast die Binance-App noch nicht?" }; +var U$1 = { "sdk-download-android": "Λήψη για Android", "sdk-connect": "Συνδεθείτε", "sdk-download-ios": "Λήψη για iOS", "sdk-install": "Εγκατάσταση", "sdk-modal-instruct-1": "1. Ανοίξτε την εφαρμογή Binance", "sdk-modal-instruct-2": "2. Πατήστε {{icon}} στην αρχική οθόνη", "sdk-modal-title": "Συνδεθείτε με την Binance", "sdk-no-app": "Δεν έχετε ακόμα την εφαρμογή Binance;" }; +var Q$1 = { "sdk-download-android": "Download for Android", "sdk-connect": "Connect", "sdk-download-ios": "Download for iOS", "sdk-install": "Install", "sdk-modal-instruct-1": "1. Open Binance app", "sdk-modal-instruct-2": "2. Tap {{icon}} on Home Screen", "sdk-modal-title": "Connect With Binance", "sdk-no-app": "Don’t have the Binance app yet?" }; +var G = { "sdk-download-android": "Descargar para Android", "sdk-connect": "Conectar", "sdk-download-ios": "Descargar para iOS", "sdk-install": "Instalar", "sdk-modal-instruct-1": "1. Open Binance app", "sdk-modal-instruct-2": "2. Pulsa en {{icon}} en la página principal", "sdk-modal-title": "Connect With Binance", "sdk-no-app": "¿Aún no tienes la aplicación de Binance?" }; +var Y$1 = { "sdk-download-android": "Descargar para Android", "sdk-connect": "Conecta", "sdk-download-ios": "Descargar para iOS", "sdk-install": "Instala", "sdk-modal-instruct-1": "1. Abre la aplicación de Binance", "sdk-modal-instruct-2": "2. Toca {{icon}} en la pantalla de inicio", "sdk-modal-title": "Conectar con Binance", "sdk-no-app": "¿Aún no tienes la aplicación de Binance?" }; +var K = { "sdk-download-android": "Télécharger pour Android", "sdk-connect": "Se connecter", "sdk-download-ios": "Télécharger pour iOS", "sdk-install": "Installer", "sdk-modal-instruct-1": "1. Ouvrez l’application de Binance", "sdk-modal-instruct-2": "2. Appuyez sur {{icon}} sur l’écran d’accueil", "sdk-modal-title": "Se connecter à Binance", "sdk-no-app": "Vous n’avez pas encore l’application de Binance ?" }; +var J = { "sdk-download-android": "Unduh untuk Android", "sdk-connect": "Terhubung", "sdk-download-ios": "Unduh untuk iOS", "sdk-install": "Instal", "sdk-modal-instruct-1": "1. Buka aplikasi Binance", "sdk-modal-instruct-2": "2. Ketuk {{icon}} di Layar Beranda", "sdk-modal-title": "Hubungkan dengan Binance", "sdk-no-app": "Belum punya aplikasi Binance?" }; +var q = { "sdk-download-android": "Scarica per Android", "sdk-connect": "Collega", "sdk-download-ios": "Scarica per iOS", "sdk-install": "Installa", "sdk-modal-instruct-1": "1. Apri l'app Binance", "sdk-modal-instruct-2": "2. Tocca {{icon}} nella homepage", "sdk-modal-title": "Collega con Binance", "sdk-no-app": "Non hai ancora l'app Binance?" }; +var _$1 = { "sdk-download-android": "Android үшін жүктеп алу", "sdk-connect": "Қосылу", "sdk-download-ios": "iOS үшін жүктеп алу", "sdk-install": "Орнату", "sdk-modal-instruct-1": "1. Binance қолданбасын ашыңыз", "sdk-modal-instruct-2": "2. Басты экрандағы {{icon}} белгішесін түртіңіз", "sdk-modal-title": "Binance платформасымен байланыстыру", "sdk-no-app": "Сізде әлі Binance қолданбасы жоқ па?" }; +var X = { "sdk-download-android": "ດາວໂຫຼດສໍາລັບ Android", "sdk-connect": "ເຊື່ອມຕໍ່", "sdk-download-ios": "ດາວໂຫຼດສໍາລັບ iOS", "sdk-install": "ຕິດຕັ້ງ", "sdk-modal-instruct-1": "1. ເປີດແອັບ Binance", "sdk-modal-instruct-2": "2. ແຕະ {{icon}} ໃນໜ້າຈໍຫຼັກ", "sdk-modal-title": "ເຊື່ອມຕໍ່ກັບ Binance", "sdk-no-app": "ຍັງບໍ່ມີແອັບ Binance ເທື່ອບໍ?" }; +var $ = { "sdk-download-android": "Lejupielādēt Android ierīcei", "sdk-connect": "Savienot", "sdk-download-ios": "Lejupielādēt iOS ierīcei", "sdk-install": "Instalēt", "sdk-modal-instruct-1": "1. Atver Binance lietotni", "sdk-modal-instruct-2": "2. Pieskaries pie {{icon}} sākuma ekrānā", "sdk-modal-title": "Savieno ar Binance", "sdk-no-app": "Vai tev vēl nav Binance lietotnes?" }; +var nn = { "sdk-download-android": "အန်းဒရွိုက်အတွက် ဒေါင်းလုဒ်လုပ်မည်", "sdk-connect": "ချိတ်ဆက်မည်", "sdk-download-ios": "iOS အတွက် ဒေါင်းလုဒ်လုပ်မည်", "sdk-install": "ထည့်သွင်းမည်", "sdk-modal-instruct-1": "1. Open Binance app", "sdk-modal-instruct-2": "ပင်မမျက်နှာပြင်မှ {{icon}} ကိုနှိပ်ပါ။", "sdk-modal-title": "Connect With Binance", "sdk-no-app": "Binance App မရှိသေးဘူးလား။" }; +var ne = { "sdk-download-android": "Pobierz na Androida", "sdk-connect": "Połącz", "sdk-download-ios": "Pobierz na iOS", "sdk-install": "Zainstaluj", "sdk-modal-instruct-1": "1. Otwórz Aplikację Binance", "sdk-modal-instruct-2": "2. Kliknij {{icon}} na ekranie głównym", "sdk-modal-title": "Połącz z Binance", "sdk-no-app": "Nie masz jeszcze aplikacji Binance?" }; +var na = { "sdk-download-android": "Baixar para Android", "sdk-connect": "Conecte", "sdk-download-ios": "Baixar para iOS", "sdk-install": "Instalar", "sdk-modal-instruct-1": "1. Abra o Aplicativo da Binance", "sdk-modal-instruct-2": "2. Toque em {{icon}} na Tela Inicial", "sdk-modal-title": "Conectar com a Binance", "sdk-no-app": "Ainda não tem o aplicativo da Binance?" }; +var nt = { "sdk-download-android": "Transferir para Android", "sdk-connect": "Associar", "sdk-download-ios": "Transferir para iOS", "sdk-install": "Instalar", "sdk-modal-instruct-1": "1. Abre a aplicação Binance", "sdk-modal-instruct-2": "2. Toca em {{icon}} no Ecrã Inicial", "sdk-modal-title": "Associa com a Binance", "sdk-no-app": "Ainda não tens a aplicação Binance?" }; +var ni = { "sdk-download-android": "Descărcați pentru Android", "sdk-connect": "Conectare", "sdk-download-ios": "Descărcați pentru iOS", "sdk-install": "Instalați", "sdk-modal-instruct-1": "1. Deschideți aplicația Binance", "sdk-modal-instruct-2": "2. Atingeți {{icon}} pe ecranul de pornire", "sdk-modal-title": "Conectați-vă cu Binance", "sdk-no-app": "Nu aveți încă aplicația Binance?" }; +var nr = { "sdk-download-android": "Скачать для Android", "sdk-connect": "Подключить", "sdk-download-ios": "Скачать для iOS", "sdk-install": "Установить", "sdk-modal-instruct-1": "1. Откройте приложение Binance", "sdk-modal-instruct-2": "2. Нажмите {{icon}} на главном экране", "sdk-modal-title": "Подключить кошелек Binance", "sdk-no-app": "У вас еще нет приложения Binance?" }; +var no = { "sdk-download-android": "Android සඳහා බාගත කරන්න", "sdk-connect": "සම්බන්ධ කරන්න", "sdk-download-ios": "iOS සඳහා බාගත කරන්න", "sdk-install": "ස්ථාපනය කරන්න", "sdk-modal-instruct-1": "1. Binance යෙදුම විවෘත කරන්න", "sdk-modal-instruct-2": "2. මුල් තිරයේ {{icon}} මත තට්ටු කරන්න", "sdk-modal-title": "Binance සමග සම්බන්ධ වන්න", "sdk-no-app": "තවමත් Binance යෙදුම නැති ද?" }; +var nd = { "sdk-download-android": "Stiahnuť pre Android", "sdk-connect": "Pripojiť", "sdk-download-ios": "Stiahnuť pre iOS", "sdk-install": "Nainštalovať", "sdk-modal-instruct-1": "1. Otvorte aplikáciu Binance", "sdk-modal-instruct-2": "2. Klepnite na ikonu {{icon}} na domovskej obrazovke", "sdk-modal-title": "Spojte sa s Binance", "sdk-no-app": "Ešte nemáte aplikáciu Binance?" }; +var nl = { "sdk-download-android": "Prenos za Android", "sdk-connect": "Poveži", "sdk-download-ios": "Prenos za iOS", "sdk-install": "Namesti", "sdk-modal-instruct-1": "1. Odprite aplikacijo Binance", "sdk-modal-instruct-2": "2. Tapnite {{icon}} na začetnem zaslonu", "sdk-modal-title": "Povežite se s platformo Binance", "sdk-no-app": "Še nimate aplikacije Binance?" }; +var nc = { "sdk-download-android": "Ladda ned för Android", "sdk-connect": "Anslut", "sdk-download-ios": "Ladda ned för iOS", "sdk-install": "Installera", "sdk-modal-instruct-1": "1. Öppna Binance-appen", "sdk-modal-instruct-2": "2. Tryck på {{icon}} på startskärmen", "sdk-modal-title": "Anslut med Binance", "sdk-no-app": "Har du inte Binance-appen ännu?" }; +var ns = { "sdk-download-android": "Android için indir", "sdk-connect": "Bağlan", "sdk-download-ios": "iOS için indir", "sdk-install": "Yükle", "sdk-modal-instruct-1": "1. Binance Uygulamasını Açın", "sdk-modal-instruct-2": "2. Ana Ekranda {{icon}} simgesine dokunun", "sdk-modal-title": "Binance ile Bağlanın", "sdk-no-app": "Henüz Binance uygulamanız yok mu?" }; +var np = { "sdk-download-android": "Завантажити для Android", "sdk-connect": "Підключитись", "sdk-download-ios": "Завантажити для iOS", "sdk-install": "Встановити", "sdk-modal-instruct-1": "1. Відкрийте застосунок Binance", "sdk-modal-instruct-2": "2. Торкніться {{icon}} на головному екрані", "sdk-modal-title": "Підключіться до Binance", "sdk-no-app": "Ще не маєте застосунку Binance?" }; +var nu = { "sdk-download-android": "Tải xuống cho Android", "sdk-connect": "Kết nối", "sdk-download-ios": "Tải xuống cho iOS", "sdk-install": "Cài đặt", "sdk-modal-instruct-1": "1. Mở ứng dụng Binance", "sdk-modal-instruct-2": "2. Nhấn vào {{icon}} trên Màn hình chính", "sdk-modal-title": "Kết nối với Binance", "sdk-no-app": "Bạn chưa có ứng dụng Binance?" }; +var nm = { "sdk-download-android": "下载安卓版", "sdk-connect": "关联", "sdk-download-ios": "下载iOS版", "sdk-install": "安装", "sdk-modal-instruct-1": "1.打开币安App", "sdk-modal-instruct-2": "2.点击主屏幕的{{icon}}", "sdk-modal-title": "关联币安", "sdk-no-app": "尚未安装币安App？" }; +var nw = { "sdk-download-android": "Android 下載", "sdk-connect": "連接", "sdk-download-ios": "iOS 下載", "sdk-install": "安裝", "sdk-modal-instruct-1": "1. 開啟幣安 App", "sdk-modal-instruct-2": "2. 在首頁畫面上點擊 {{icon}}", "sdk-modal-title": "與幣安連接", "sdk-no-app": "還沒有幣安 App 嗎？" }; +var nk = { en: Q$1, ar: H, "bg-BG": F$1, "zh-CN": nm, "zh-TW": nw, "cs-CZ": Z, "fr-FR": K, "de-DE": R, "el-GR": U$1, "id-ID": J, "it-IT": q, "kk-KZ": _$1, "lv-LV": $, "pl-PL": ne, "pt-BR": na, "pt-PT": nt, "ro-RO": ni, "ru-RU": nr, "sk-SK": nd, "sl-SI": nl, "es-LA": Y$1, "es-ES": G, "sv-SE": nc, "tr-TR": ns, "uk-UA": np, "vi-VN": nu, "da-DK": V$1, "my-MM": nn, "lo-LA": X, "si-LK": no }; +var nf = P.reduce(function(n11, e2) { + return n11[e2] = nk[e2], n11; +}, {}), nb = nf; +var nv = function() { + var n11 = y$4(), e2 = n11.lng; + return reactExports.useCallback(function(n12, a2) { + var t3, i2; + return (nb === null || nb === void 0 ? void 0 : (t3 = nb[e2]) === null || t3 === void 0 ? void 0 : t3[n12]) || (nb === null || nb === void 0 ? void 0 : (i2 = nb.en) === null || i2 === void 0 ? void 0 : i2[n12]) || (a2 === null || a2 === void 0 ? void 0 : a2.default) || n12; + }, [e2]); +}, ng = nv; +var nx = function(n11) { + var e2 = n11.size, a2 = e2 === void 0 ? 24 : e2, t3 = n11.color, i2 = t3 === void 0 ? "currentColor" : t3, r2 = n11.className, o2 = n11.children, c2 = l$4(n11, ["size", "color", "className", "children"]); + return W$1.createElement("svg", d$2({ width: a2, height: a2, fill: i2, className: r2, viewBox: "0 0 24 24", xmlns: "http://www.w3.org/2000/svg" }, c2), o2); +}, nW = nx; +var nB = function(n11) { + return W$1.createElement(nW, d$2({ size: 24 }, n11), W$1.createElement("path", { d: "M21.7725 18.7033C21.4062 19.5418 20.9727 20.3136 20.4704 21.0232C19.7857 21.9906 19.2251 22.6602 18.7931 23.032C18.1233 23.6424 17.4058 23.955 16.6374 23.9728C16.0857 23.9728 15.4205 23.8172 14.6461 23.5017C13.8692 23.1876 13.1552 23.032 12.5024 23.032C11.8177 23.032 11.0834 23.1876 10.2979 23.5017C9.51127 23.8172 8.87756 23.9816 8.39305 23.9979C7.65619 24.0291 6.92173 23.7076 6.1886 23.032C5.72069 22.6276 5.13542 21.9343 4.43429 20.9521C3.68203 19.9033 3.06358 18.687 2.57906 17.3004C2.06017 15.8026 1.80005 14.3523 1.80005 12.9482C1.80005 11.3398 2.15076 9.95259 2.85324 8.79011C3.40532 7.85636 4.13979 7.11979 5.05903 6.57906C5.97827 6.03834 6.97151 5.76279 8.04114 5.74516C8.62641 5.74516 9.39391 5.92456 10.3477 6.27715C11.2988 6.63091 11.9095 6.81032 12.1772 6.81032C12.3774 6.81032 13.0558 6.60054 14.2058 6.18233C15.2934 5.79449 16.2113 5.63391 16.9633 5.69716C19.0009 5.86012 20.5317 6.6561 21.5497 8.09013C19.7274 9.18432 18.826 10.7169 18.8439 12.6829C18.8603 14.2142 19.4209 15.4886 20.5227 16.5004C21.022 16.97 21.5796 17.333 22.2001 17.5907C22.0655 17.9774 21.9235 18.3477 21.7725 18.7033ZM17.0993 0.480137C17.0993 1.68041 16.6568 2.8011 15.7748 3.8384C14.7104 5.07155 13.4229 5.78412 12.0268 5.67168C12.009 5.52769 11.9987 5.37614 11.9987 5.21688C11.9987 4.06462 12.5049 2.83147 13.4038 1.82321C13.8526 1.3127 14.4234 0.888228 15.1155 0.549615C15.8062 0.216055 16.4595 0.031589 17.0739 0C17.0918 0.160458 17.0993 0.320926 17.0993 0.480121V0.480137Z", fill: "#1E2329" })); +}; +var nC = function(n11) { + return W$1.createElement(nW, d$2({ size: 24 }, n11), W$1.createElement("path", { d: "M13.5589 11.0874L4.08203 1.59644H4.17441C4.98558 1.59644 5.68614 1.89129 6.81073 2.4993L16.7488 7.88083L13.5589 11.0874Z", fill: "#202630" }), W$1.createElement("path", { d: "M12.6373 12.008L2.90218 21.7203C2.66236 21.3329 2.49658 20.7063 2.49658 19.8034V4.19354C2.49658 3.29078 2.66236 2.66403 2.90218 2.2771L12.6373 12.008Z", fill: "#202630" }), W$1.createElement("path", { d: "M13.5589 12.9124L16.7488 16.1187L6.81073 21.5001C5.68614 22.1083 4.98548 22.4036 4.17441 22.4036H4.08203L13.5589 12.9124Z", fill: "#202630" }), W$1.createElement("path", { d: "M17.9437 8.52563L14.4775 12.0091L17.9437 15.4738L20.0456 14.3309C20.8199 13.9069 22 13.1329 22 12.0091C22 10.8662 20.8199 10.0922 20.0456 9.66821L17.9437 8.52563Z", fill: "#202630" })); +}; +var nM = function(n11) { + return W$1.createElement(nW, d$2({ size: 24 }, n11), W$1.createElement("path", { fillRule: "evenodd", clipRule: "evenodd", d: "M7.5 4H10.5V7H7.5V10H4.5V7V4H7.5ZM14.5 4H17.5H20.5V7V10H17.5V7H14.5V4ZM10.5 20V17H7.5V14H4.5V17V20H7.5H10.5ZM17.5 20H14.5V17H17.5V14H20.5V17V20H17.5ZM16.5 10.5H8.5V13.5H16.5V10.5Z", fill: "#202630" })); +}; +var nI = function(n11) { + var e2 = n11.value, a2 = l$4(n11, ["value"]); + var t3 = nO(e2).map(function(n12) { + return typeof n12 == "string" ? n12 : W$1.cloneElement(a2[n12.key], { key: n12.key }); + }); + return W$1.createElement(W$1.Fragment, null, t3); +}, nO = function(n11) { + var e2 = /{{(.*?)}}/g, a2, t3 = 0, i2 = []; + for (; (a2 = e2.exec(n11)) !== null; ) + a2.index !== t3 && i2.push(n11.substring(t3, a2.index)), i2.push({ key: a2[1] }), t3 = e2.lastIndex; + return t3 !== n11.length && i2.push(n11.substring(t3)), i2; +}; +var nN = function() { + var n11 = ng(); + return W$1.createElement(W$1.Fragment, null, W$1.createElement(nj, { t: n11 }), W$1.createElement(nD, { t: n11 }), W$1.createElement(nz, null)); +}, nj = function(n11) { + var e2 = n11.t; + return W$1.createElement("div", { style: { borderBottom: "1px solid #EAECEF" }, className: "grid justify-center gap-y-2 pb-6 w3w-body3 w3w-t-black border-b border-gray-300" }, W$1.createElement("div", null, e2("sdk-modal-instruct-1", { default: "1. Open Binance app" })), W$1.createElement("div", { className: "flex items-center" }, W$1.createElement(nI, { value: e2("sdk-modal-instruct-2", { default: "2. Tap {{icon}} on Home" }), icon: W$1.createElement(nM, { className: "w-[24px] h-[24px] mx-[4px]" }) }))); +}, nD = function(n11) { + var e2 = n11.t; + return W$1.createElement("div", { className: "py-4 w3w-body3 w3w-t-secondary text-center" }, e2("sdk-no-app", { default: "Don't have Binance app yet?" })); +}, nz = function() { + return W$1.createElement("div", { className: "grid grid-cols-2 gap-x-4" }, W$1.createElement(nT, { type: "iOS" }), W$1.createElement(nT, { type: "Android" })); +}, nT = function(n11) { + var e2 = n11.type; + var a2 = ng(); + return W$1.createElement("div", { style: { border: "1px solid #EAECEF" }, className: "p-[12px] rounded-lg grid cursor-pointer w3w-t-secondary grid-flow-col items-center gap-x-4 w-[150px]", onClick: function() { + window.open(e2 === "Android" ? M.googlePlay : M.appleStore, "_blank"); + } }, e2 === "Android" ? W$1.createElement(nC, { className: "w-[24px] h-[24px] m-auto" }) : W$1.createElement(nB, { className: "w-[24px] h-[24px] m-auto" }), W$1.createElement("div", { className: "w-[75px] w3w-caption2 w3w-t-secondary" }, a2("sdk-download-".concat(e2.toLowerCase()), { default: "Download for ".concat(e2) }))); +}; +var nH = function(n11) { + return W$1.createElement(nW, d$2({}, n11), W$1.createElement("path", { d: "M6.69708 4.57538L4.57576 6.6967L9.87906 12L4.57576 17.3033L6.69708 19.4246L12.0004 14.1213L17.3037 19.4246L19.425 17.3033L14.1217 12L19.425 6.6967L17.3037 4.57538L12.0004 9.87868L6.69708 4.57538Z", fill: "currentColor" })); +}; +var nF = function(n11) { + var e2 = n11.onClose; + var a2 = ng(); + return W$1.createElement("div", { className: "flex items-center justify-between" }, W$1.createElement("p", { className: "text-base font-medium text-[#1E2329] lg:text-xl md:font-semibold md:w3w-subtitle1" }, a2("sdk-modal-title", { default: "Connect with Binance" })), W$1.createElement("div", { className: "cursor-pointer text-[#929AA5]", onClick: e2 }, W$1.createElement(nH, null))); +}, nZ = nF; +var nR = function(n11) { + var e2 = n11.id, a2 = n11.onClose, t3 = n11.onConnect; + var i2 = ng(); + return W$1.createElement("div", { id: e2, className: "w3w-animated w3w-fadeIn pointer-events-auto fixed top-0 left-0 h-full w-full bg-black/[.80] duration-300 ease-in-out will-change-auto" }, W$1.createElement("div", { className: "absolute bottom-0 m-auto w-full rounded-t-2xl bg-white px-4 pb-6 shadow-inner duration-300 ease-in-out will-change-transform md:w-[400px]" }, W$1.createElement(nU, { onClose: a2 }), W$1.createElement("div", { className: "mt-6 mb-4 flex justify-center" }, W$1.createElement("img", { className: "w-[60px]", src: I$1 })), W$1.createElement("div", { className: "w3w-subtitle1 text-center mb-6 w3w-t-primary" }, i2("sdk-modal-title", { default: "Connect with Binance" })), W$1.createElement("button", { onClick: t3, style: { borderColor: "transparent" }, className: "w-full rounded h-[40px] flex justify-center items-center w3w-bg-primary w3w-t-primary w3w-subtitle3 mb-4" }, i2("sdk-connect", { default: "Connect" })), W$1.createElement("div", { className: "text-center py-3 w3w-t-secondary" }, W$1.createElement("span", null, i2("sdk-no-app", { default: "Don’t have Binance app yet?" })), W$1.createElement("a", { target: "_blank", href: "https://www.binance.com/en/download", className: "w3w-t-brand ml-1" }, i2("sdk-install", { default: "Install" }))))); +}, nU = function(n11) { + var e2 = n11.onClose; + return W$1.createElement("div", { className: "flex items-center justify-end h-[52px]" }, W$1.createElement("div", { className: "cursor-pointer text-[#929AA5]", onClick: e2 }, W$1.createElement(nH, { className: "w-[20px]" }))); +}; +var nK = function(n11, e2) { + var a2 = "visibilitychange", t3 = setTimeout(function() { + document.hidden || n11(); + }, e2), i2 = function() { + document.hidden && (clearTimeout(t3), document.removeEventListener(a2, i2)); + }; + document.addEventListener(a2, i2, false); +}, nJ = function(n11) { + var e2 = document.createElement("a"); + e2.href = n11, document.body.appendChild(e2), nK(function() { + window.location.href = "https://www.binance.com/en/download"; + }, 1e3), e2.click(), document.body.removeChild(e2); +}, nq = function(n11) { + var e2 = z(), a2 = e2.isAndroid, t3 = e2.isMobile; + return { toBinance: function() { + var e3 = rC(a2, n11); + if (t3) { + if (!a2) { + var i2 = document.createElement("a"); + i2.href = e3, document.body.appendChild(i2), i2.click(), document.body.removeChild(i2); + } + a2 && nJ(e3); + } + } }; +}; +function n_(n11) { + var e2 = nq(n11.url), a2 = e2.toBinance; + return W$1.createElement("div", null, W$1.createElement("div", { className: "mt-[35px] flex justify-center" }, W$1.createElement("div", { className: "w-[200px] h-[200px] mb-4", onClick: a2 }, n11.url && W$1.createElement(QRCodeSVG, { value: n11.url, width: "100%", height: "100%", level: "M", imageSettings: { src: I$1, height: 32, width: 32, excavate: false } })))); +} +var nX = n_; +var n$ = function(n11) { + var e2 = n11.onClose, a2 = n11.isReady; + var t3 = z(), i2 = t3.isMobile, r2 = s$5(reactExports.useState(""), 2), o2 = r2[0], l2 = r2[1], c2 = s$5(reactExports.useState(false), 2), p2 = c2[0], u2 = c2[1]; + reactExports.useEffect(function() { + a2.then(l2).catch(function() { + return u2(true); + }); + }, [a2]); + var m2 = function() { + rj(o2); + }, w = { url: o2, error: p2 }; + if (i2 === false) + return W$1.createElement("div", { id: A, className: "w3w-animated w3w-fadeIn pointer-events-auto fixed top-0 left-0 h-full w-full bg-black/[.80] duration-300 ease-in-out will-change-auto" }, W$1.createElement("div", { style: { transform: "translateY(-50%)", top: "50%" }, className: "relative m-auto w-[343px] rounded-2xl bg-white px-6 pt-[20px] pb-6 shadow-inner duration-300 ease-in-out will-change-transform md:w-[400px] lg:p-8 lg:pt-6" }, W$1.createElement(nZ, { onClose: e2 }), W$1.createElement(nX, d$2({}, w)), W$1.createElement(nN, null))); + if (i2) + return W$1.createElement(nR, { onConnect: m2, onClose: e2, id: A }); +}, n1 = n$; +var n0 = { order: ["querystring", "cookie", "localStorage", "sessionStorage", "navigator", "htmlTag", "path", "subdomain"], lookupQuerystring: function n() { + var n11 = window.location.search.match(/lng=([^&]*)/); + return n11 && n11[1]; +}, lookupCookie: function n2() { + var n11 = document.cookie.match(/i18next=([^;]*)/); + return n11 && n11[1]; +}, lookupLocalStorage: function n3() { + return localStorage.getItem("i18nextLng"); +}, lookupSessionStorage: function n4() { + return sessionStorage.getItem("i18nextLng"); +}, lookupFromNavigator: function n5() { + return navigator.language; +}, lookupFromHtmlTag: function n6() { + return document.documentElement.lang; +}, lookupFromPath: function n7() { + var n11 = window.location.pathname.match(/\/([^/]*)/); + return n11 && n11[1]; +}, lookupFromSubdomain: function n8() { + var n11 = window.location.hostname.match(/^(.+)\./); + return n11 && n11[1]; +} }, n22 = function() { + var n11 = true, e2 = false, a2 = void 0; + try { + for (var t3 = n0.order[Symbol.iterator](), i2; !(n11 = (i2 = t3.next()).done); n11 = true) { + var r2 = i2.value; + try { + var o2 = n0["lookup" + r2.charAt(0).toUpperCase() + r2.slice(1)](); + if (o2) + return o2; + } catch (n12) { + console.error("Error detecting language with method: ".concat(r2), n12); + continue; + } + } + } catch (n12) { + e2 = true; + a2 = n12; + } finally { + try { + if (!n11 && t3.return != null) { + t3.return(); + } + } finally { + if (e2) { + throw a2; + } + } + } + return "en"; +}; +function n32() { + var n11 = window.document, e2 = n11.createElement("div"); + return e2.setAttribute("id", C), n11.body.appendChild(e2), e2; +} +function n42() { + var n11 = window.document, e2 = n11.getElementById(A); + e2 && (e2.className = e2.className.replace("w3w-fadeIn", "w3w-fadeOut"), setTimeout(function() { + var e3 = n11.getElementById(C); + e3 && n11.body.removeChild(e3); + }, 300)); +} +function n52(n11) { + return function() { + n42(), n11 && n11(); + }; +} +function n9(n11) { + return n62.apply(this, arguments); +} +function n62() { + n62 = t$5(function(n11) { + var e2, a2, t3, i2, r2, o2; + return u$5(this, function(d2) { + switch (d2.label) { + case 0: + e2 = n11.isReady, a2 = n11.cb, t3 = n11.lng; + i2 = n32(), r2 = createRoot(i2); + return [4, e2]; + case 1: + d2.sent(); + o2 = t3 !== null && t3 !== void 0 ? t3 : n22(); + r2.render(reactExports.createElement(h$4.Provider, { value: { lng: o2 } }, reactExports.createElement("style", { dangerouslySetInnerHTML: { __html: b$3 } }), reactExports.createElement(n1, { isReady: e2, onClose: n52(a2) }))); + return [2]; + } + }); + }); + return n62.apply(this, arguments); +} +function n72() { + n42(); +} +var n82 = function(n11) { +}, en = function() { +}; +function ee(n11) { + var e2 = n11.cb, a2 = n11.lng; + var t3 = new Promise(function(n12, e3) { + n82 = n12, en = e3; + }); + eh$1() || n9({ isReady: t3, cb: e2, lng: a2 }); +} +function ea$1() { + eh$1() || n72(); +} +function et(n11) { + n82(n11); +} +function ei$1() { + console.log("relay failed...."), en(); +} +var er$1 = { open: ee, close: ea$1, ready: et, fail: ei$1 }, eo$1 = er$1; +var browser = function() { + throw new Error( + "ws does not work in the browser. Browser clients must use the native WebSocket object" + ); +}; +const k$1 = /* @__PURE__ */ getDefaultExportFromCjs(browser); +function t$4(t3) { + if (t3 === void 0) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + return t3; +} +function e$4(t3, e2) { + if (!(t3 instanceof e2)) { + throw new TypeError("Cannot call a class as a function"); + } +} +function n$4(t3, e2) { + for (var n11 = 0; n11 < e2.length; n11++) { + var r2 = e2[n11]; + r2.enumerable = r2.enumerable || false; + r2.configurable = true; + if ("value" in r2) + r2.writable = true; + Object.defineProperty(t3, r2.key, r2); + } +} +function r$4(t3, e2, r2) { + if (e2) + n$4(t3.prototype, e2); + if (r2) + n$4(t3, r2); + return t3; +} +function o$4(t3) { + o$4 = Object.setPrototypeOf ? Object.getPrototypeOf : function t4(t4) { + return t4.__proto__ || Object.getPrototypeOf(t4); + }; + return o$4(t3); +} +function i$4(t3, e2) { + if (typeof e2 !== "function" && e2 !== null) { + throw new TypeError("Super expression must either be null or a function"); + } + t3.prototype = Object.create(e2 && e2.prototype, { constructor: { value: t3, writable: true, configurable: true } }); + if (e2) + u$4(t3, e2); +} +function s$4(e2, n11) { + if (n11 && (c$4(n11) === "object" || typeof n11 === "function")) { + return n11; + } + return t$4(e2); +} +function u$4(t3, e2) { + u$4 = Object.setPrototypeOf || function t4(t4, e3) { + t4.__proto__ = e3; + return t4; + }; + return u$4(t3, e2); +} +function c$4(t3) { + "@swc/helpers - typeof"; + return t3 && typeof Symbol !== "undefined" && t3.constructor === Symbol ? "symbol" : typeof t3; +} +function a$4() { + if (typeof Reflect === "undefined" || !Reflect.construct) + return false; + if (Reflect.construct.sham) + return false; + if (typeof Proxy === "function") + return true; + try { + Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() { + })); + return true; + } catch (t3) { + return false; + } +} +function f$3(t3) { + var e2 = a$4(); + return function n11() { + var n12 = o$4(t3), r2; + if (e2) { + var i2 = o$4(this).constructor; + r2 = Reflect.construct(n12, arguments, i2); + } else { + r2 = n12.apply(this, arguments); + } + return s$4(this, r2); + }; +} +var l$3 = Object.defineProperty; +var h$3 = function(t3, e2, n11) { + return e2 in t3 ? l$3(t3, e2, { enumerable: true, configurable: true, writable: true, value: n11 }) : t3[e2] = n11; +}; +var y$3 = function(t3, e2, n11) { + return h$3(t3, (typeof e2 === "undefined" ? "undefined" : c$4(e2)) != "symbol" ? e2 + "" : e2, n11), n11; +}; +var d$1 = (typeof window === "undefined" ? "undefined" : c$4(window)) < "u" ? window.WebSocket : k$1, v$2 = function(n11) { + i$4(s2, n11); + var o2 = f$3(s2); + function s2(n12) { + e$4(this, s2); + var r2; + r2 = o2.call(this); + r2.opts = n12; + y$3(t$4(r2), "qs"); + y$3(t$4(r2), "urls", []); + y$3(t$4(r2), "url"); + y$3(t$4(r2), "socket"); + y$3(t$4(r2), "nextSocket"); + y$3(t$4(r2), "queue", []); + y$3(t$4(r2), "subscriptions", []); + y$3(t$4(r2), "retryIndex", 0); + r2.socket = null, r2.nextSocket = null, r2.subscriptions = n12.subscriptions || [], r2.qs = "env=browser&protocol=wc&version=".concat(n12.version); + return r2; + } + r$4(s2, [{ key: "readyState", get: function t3() { + return this.socket ? this.socket.readyState : -1; + }, set: function t3(t3) { + } }, { key: "connecting", get: function t3() { + return this.readyState === 0; + }, set: function t3(t3) { + } }, { key: "connected", get: function t3() { + return this.readyState === 1; + }, set: function t3(t3) { + } }, { key: "retryFailed", get: function t3() { + return this.retryIndex > 0 && this.retryIndex > this.urls.length; + }, set: function t3(t3) { + } }, { key: "open", value: function t3(t3) { + if (!Array.isArray(t3) || t3.length === 0) + throw new Error("Missing or invalid WebSocket url"); + this.urls = t3, this.retryIndex = 0, this.socketCreate(); + } }, { key: "close", value: function t3() { + this._socketClose(); + } }, { key: "send", value: function t3(t3, e2, n12) { + if (!e2 || typeof e2 != "string") + throw new Error("Missing or invalid topic field"); + this.socketSend({ topic: e2, type: "pub", payload: t3, silent: !!n12 }); + } }, { key: "subscribe", value: function t3(t3) { + this.socketSend({ topic: t3, type: "sub", payload: "", silent: true }); + } }, { key: "socketCreate", value: function t3() { + var t4 = this; + if (this.nextSocket) + return; + var e2 = this.url || this.getWsUrl(); + if (!e2) + return this.events.emit("error", new Error("Retry limit reached. Can't connect to any url."), e2); + if (this.url = e2, this.nextSocket = new d$1(e2), !this.nextSocket) + throw new Error("Failed to create socket"); + this.nextSocket.onmessage = function(e3) { + return t4.socketReceive(e3); + }, this.nextSocket.onopen = function() { + return t4.socketOpen(); + }, this.nextSocket.onerror = function(n12) { + return t4.socketError(n12, e2); + }, this.nextSocket.onclose = function(e3) { + t4.nextSocket = null, t4.socketCreate(); + }; + } }, { key: "getWsUrl", value: function t3() { + return this.retryIndex >= this.urls.length ? "" : "".concat(this.urls[this.retryIndex++], "?").concat(this.qs); + } }, { key: "socketOpen", value: function t3() { + this._socketClose(), this.socket = this.nextSocket, this.nextSocket = null, this.queueSubscriptions(), this.pushQueue(), this.events.emit("open", this.urls[this.retryIndex - 1]); + } }, { key: "_socketClose", value: function t3() { + this.socket && (this.socket.onclose = function() { + }, this.socket.close(), this.events.emit("close")); + } }, { key: "socketSend", value: function t3(t3) { + var e2 = JSON.stringify(t3); + this.socket && this.socket.readyState === 1 ? this.socket.send(e2) : this.setToQueue(t3); + } }, { key: "socketReceive", value: function t3(t3) { + var e2; + try { + e2 = JSON.parse(t3.data); + } catch (t4) { + return; + } + this.socketSend({ topic: e2.topic, type: "ack", payload: "", silent: true }), this.socket && this.socket.readyState === 1 && this.events.emit("message", e2); + } }, { key: "socketError", value: function t3(t3, e2) { + this.events.emit("error", t3, e2); + } }, { key: "queueSubscriptions", value: function t3() { + var t4 = this; + this.subscriptions.forEach(function(e2) { + return t4.queue.push({ topic: e2, type: "sub", payload: "", silent: true }); + }), this.subscriptions = this.opts.subscriptions || []; + } }, { key: "setToQueue", value: function t3(t3) { + this.queue.push(t3); + } }, { key: "pushQueue", value: function t3() { + var t4 = this; + this.queue.forEach(function(e2) { + return t4.socketSend(e2); + }), this.queue = []; + } }]); + return s2; +}(rh); +function b$2(t3) { + var e2 = Date.now(); + return new Promise(function(n11) { + try { + setTimeout(function() { + n11({ ttl: 0, url: t3 }); + }, 5e3); + var r2 = new d$1(t3); + r2.onopen = function() { + r2.close(), n11({ ttl: Date.now() - e2, url: t3 }); + }, r2.onerror = function() { + n11({ ttl: 0, url: t3 }); + }; + } catch (e3) { + n11({ ttl: 0, url: t3 }); + } + }); +} +function t$3(t3) { + if (t3 === void 0) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + return t3; +} +function e$3(t3, e2) { + if (!(t3 instanceof e2)) { + throw new TypeError("Cannot call a class as a function"); + } +} +function n$3(t3) { + n$3 = Object.setPrototypeOf ? Object.getPrototypeOf : function t4(t4) { + return t4.__proto__ || Object.getPrototypeOf(t4); + }; + return n$3(t3); +} +function r$3(t3, e2) { + if (typeof e2 !== "function" && e2 !== null) { + throw new TypeError("Super expression must either be null or a function"); + } + t3.prototype = Object.create(e2 && e2.prototype, { constructor: { value: t3, writable: true, configurable: true } }); + if (e2) + c$3(t3, e2); +} +function o$3(e2, n11) { + if (n11 && (i$3(n11) === "object" || typeof n11 === "function")) { + return n11; + } + return t$3(e2); +} +function c$3(t3, e2) { + c$3 = Object.setPrototypeOf || function t4(t4, e3) { + t4.__proto__ = e3; + return t4; + }; + return c$3(t3, e2); +} +function i$3(t3) { + "@swc/helpers - typeof"; + return t3 && typeof Symbol !== "undefined" && t3.constructor === Symbol ? "symbol" : typeof t3; +} +function u$3() { + if (typeof Reflect === "undefined" || !Reflect.construct) + return false; + if (Reflect.construct.sham) + return false; + if (typeof Proxy === "function") + return true; + try { + Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() { + })); + return true; + } catch (t3) { + return false; + } +} +function f$2(t3) { + var e2 = u$3(); + return function r2() { + var r3 = n$3(t3), c2; + if (e2) { + var i2 = n$3(this).constructor; + c2 = Reflect.construct(r3, arguments, i2); + } else { + c2 = r3.apply(this, arguments); + } + return o$3(this, c2); + }; +} +var s$3 = Object.defineProperty; +var a$3 = function(t3, e2, n11) { + return e2 in t3 ? s$3(t3, e2, { enumerable: true, configurable: true, writable: true, value: n11 }) : t3[e2] = n11; +}; +var l$2 = function(t3, e2, n11) { + return a$3(t3, (typeof e2 === "undefined" ? "undefined" : i$3(e2)) != "symbol" ? e2 + "" : e2, n11), n11; +}; +var p$2 = function t() { + e$3(this, t); + l$2(this, "events"); +}, y$2 = function(t3) { + r$3(o2, t3); + var n11 = f$2(o2); + function o2() { + e$3(this, o2); + return n11.apply(this, arguments); + } + return o2; +}(p$2); +(function(n11) { + r$3(c2, n11); + var o2 = f$2(c2); + function c2() { + e$3(this, c2); + var n12; + n12 = o2.call.apply(o2, [this].concat(Array.prototype.slice.call(arguments))); + l$2(t$3(n12), "connection"); + return n12; + } + return c2; +})(y$2); +var h$2 = function(t3) { + return t3[t3.DisconnectAtWallet = 0] = "DisconnectAtWallet", t3[t3.DisconnectAtClient = 1] = "DisconnectAtClient", t3[t3.NetworkError = 2] = "NetworkError", t3; +}(h$2 || {}); +const version$6 = "logger/5.7.0"; +let _permanentCensorErrors = false; +let _censorErrors = false; +const LogLevels = { debug: 1, "default": 2, info: 2, warning: 3, error: 4, off: 5 }; +let _logLevel = LogLevels["default"]; +let _globalLogger = null; +function _checkNormalize() { + try { + const missing = []; + ["NFD", "NFC", "NFKD", "NFKC"].forEach((form) => { + try { + if ("test".normalize(form) !== "test") { + throw new Error("bad normalize"); + } + ; + } catch (error) { + missing.push(form); + } + }); + if (missing.length) { + throw new Error("missing " + missing.join(", ")); + } + if (String.fromCharCode(233).normalize("NFD") !== String.fromCharCode(101, 769)) { + throw new Error("broken implementation"); + } + } catch (error) { + return error.message; + } + return null; +} +const _normalizeError = _checkNormalize(); +var LogLevel; +(function(LogLevel2) { + LogLevel2["DEBUG"] = "DEBUG"; + LogLevel2["INFO"] = "INFO"; + LogLevel2["WARNING"] = "WARNING"; + LogLevel2["ERROR"] = "ERROR"; + LogLevel2["OFF"] = "OFF"; +})(LogLevel || (LogLevel = {})); +var ErrorCode; +(function(ErrorCode2) { + ErrorCode2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR"; + ErrorCode2["NOT_IMPLEMENTED"] = "NOT_IMPLEMENTED"; + ErrorCode2["UNSUPPORTED_OPERATION"] = "UNSUPPORTED_OPERATION"; + ErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR"; + ErrorCode2["SERVER_ERROR"] = "SERVER_ERROR"; + ErrorCode2["TIMEOUT"] = "TIMEOUT"; + ErrorCode2["BUFFER_OVERRUN"] = "BUFFER_OVERRUN"; + ErrorCode2["NUMERIC_FAULT"] = "NUMERIC_FAULT"; + ErrorCode2["MISSING_NEW"] = "MISSING_NEW"; + ErrorCode2["INVALID_ARGUMENT"] = "INVALID_ARGUMENT"; + ErrorCode2["MISSING_ARGUMENT"] = "MISSING_ARGUMENT"; + ErrorCode2["UNEXPECTED_ARGUMENT"] = "UNEXPECTED_ARGUMENT"; + ErrorCode2["CALL_EXCEPTION"] = "CALL_EXCEPTION"; + ErrorCode2["INSUFFICIENT_FUNDS"] = "INSUFFICIENT_FUNDS"; + ErrorCode2["NONCE_EXPIRED"] = "NONCE_EXPIRED"; + ErrorCode2["REPLACEMENT_UNDERPRICED"] = "REPLACEMENT_UNDERPRICED"; + ErrorCode2["UNPREDICTABLE_GAS_LIMIT"] = "UNPREDICTABLE_GAS_LIMIT"; + ErrorCode2["TRANSACTION_REPLACED"] = "TRANSACTION_REPLACED"; + ErrorCode2["ACTION_REJECTED"] = "ACTION_REJECTED"; +})(ErrorCode || (ErrorCode = {})); +const HEX = "0123456789abcdef"; +class Logger { + constructor(version2) { + Object.defineProperty(this, "version", { + enumerable: true, + value: version2, + writable: false + }); + } + _log(logLevel, args) { + const level = logLevel.toLowerCase(); + if (LogLevels[level] == null) { + this.throwArgumentError("invalid log level name", "logLevel", logLevel); + } + if (_logLevel > LogLevels[level]) { + return; + } + console.log.apply(console, args); + } + debug(...args) { + this._log(Logger.levels.DEBUG, args); + } + info(...args) { + this._log(Logger.levels.INFO, args); + } + warn(...args) { + this._log(Logger.levels.WARNING, args); + } + makeError(message, code, params) { + if (_censorErrors) { + return this.makeError("censored error", code, {}); + } + if (!code) { + code = Logger.errors.UNKNOWN_ERROR; + } + if (!params) { + params = {}; + } + const messageDetails = []; + Object.keys(params).forEach((key) => { + const value = params[key]; + try { + if (value instanceof Uint8Array) { + let hex = ""; + for (let i2 = 0; i2 < value.length; i2++) { + hex += HEX[value[i2] >> 4]; + hex += HEX[value[i2] & 15]; + } + messageDetails.push(key + "=Uint8Array(0x" + hex + ")"); + } else { + messageDetails.push(key + "=" + JSON.stringify(value)); + } + } catch (error2) { + messageDetails.push(key + "=" + JSON.stringify(params[key].toString())); + } + }); + messageDetails.push(`code=${code}`); + messageDetails.push(`version=${this.version}`); + const reason = message; + let url = ""; + switch (code) { + case ErrorCode.NUMERIC_FAULT: { + url = "NUMERIC_FAULT"; + const fault = message; + switch (fault) { + case "overflow": + case "underflow": + case "division-by-zero": + url += "-" + fault; + break; + case "negative-power": + case "negative-width": + url += "-unsupported"; + break; + case "unbound-bitwise-result": + url += "-unbound-result"; + break; + } + break; + } + case ErrorCode.CALL_EXCEPTION: + case ErrorCode.INSUFFICIENT_FUNDS: + case ErrorCode.MISSING_NEW: + case ErrorCode.NONCE_EXPIRED: + case ErrorCode.REPLACEMENT_UNDERPRICED: + case ErrorCode.TRANSACTION_REPLACED: + case ErrorCode.UNPREDICTABLE_GAS_LIMIT: + url = code; + break; + } + if (url) { + message += " [ See: https://links.ethers.org/v5-errors-" + url + " ]"; + } + if (messageDetails.length) { + message += " (" + messageDetails.join(", ") + ")"; + } + const error = new Error(message); + error.reason = reason; + error.code = code; + Object.keys(params).forEach(function(key) { + error[key] = params[key]; + }); + return error; + } + throwError(message, code, params) { + throw this.makeError(message, code, params); + } + throwArgumentError(message, name, value) { + return this.throwError(message, Logger.errors.INVALID_ARGUMENT, { + argument: name, + value + }); + } + assert(condition, message, code, params) { + if (!!condition) { + return; + } + this.throwError(message, code, params); + } + assertArgument(condition, message, name, value) { + if (!!condition) { + return; + } + this.throwArgumentError(message, name, value); + } + checkNormalize(message) { + if (_normalizeError) { + this.throwError("platform missing String.prototype.normalize", Logger.errors.UNSUPPORTED_OPERATION, { + operation: "String.prototype.normalize", + form: _normalizeError + }); + } + } + checkSafeUint53(value, message) { + if (typeof value !== "number") { + return; + } + if (message == null) { + message = "value not safe"; + } + if (value < 0 || value >= 9007199254740991) { + this.throwError(message, Logger.errors.NUMERIC_FAULT, { + operation: "checkSafeInteger", + fault: "out-of-safe-range", + value + }); + } + if (value % 1) { + this.throwError(message, Logger.errors.NUMERIC_FAULT, { + operation: "checkSafeInteger", + fault: "non-integer", + value + }); + } + } + checkArgumentCount(count, expectedCount, message) { + if (message) { + message = ": " + message; + } else { + message = ""; + } + if (count < expectedCount) { + this.throwError("missing argument" + message, Logger.errors.MISSING_ARGUMENT, { + count, + expectedCount + }); + } + if (count > expectedCount) { + this.throwError("too many arguments" + message, Logger.errors.UNEXPECTED_ARGUMENT, { + count, + expectedCount + }); + } + } + checkNew(target, kind) { + if (target === Object || target == null) { + this.throwError("missing new", Logger.errors.MISSING_NEW, { name: kind.name }); + } + } + checkAbstract(target, kind) { + if (target === kind) { + this.throwError("cannot instantiate abstract class " + JSON.stringify(kind.name) + " directly; use a sub-class", Logger.errors.UNSUPPORTED_OPERATION, { name: target.name, operation: "new" }); + } else if (target === Object || target == null) { + this.throwError("missing new", Logger.errors.MISSING_NEW, { name: kind.name }); + } + } + static globalLogger() { + if (!_globalLogger) { + _globalLogger = new Logger(version$6); + } + return _globalLogger; + } + static setCensorship(censorship, permanent) { + if (!censorship && permanent) { + this.globalLogger().throwError("cannot permanently disable censorship", Logger.errors.UNSUPPORTED_OPERATION, { + operation: "setCensorship" + }); + } + if (_permanentCensorErrors) { + if (!censorship) { + return; + } + this.globalLogger().throwError("error censorship permanent", Logger.errors.UNSUPPORTED_OPERATION, { + operation: "setCensorship" + }); + } + _censorErrors = !!censorship; + _permanentCensorErrors = !!permanent; + } + static setLogLevel(logLevel) { + const level = LogLevels[logLevel.toLowerCase()]; + if (level == null) { + Logger.globalLogger().warn("invalid log level - " + logLevel); + return; + } + _logLevel = level; + } + static from(version2) { + return new Logger(version2); + } +} +Logger.errors = ErrorCode; +Logger.levels = LogLevel; +const version$5 = "bytes/5.7.0"; +const logger$9 = new Logger(version$5); +function isHexable(value) { + return !!value.toHexString; +} +function addSlice(array) { + if (array.slice) { + return array; + } + array.slice = function() { + const args = Array.prototype.slice.call(arguments); + return addSlice(new Uint8Array(Array.prototype.slice.apply(array, args))); + }; + return array; +} +function isInteger(value) { + return typeof value === "number" && value == value && value % 1 === 0; +} +function isBytes(value) { + if (value == null) { + return false; + } + if (value.constructor === Uint8Array) { + return true; + } + if (typeof value === "string") { + return false; + } + if (!isInteger(value.length) || value.length < 0) { + return false; + } + for (let i2 = 0; i2 < value.length; i2++) { + const v2 = value[i2]; + if (!isInteger(v2) || v2 < 0 || v2 >= 256) { + return false; + } + } + return true; +} +function arrayify(value, options) { + if (!options) { + options = {}; + } + if (typeof value === "number") { + logger$9.checkSafeUint53(value, "invalid arrayify value"); + const result = []; + while (value) { + result.unshift(value & 255); + value = parseInt(String(value / 256)); + } + if (result.length === 0) { + result.push(0); + } + return addSlice(new Uint8Array(result)); + } + if (options.allowMissingPrefix && typeof value === "string" && value.substring(0, 2) !== "0x") { + value = "0x" + value; + } + if (isHexable(value)) { + value = value.toHexString(); + } + if (isHexString(value)) { + let hex = value.substring(2); + if (hex.length % 2) { + if (options.hexPad === "left") { + hex = "0" + hex; + } else if (options.hexPad === "right") { + hex += "0"; + } else { + logger$9.throwArgumentError("hex data is odd-length", "value", value); + } + } + const result = []; + for (let i2 = 0; i2 < hex.length; i2 += 2) { + result.push(parseInt(hex.substring(i2, i2 + 2), 16)); + } + return addSlice(new Uint8Array(result)); + } + if (isBytes(value)) { + return addSlice(new Uint8Array(value)); + } + return logger$9.throwArgumentError("invalid arrayify value", "value", value); +} +function concat(items) { + const objects = items.map((item) => arrayify(item)); + const length = objects.reduce((accum, item) => accum + item.length, 0); + const result = new Uint8Array(length); + objects.reduce((offset, object) => { + result.set(object, offset); + return offset + object.length; + }, 0); + return addSlice(result); +} +function isHexString(value, length) { + if (typeof value !== "string" || !value.match(/^0x[0-9A-Fa-f]*$/)) { + return false; + } + if (length && value.length !== 2 + 2 * length) { + return false; + } + return true; +} +const HexCharacters = "0123456789abcdef"; +function hexlify(value, options) { + if (!options) { + options = {}; + } + if (typeof value === "number") { + logger$9.checkSafeUint53(value, "invalid hexlify value"); + let hex = ""; + while (value) { + hex = HexCharacters[value & 15] + hex; + value = Math.floor(value / 16); + } + if (hex.length) { + if (hex.length % 2) { + hex = "0" + hex; + } + return "0x" + hex; + } + return "0x00"; + } + if (typeof value === "bigint") { + value = value.toString(16); + if (value.length % 2) { + return "0x0" + value; + } + return "0x" + value; + } + if (options.allowMissingPrefix && typeof value === "string" && value.substring(0, 2) !== "0x") { + value = "0x" + value; + } + if (isHexable(value)) { + return value.toHexString(); + } + if (isHexString(value)) { + if (value.length % 2) { + if (options.hexPad === "left") { + value = "0x0" + value.substring(2); + } else if (options.hexPad === "right") { + value += "0"; + } else { + logger$9.throwArgumentError("hex data is odd-length", "value", value); + } + } + return value.toLowerCase(); + } + if (isBytes(value)) { + let result = "0x"; + for (let i2 = 0; i2 < value.length; i2++) { + let v2 = value[i2]; + result += HexCharacters[(v2 & 240) >> 4] + HexCharacters[v2 & 15]; + } + return result; + } + return logger$9.throwArgumentError("invalid hexlify value", "value", value); +} +function hexDataSlice(data, offset, endOffset) { + if (typeof data !== "string") { + data = hexlify(data); + } else if (!isHexString(data) || data.length % 2) { + logger$9.throwArgumentError("invalid hexData", "value", data); + } + offset = 2 + 2 * offset; + if (endOffset != null) { + return "0x" + data.substring(offset, 2 + 2 * endOffset); + } + return "0x" + data.substring(offset); +} +function hexConcat(items) { + let result = "0x"; + items.forEach((item) => { + result += hexlify(item).substring(2); + }); + return result; +} +function hexZeroPad(value, length) { + if (typeof value !== "string") { + value = hexlify(value); + } else if (!isHexString(value)) { + logger$9.throwArgumentError("invalid hex string", "value", value); + } + if (value.length > 2 * length + 2) { + logger$9.throwArgumentError("value out of range", "value", arguments[1]); + } + while (value.length < 2 * length + 2) { + value = "0x0" + value.substring(2); + } + return value; +} +const version$4 = "bignumber/5.7.0"; +var BN = _BN.BN; +const logger$8 = new Logger(version$4); +const _constructorGuard$1 = {}; +const MAX_SAFE = 9007199254740991; +let _warnedToStringRadix = false; +class BigNumber { + constructor(constructorGuard, hex) { + if (constructorGuard !== _constructorGuard$1) { + logger$8.throwError("cannot call constructor directly; use BigNumber.from", Logger.errors.UNSUPPORTED_OPERATION, { + operation: "new (BigNumber)" + }); + } + this._hex = hex; + this._isBigNumber = true; + Object.freeze(this); + } + fromTwos(value) { + return toBigNumber(toBN(this).fromTwos(value)); + } + toTwos(value) { + return toBigNumber(toBN(this).toTwos(value)); + } + abs() { + if (this._hex[0] === "-") { + return BigNumber.from(this._hex.substring(1)); + } + return this; + } + add(other) { + return toBigNumber(toBN(this).add(toBN(other))); + } + sub(other) { + return toBigNumber(toBN(this).sub(toBN(other))); + } + div(other) { + const o2 = BigNumber.from(other); + if (o2.isZero()) { + throwFault("division-by-zero", "div"); + } + return toBigNumber(toBN(this).div(toBN(other))); + } + mul(other) { + return toBigNumber(toBN(this).mul(toBN(other))); + } + mod(other) { + const value = toBN(other); + if (value.isNeg()) { + throwFault("division-by-zero", "mod"); + } + return toBigNumber(toBN(this).umod(value)); + } + pow(other) { + const value = toBN(other); + if (value.isNeg()) { + throwFault("negative-power", "pow"); + } + return toBigNumber(toBN(this).pow(value)); + } + and(other) { + const value = toBN(other); + if (this.isNegative() || value.isNeg()) { + throwFault("unbound-bitwise-result", "and"); + } + return toBigNumber(toBN(this).and(value)); + } + or(other) { + const value = toBN(other); + if (this.isNegative() || value.isNeg()) { + throwFault("unbound-bitwise-result", "or"); + } + return toBigNumber(toBN(this).or(value)); + } + xor(other) { + const value = toBN(other); + if (this.isNegative() || value.isNeg()) { + throwFault("unbound-bitwise-result", "xor"); + } + return toBigNumber(toBN(this).xor(value)); + } + mask(value) { + if (this.isNegative() || value < 0) { + throwFault("negative-width", "mask"); + } + return toBigNumber(toBN(this).maskn(value)); + } + shl(value) { + if (this.isNegative() || value < 0) { + throwFault("negative-width", "shl"); + } + return toBigNumber(toBN(this).shln(value)); + } + shr(value) { + if (this.isNegative() || value < 0) { + throwFault("negative-width", "shr"); + } + return toBigNumber(toBN(this).shrn(value)); + } + eq(other) { + return toBN(this).eq(toBN(other)); + } + lt(other) { + return toBN(this).lt(toBN(other)); + } + lte(other) { + return toBN(this).lte(toBN(other)); + } + gt(other) { + return toBN(this).gt(toBN(other)); + } + gte(other) { + return toBN(this).gte(toBN(other)); + } + isNegative() { + return this._hex[0] === "-"; + } + isZero() { + return toBN(this).isZero(); + } + toNumber() { + try { + return toBN(this).toNumber(); + } catch (error) { + throwFault("overflow", "toNumber", this.toString()); + } + return null; + } + toBigInt() { + try { + return BigInt(this.toString()); + } catch (e2) { + } + return logger$8.throwError("this platform does not support BigInt", Logger.errors.UNSUPPORTED_OPERATION, { + value: this.toString() + }); + } + toString() { + if (arguments.length > 0) { + if (arguments[0] === 10) { + if (!_warnedToStringRadix) { + _warnedToStringRadix = true; + logger$8.warn("BigNumber.toString does not accept any parameters; base-10 is assumed"); + } + } else if (arguments[0] === 16) { + logger$8.throwError("BigNumber.toString does not accept any parameters; use bigNumber.toHexString()", Logger.errors.UNEXPECTED_ARGUMENT, {}); + } else { + logger$8.throwError("BigNumber.toString does not accept parameters", Logger.errors.UNEXPECTED_ARGUMENT, {}); + } + } + return toBN(this).toString(10); + } + toHexString() { + return this._hex; + } + toJSON(key) { + return { type: "BigNumber", hex: this.toHexString() }; + } + static from(value) { + if (value instanceof BigNumber) { + return value; + } + if (typeof value === "string") { + if (value.match(/^-?0x[0-9a-f]+$/i)) { + return new BigNumber(_constructorGuard$1, toHex(value)); + } + if (value.match(/^-?[0-9]+$/)) { + return new BigNumber(_constructorGuard$1, toHex(new BN(value))); + } + return logger$8.throwArgumentError("invalid BigNumber string", "value", value); + } + if (typeof value === "number") { + if (value % 1) { + throwFault("underflow", "BigNumber.from", value); + } + if (value >= MAX_SAFE || value <= -MAX_SAFE) { + throwFault("overflow", "BigNumber.from", value); + } + return BigNumber.from(String(value)); + } + const anyValue = value; + if (typeof anyValue === "bigint") { + return BigNumber.from(anyValue.toString()); + } + if (isBytes(anyValue)) { + return BigNumber.from(hexlify(anyValue)); + } + if (anyValue) { + if (anyValue.toHexString) { + const hex = anyValue.toHexString(); + if (typeof hex === "string") { + return BigNumber.from(hex); + } + } else { + let hex = anyValue._hex; + if (hex == null && anyValue.type === "BigNumber") { + hex = anyValue.hex; + } + if (typeof hex === "string") { + if (isHexString(hex) || hex[0] === "-" && isHexString(hex.substring(1))) { + return BigNumber.from(hex); + } + } + } + } + return logger$8.throwArgumentError("invalid BigNumber value", "value", value); + } + static isBigNumber(value) { + return !!(value && value._isBigNumber); + } +} +function toHex(value) { + if (typeof value !== "string") { + return toHex(value.toString(16)); + } + if (value[0] === "-") { + value = value.substring(1); + if (value[0] === "-") { + logger$8.throwArgumentError("invalid hex", "value", value); + } + value = toHex(value); + if (value === "0x00") { + return value; + } + return "-" + value; + } + if (value.substring(0, 2) !== "0x") { + value = "0x" + value; + } + if (value === "0x") { + return "0x00"; + } + if (value.length % 2) { + value = "0x0" + value.substring(2); + } + while (value.length > 4 && value.substring(0, 4) === "0x00") { + value = "0x" + value.substring(4); + } + return value; +} +function toBigNumber(value) { + return BigNumber.from(toHex(value)); +} +function toBN(value) { + const hex = BigNumber.from(value).toHexString(); + if (hex[0] === "-") { + return new BN("-" + hex.substring(3), 16); + } + return new BN(hex.substring(2), 16); +} +function throwFault(fault, operation, value) { + const params = { fault, operation }; + if (value != null) { + params.value = value; + } + return logger$8.throwError(fault, Logger.errors.NUMERIC_FAULT, params); +} +function _base36To16(value) { + return new BN(value, 36).toString(16); +} +const version$3 = "properties/5.7.0"; +globalThis && globalThis.__awaiter || function(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()); + }); +}; +const logger$7 = new Logger(version$3); +function defineReadOnly(object, name, value) { + Object.defineProperty(object, name, { + enumerable: true, + value, + writable: false + }); +} +function getStatic(ctor, key) { + for (let i2 = 0; i2 < 32; i2++) { + if (ctor[key]) { + return ctor[key]; + } + if (!ctor.prototype || typeof ctor.prototype !== "object") { + break; + } + ctor = Object.getPrototypeOf(ctor.prototype).constructor; + } + return null; +} +const opaque = { bigint: true, boolean: true, "function": true, number: true, string: true }; +function _isFrozen(object) { + if (object === void 0 || object === null || opaque[typeof object]) { + return true; + } + if (Array.isArray(object) || typeof object === "object") { + if (!Object.isFrozen(object)) { + return false; + } + const keys = Object.keys(object); + for (let i2 = 0; i2 < keys.length; i2++) { + let value = null; + try { + value = object[keys[i2]]; + } catch (error) { + continue; + } + if (!_isFrozen(value)) { + return false; + } + } + return true; + } + return logger$7.throwArgumentError(`Cannot deepCopy ${typeof object}`, "object", object); +} +function _deepCopy(object) { + if (_isFrozen(object)) { + return object; + } + if (Array.isArray(object)) { + return Object.freeze(object.map((item) => deepCopy(item))); + } + if (typeof object === "object") { + const result = {}; + for (const key in object) { + const value = object[key]; + if (value === void 0) { + continue; + } + defineReadOnly(result, key, deepCopy(value)); + } + return result; + } + return logger$7.throwArgumentError(`Cannot deepCopy ${typeof object}`, "object", object); +} +function deepCopy(object) { + return _deepCopy(object); +} +class Description { + constructor(info) { + for (const key in info) { + this[key] = deepCopy(info[key]); + } + } +} +const version$2 = "abi/5.7.0"; +const logger$6 = new Logger(version$2); +const _constructorGuard = {}; +let ModifiersBytes = { calldata: true, memory: true, storage: true }; +let ModifiersNest = { calldata: true, memory: true }; +function checkModifier(type, name) { + if (type === "bytes" || type === "string") { + if (ModifiersBytes[name]) { + return true; + } + } else if (type === "address") { + if (name === "payable") { + return true; + } + } else if (type.indexOf("[") >= 0 || type === "tuple") { + if (ModifiersNest[name]) { + return true; + } + } + if (ModifiersBytes[name] || name === "payable") { + logger$6.throwArgumentError("invalid modifier", "name", name); + } + return false; +} +function parseParamType(param, allowIndexed) { + let originalParam = param; + function throwError(i2) { + logger$6.throwArgumentError(`unexpected character at position ${i2}`, "param", param); + } + param = param.replace(/\s/g, " "); + function newNode(parent2) { + let node2 = { type: "", name: "", parent: parent2, state: { allowType: true } }; + if (allowIndexed) { + node2.indexed = false; + } + return node2; + } + let parent = { type: "", name: "", state: { allowType: true } }; + let node = parent; + for (let i2 = 0; i2 < param.length; i2++) { + let c2 = param[i2]; + switch (c2) { + case "(": + if (node.state.allowType && node.type === "") { + node.type = "tuple"; + } else if (!node.state.allowParams) { + throwError(i2); + } + node.state.allowType = false; + node.type = verifyType(node.type); + node.components = [newNode(node)]; + node = node.components[0]; + break; + case ")": + delete node.state; + if (node.name === "indexed") { + if (!allowIndexed) { + throwError(i2); + } + node.indexed = true; + node.name = ""; + } + if (checkModifier(node.type, node.name)) { + node.name = ""; + } + node.type = verifyType(node.type); + let child = node; + node = node.parent; + if (!node) { + throwError(i2); + } + delete child.parent; + node.state.allowParams = false; + node.state.allowName = true; + node.state.allowArray = true; + break; + case ",": + delete node.state; + if (node.name === "indexed") { + if (!allowIndexed) { + throwError(i2); + } + node.indexed = true; + node.name = ""; + } + if (checkModifier(node.type, node.name)) { + node.name = ""; + } + node.type = verifyType(node.type); + let sibling = newNode(node.parent); + node.parent.components.push(sibling); + delete node.parent; + node = sibling; + break; + case " ": + if (node.state.allowType) { + if (node.type !== "") { + node.type = verifyType(node.type); + delete node.state.allowType; + node.state.allowName = true; + node.state.allowParams = true; + } + } + if (node.state.allowName) { + if (node.name !== "") { + if (node.name === "indexed") { + if (!allowIndexed) { + throwError(i2); + } + if (node.indexed) { + throwError(i2); + } + node.indexed = true; + node.name = ""; + } else if (checkModifier(node.type, node.name)) { + node.name = ""; + } else { + node.state.allowName = false; + } + } + } + break; + case "[": + if (!node.state.allowArray) { + throwError(i2); + } + node.type += c2; + node.state.allowArray = false; + node.state.allowName = false; + node.state.readArray = true; + break; + case "]": + if (!node.state.readArray) { + throwError(i2); + } + node.type += c2; + node.state.readArray = false; + node.state.allowArray = true; + node.state.allowName = true; + break; + default: + if (node.state.allowType) { + node.type += c2; + node.state.allowParams = true; + node.state.allowArray = true; + } else if (node.state.allowName) { + node.name += c2; + delete node.state.allowArray; + } else if (node.state.readArray) { + node.type += c2; + } else { + throwError(i2); + } + } + } + if (node.parent) { + logger$6.throwArgumentError("unexpected eof", "param", param); + } + delete parent.state; + if (node.name === "indexed") { + if (!allowIndexed) { + throwError(originalParam.length - 7); + } + if (node.indexed) { + throwError(originalParam.length - 7); + } + node.indexed = true; + node.name = ""; + } else if (checkModifier(node.type, node.name)) { + node.name = ""; + } + parent.type = verifyType(parent.type); + return parent; +} +function populate(object, params) { + for (let key in params) { + defineReadOnly(object, key, params[key]); + } +} +const FormatTypes = Object.freeze({ + // Bare formatting, as is needed for computing a sighash of an event or function + sighash: "sighash", + // Human-Readable with Minimal spacing and without names (compact human-readable) + minimal: "minimal", + // Human-Readable with nice spacing, including all names + full: "full", + // JSON-format a la Solidity + json: "json" +}); +const paramTypeArray = new RegExp(/^(.*)\[([0-9]*)\]$/); +class ParamType { + constructor(constructorGuard, params) { + if (constructorGuard !== _constructorGuard) { + logger$6.throwError("use fromString", Logger.errors.UNSUPPORTED_OPERATION, { + operation: "new ParamType()" + }); + } + populate(this, params); + let match = this.type.match(paramTypeArray); + if (match) { + populate(this, { + arrayLength: parseInt(match[2] || "-1"), + arrayChildren: ParamType.fromObject({ + type: match[1], + components: this.components + }), + baseType: "array" + }); + } else { + populate(this, { + arrayLength: null, + arrayChildren: null, + baseType: this.components != null ? "tuple" : this.type + }); + } + this._isParamType = true; + Object.freeze(this); + } + // Format the parameter fragment + // - sighash: "(uint256,address)" + // - minimal: "tuple(uint256,address) indexed" + // - full: "tuple(uint256 foo, address bar) indexed baz" + format(format) { + if (!format) { + format = FormatTypes.sighash; + } + if (!FormatTypes[format]) { + logger$6.throwArgumentError("invalid format type", "format", format); + } + if (format === FormatTypes.json) { + let result2 = { + type: this.baseType === "tuple" ? "tuple" : this.type, + name: this.name || void 0 + }; + if (typeof this.indexed === "boolean") { + result2.indexed = this.indexed; + } + if (this.components) { + result2.components = this.components.map((comp) => JSON.parse(comp.format(format))); + } + return JSON.stringify(result2); + } + let result = ""; + if (this.baseType === "array") { + result += this.arrayChildren.format(format); + result += "[" + (this.arrayLength < 0 ? "" : String(this.arrayLength)) + "]"; + } else { + if (this.baseType === "tuple") { + if (format !== FormatTypes.sighash) { + result += this.type; + } + result += "(" + this.components.map((comp) => comp.format(format)).join(format === FormatTypes.full ? ", " : ",") + ")"; + } else { + result += this.type; + } + } + if (format !== FormatTypes.sighash) { + if (this.indexed === true) { + result += " indexed"; + } + if (format === FormatTypes.full && this.name) { + result += " " + this.name; + } + } + return result; + } + static from(value, allowIndexed) { + if (typeof value === "string") { + return ParamType.fromString(value, allowIndexed); + } + return ParamType.fromObject(value); + } + static fromObject(value) { + if (ParamType.isParamType(value)) { + return value; + } + return new ParamType(_constructorGuard, { + name: value.name || null, + type: verifyType(value.type), + indexed: value.indexed == null ? null : !!value.indexed, + components: value.components ? value.components.map(ParamType.fromObject) : null + }); + } + static fromString(value, allowIndexed) { + function ParamTypify(node) { + return ParamType.fromObject({ + name: node.name, + type: node.type, + indexed: node.indexed, + components: node.components + }); + } + return ParamTypify(parseParamType(value, !!allowIndexed)); + } + static isParamType(value) { + return !!(value != null && value._isParamType); + } +} +function parseParams(value, allowIndex) { + return splitNesting(value).map((param) => ParamType.fromString(param, allowIndex)); +} +class Fragment { + constructor(constructorGuard, params) { + if (constructorGuard !== _constructorGuard) { + logger$6.throwError("use a static from method", Logger.errors.UNSUPPORTED_OPERATION, { + operation: "new Fragment()" + }); + } + populate(this, params); + this._isFragment = true; + Object.freeze(this); + } + static from(value) { + if (Fragment.isFragment(value)) { + return value; + } + if (typeof value === "string") { + return Fragment.fromString(value); + } + return Fragment.fromObject(value); + } + static fromObject(value) { + if (Fragment.isFragment(value)) { + return value; + } + switch (value.type) { + case "function": + return FunctionFragment.fromObject(value); + case "event": + return EventFragment.fromObject(value); + case "constructor": + return ConstructorFragment.fromObject(value); + case "error": + return ErrorFragment.fromObject(value); + case "fallback": + case "receive": + return null; + } + return logger$6.throwArgumentError("invalid fragment object", "value", value); + } + static fromString(value) { + value = value.replace(/\s/g, " "); + value = value.replace(/\(/g, " (").replace(/\)/g, ") ").replace(/\s+/g, " "); + value = value.trim(); + if (value.split(" ")[0] === "event") { + return EventFragment.fromString(value.substring(5).trim()); + } else if (value.split(" ")[0] === "function") { + return FunctionFragment.fromString(value.substring(8).trim()); + } else if (value.split("(")[0].trim() === "constructor") { + return ConstructorFragment.fromString(value.trim()); + } else if (value.split(" ")[0] === "error") { + return ErrorFragment.fromString(value.substring(5).trim()); + } + return logger$6.throwArgumentError("unsupported fragment", "value", value); + } + static isFragment(value) { + return !!(value && value._isFragment); + } +} +class EventFragment extends Fragment { + format(format) { + if (!format) { + format = FormatTypes.sighash; + } + if (!FormatTypes[format]) { + logger$6.throwArgumentError("invalid format type", "format", format); + } + if (format === FormatTypes.json) { + return JSON.stringify({ + type: "event", + anonymous: this.anonymous, + name: this.name, + inputs: this.inputs.map((input) => JSON.parse(input.format(format))) + }); + } + let result = ""; + if (format !== FormatTypes.sighash) { + result += "event "; + } + result += this.name + "(" + this.inputs.map((input) => input.format(format)).join(format === FormatTypes.full ? ", " : ",") + ") "; + if (format !== FormatTypes.sighash) { + if (this.anonymous) { + result += "anonymous "; + } + } + return result.trim(); + } + static from(value) { + if (typeof value === "string") { + return EventFragment.fromString(value); + } + return EventFragment.fromObject(value); + } + static fromObject(value) { + if (EventFragment.isEventFragment(value)) { + return value; + } + if (value.type !== "event") { + logger$6.throwArgumentError("invalid event object", "value", value); + } + const params = { + name: verifyIdentifier(value.name), + anonymous: value.anonymous, + inputs: value.inputs ? value.inputs.map(ParamType.fromObject) : [], + type: "event" + }; + return new EventFragment(_constructorGuard, params); + } + static fromString(value) { + let match = value.match(regexParen); + if (!match) { + logger$6.throwArgumentError("invalid event string", "value", value); + } + let anonymous = false; + match[3].split(" ").forEach((modifier) => { + switch (modifier.trim()) { + case "anonymous": + anonymous = true; + break; + case "": + break; + default: + logger$6.warn("unknown modifier: " + modifier); + } + }); + return EventFragment.fromObject({ + name: match[1].trim(), + anonymous, + inputs: parseParams(match[2], true), + type: "event" + }); + } + static isEventFragment(value) { + return value && value._isFragment && value.type === "event"; + } +} +function parseGas(value, params) { + params.gas = null; + let comps = value.split("@"); + if (comps.length !== 1) { + if (comps.length > 2) { + logger$6.throwArgumentError("invalid human-readable ABI signature", "value", value); + } + if (!comps[1].match(/^[0-9]+$/)) { + logger$6.throwArgumentError("invalid human-readable ABI signature gas", "value", value); + } + params.gas = BigNumber.from(comps[1]); + return comps[0]; + } + return value; +} +function parseModifiers(value, params) { + params.constant = false; + params.payable = false; + params.stateMutability = "nonpayable"; + value.split(" ").forEach((modifier) => { + switch (modifier.trim()) { + case "constant": + params.constant = true; + break; + case "payable": + params.payable = true; + params.stateMutability = "payable"; + break; + case "nonpayable": + params.payable = false; + params.stateMutability = "nonpayable"; + break; + case "pure": + params.constant = true; + params.stateMutability = "pure"; + break; + case "view": + params.constant = true; + params.stateMutability = "view"; + break; + case "external": + case "public": + case "": + break; + default: + console.log("unknown modifier: " + modifier); + } + }); +} +function verifyState(value) { + let result = { + constant: false, + payable: true, + stateMutability: "payable" + }; + if (value.stateMutability != null) { + result.stateMutability = value.stateMutability; + result.constant = result.stateMutability === "view" || result.stateMutability === "pure"; + if (value.constant != null) { + if (!!value.constant !== result.constant) { + logger$6.throwArgumentError("cannot have constant function with mutability " + result.stateMutability, "value", value); + } + } + result.payable = result.stateMutability === "payable"; + if (value.payable != null) { + if (!!value.payable !== result.payable) { + logger$6.throwArgumentError("cannot have payable function with mutability " + result.stateMutability, "value", value); + } + } + } else if (value.payable != null) { + result.payable = !!value.payable; + if (value.constant == null && !result.payable && value.type !== "constructor") { + logger$6.throwArgumentError("unable to determine stateMutability", "value", value); + } + result.constant = !!value.constant; + if (result.constant) { + result.stateMutability = "view"; + } else { + result.stateMutability = result.payable ? "payable" : "nonpayable"; + } + if (result.payable && result.constant) { + logger$6.throwArgumentError("cannot have constant payable function", "value", value); + } + } else if (value.constant != null) { + result.constant = !!value.constant; + result.payable = !result.constant; + result.stateMutability = result.constant ? "view" : "payable"; + } else if (value.type !== "constructor") { + logger$6.throwArgumentError("unable to determine stateMutability", "value", value); + } + return result; +} +class ConstructorFragment extends Fragment { + format(format) { + if (!format) { + format = FormatTypes.sighash; + } + if (!FormatTypes[format]) { + logger$6.throwArgumentError("invalid format type", "format", format); + } + if (format === FormatTypes.json) { + return JSON.stringify({ + type: "constructor", + stateMutability: this.stateMutability !== "nonpayable" ? this.stateMutability : void 0, + payable: this.payable, + gas: this.gas ? this.gas.toNumber() : void 0, + inputs: this.inputs.map((input) => JSON.parse(input.format(format))) + }); + } + if (format === FormatTypes.sighash) { + logger$6.throwError("cannot format a constructor for sighash", Logger.errors.UNSUPPORTED_OPERATION, { + operation: "format(sighash)" + }); + } + let result = "constructor(" + this.inputs.map((input) => input.format(format)).join(format === FormatTypes.full ? ", " : ",") + ") "; + if (this.stateMutability && this.stateMutability !== "nonpayable") { + result += this.stateMutability + " "; + } + return result.trim(); + } + static from(value) { + if (typeof value === "string") { + return ConstructorFragment.fromString(value); + } + return ConstructorFragment.fromObject(value); + } + static fromObject(value) { + if (ConstructorFragment.isConstructorFragment(value)) { + return value; + } + if (value.type !== "constructor") { + logger$6.throwArgumentError("invalid constructor object", "value", value); + } + let state = verifyState(value); + if (state.constant) { + logger$6.throwArgumentError("constructor cannot be constant", "value", value); + } + const params = { + name: null, + type: value.type, + inputs: value.inputs ? value.inputs.map(ParamType.fromObject) : [], + payable: state.payable, + stateMutability: state.stateMutability, + gas: value.gas ? BigNumber.from(value.gas) : null + }; + return new ConstructorFragment(_constructorGuard, params); + } + static fromString(value) { + let params = { type: "constructor" }; + value = parseGas(value, params); + let parens = value.match(regexParen); + if (!parens || parens[1].trim() !== "constructor") { + logger$6.throwArgumentError("invalid constructor string", "value", value); + } + params.inputs = parseParams(parens[2].trim(), false); + parseModifiers(parens[3].trim(), params); + return ConstructorFragment.fromObject(params); + } + static isConstructorFragment(value) { + return value && value._isFragment && value.type === "constructor"; + } +} +class FunctionFragment extends ConstructorFragment { + format(format) { + if (!format) { + format = FormatTypes.sighash; + } + if (!FormatTypes[format]) { + logger$6.throwArgumentError("invalid format type", "format", format); + } + if (format === FormatTypes.json) { + return JSON.stringify({ + type: "function", + name: this.name, + constant: this.constant, + stateMutability: this.stateMutability !== "nonpayable" ? this.stateMutability : void 0, + payable: this.payable, + gas: this.gas ? this.gas.toNumber() : void 0, + inputs: this.inputs.map((input) => JSON.parse(input.format(format))), + outputs: this.outputs.map((output) => JSON.parse(output.format(format))) + }); + } + let result = ""; + if (format !== FormatTypes.sighash) { + result += "function "; + } + result += this.name + "(" + this.inputs.map((input) => input.format(format)).join(format === FormatTypes.full ? ", " : ",") + ") "; + if (format !== FormatTypes.sighash) { + if (this.stateMutability) { + if (this.stateMutability !== "nonpayable") { + result += this.stateMutability + " "; + } + } else if (this.constant) { + result += "view "; + } + if (this.outputs && this.outputs.length) { + result += "returns (" + this.outputs.map((output) => output.format(format)).join(", ") + ") "; + } + if (this.gas != null) { + result += "@" + this.gas.toString() + " "; + } + } + return result.trim(); + } + static from(value) { + if (typeof value === "string") { + return FunctionFragment.fromString(value); + } + return FunctionFragment.fromObject(value); + } + static fromObject(value) { + if (FunctionFragment.isFunctionFragment(value)) { + return value; + } + if (value.type !== "function") { + logger$6.throwArgumentError("invalid function object", "value", value); + } + let state = verifyState(value); + const params = { + type: value.type, + name: verifyIdentifier(value.name), + constant: state.constant, + inputs: value.inputs ? value.inputs.map(ParamType.fromObject) : [], + outputs: value.outputs ? value.outputs.map(ParamType.fromObject) : [], + payable: state.payable, + stateMutability: state.stateMutability, + gas: value.gas ? BigNumber.from(value.gas) : null + }; + return new FunctionFragment(_constructorGuard, params); + } + static fromString(value) { + let params = { type: "function" }; + value = parseGas(value, params); + let comps = value.split(" returns "); + if (comps.length > 2) { + logger$6.throwArgumentError("invalid function string", "value", value); + } + let parens = comps[0].match(regexParen); + if (!parens) { + logger$6.throwArgumentError("invalid function signature", "value", value); + } + params.name = parens[1].trim(); + if (params.name) { + verifyIdentifier(params.name); + } + params.inputs = parseParams(parens[2], false); + parseModifiers(parens[3].trim(), params); + if (comps.length > 1) { + let returns = comps[1].match(regexParen); + if (returns[1].trim() != "" || returns[3].trim() != "") { + logger$6.throwArgumentError("unexpected tokens", "value", value); + } + params.outputs = parseParams(returns[2], false); + } else { + params.outputs = []; + } + return FunctionFragment.fromObject(params); + } + static isFunctionFragment(value) { + return value && value._isFragment && value.type === "function"; + } +} +function checkForbidden(fragment) { + const sig = fragment.format(); + if (sig === "Error(string)" || sig === "Panic(uint256)") { + logger$6.throwArgumentError(`cannot specify user defined ${sig} error`, "fragment", fragment); + } + return fragment; +} +class ErrorFragment extends Fragment { + format(format) { + if (!format) { + format = FormatTypes.sighash; + } + if (!FormatTypes[format]) { + logger$6.throwArgumentError("invalid format type", "format", format); + } + if (format === FormatTypes.json) { + return JSON.stringify({ + type: "error", + name: this.name, + inputs: this.inputs.map((input) => JSON.parse(input.format(format))) + }); + } + let result = ""; + if (format !== FormatTypes.sighash) { + result += "error "; + } + result += this.name + "(" + this.inputs.map((input) => input.format(format)).join(format === FormatTypes.full ? ", " : ",") + ") "; + return result.trim(); + } + static from(value) { + if (typeof value === "string") { + return ErrorFragment.fromString(value); + } + return ErrorFragment.fromObject(value); + } + static fromObject(value) { + if (ErrorFragment.isErrorFragment(value)) { + return value; + } + if (value.type !== "error") { + logger$6.throwArgumentError("invalid error object", "value", value); + } + const params = { + type: value.type, + name: verifyIdentifier(value.name), + inputs: value.inputs ? value.inputs.map(ParamType.fromObject) : [] + }; + return checkForbidden(new ErrorFragment(_constructorGuard, params)); + } + static fromString(value) { + let params = { type: "error" }; + let parens = value.match(regexParen); + if (!parens) { + logger$6.throwArgumentError("invalid error signature", "value", value); + } + params.name = parens[1].trim(); + if (params.name) { + verifyIdentifier(params.name); + } + params.inputs = parseParams(parens[2], false); + return checkForbidden(ErrorFragment.fromObject(params)); + } + static isErrorFragment(value) { + return value && value._isFragment && value.type === "error"; + } +} +function verifyType(type) { + if (type.match(/^uint($|[^1-9])/)) { + type = "uint256" + type.substring(4); + } else if (type.match(/^int($|[^1-9])/)) { + type = "int256" + type.substring(3); + } + return type; +} +const regexIdentifier = new RegExp("^[a-zA-Z$_][a-zA-Z0-9$_]*$"); +function verifyIdentifier(value) { + if (!value || !value.match(regexIdentifier)) { + logger$6.throwArgumentError(`invalid identifier "${value}"`, "value", value); + } + return value; +} +const regexParen = new RegExp("^([^)(]*)\\((.*)\\)([^)(]*)$"); +function splitNesting(value) { + value = value.trim(); + let result = []; + let accum = ""; + let depth = 0; + for (let offset = 0; offset < value.length; offset++) { + let c2 = value[offset]; + if (c2 === "," && depth === 0) { + result.push(accum); + accum = ""; + } else { + accum += c2; + if (c2 === "(") { + depth++; + } else if (c2 === ")") { + depth--; + if (depth === -1) { + logger$6.throwArgumentError("unbalanced parenthesis", "value", value); + } + } + } + } + if (accum) { + result.push(accum); + } + return result; +} +const logger$5 = new Logger(version$2); +class Coder { + constructor(name, type, localName, dynamic) { + this.name = name; + this.type = type; + this.localName = localName; + this.dynamic = dynamic; + } + _throwError(message, value) { + logger$5.throwArgumentError(message, this.localName, value); + } +} +class Writer { + constructor(wordSize) { + defineReadOnly(this, "wordSize", wordSize || 32); + this._data = []; + this._dataLength = 0; + this._padding = new Uint8Array(wordSize); + } + get data() { + return hexConcat(this._data); + } + get length() { + return this._dataLength; + } + _writeData(data) { + this._data.push(data); + this._dataLength += data.length; + return data.length; + } + appendWriter(writer) { + return this._writeData(concat(writer._data)); + } + // Arrayish items; padded on the right to wordSize + writeBytes(value) { + let bytes = arrayify(value); + const paddingOffset = bytes.length % this.wordSize; + if (paddingOffset) { + bytes = concat([bytes, this._padding.slice(paddingOffset)]); + } + return this._writeData(bytes); + } + _getValue(value) { + let bytes = arrayify(BigNumber.from(value)); + if (bytes.length > this.wordSize) { + logger$5.throwError("value out-of-bounds", Logger.errors.BUFFER_OVERRUN, { + length: this.wordSize, + offset: bytes.length + }); + } + if (bytes.length % this.wordSize) { + bytes = concat([this._padding.slice(bytes.length % this.wordSize), bytes]); + } + return bytes; + } + // BigNumberish items; padded on the left to wordSize + writeValue(value) { + return this._writeData(this._getValue(value)); + } + writeUpdatableValue() { + const offset = this._data.length; + this._data.push(this._padding); + this._dataLength += this.wordSize; + return (value) => { + this._data[offset] = this._getValue(value); + }; + } +} +class Reader { + constructor(data, wordSize, coerceFunc, allowLoose) { + defineReadOnly(this, "_data", arrayify(data)); + defineReadOnly(this, "wordSize", wordSize || 32); + defineReadOnly(this, "_coerceFunc", coerceFunc); + defineReadOnly(this, "allowLoose", allowLoose); + this._offset = 0; + } + get data() { + return hexlify(this._data); + } + get consumed() { + return this._offset; + } + // The default Coerce function + static coerce(name, value) { + let match = name.match("^u?int([0-9]+)$"); + if (match && parseInt(match[1]) <= 48) { + value = value.toNumber(); + } + return value; + } + coerce(name, value) { + if (this._coerceFunc) { + return this._coerceFunc(name, value); + } + return Reader.coerce(name, value); + } + _peekBytes(offset, length, loose) { + let alignedLength = Math.ceil(length / this.wordSize) * this.wordSize; + if (this._offset + alignedLength > this._data.length) { + if (this.allowLoose && loose && this._offset + length <= this._data.length) { + alignedLength = length; + } else { + logger$5.throwError("data out-of-bounds", Logger.errors.BUFFER_OVERRUN, { + length: this._data.length, + offset: this._offset + alignedLength + }); + } + } + return this._data.slice(this._offset, this._offset + alignedLength); + } + subReader(offset) { + return new Reader(this._data.slice(this._offset + offset), this.wordSize, this._coerceFunc, this.allowLoose); + } + readBytes(length, loose) { + let bytes = this._peekBytes(0, length, !!loose); + this._offset += bytes.length; + return bytes.slice(0, length); + } + readValue() { + return BigNumber.from(this.readBytes(this.wordSize)); + } +} +var sha3$1 = { exports: {} }; +/** + * [js-sha3]{@link https://github.com/emn178/js-sha3} + * + * @version 0.8.0 + * @author Chen, Yi-Cyuan [emn178@gmail.com] + * @copyright Chen, Yi-Cyuan 2015-2018 + * @license MIT + */ +(function(module) { + (function() { + var INPUT_ERROR = "input is invalid type"; + var FINALIZE_ERROR = "finalize already called"; + var WINDOW = typeof window === "object"; + var root = WINDOW ? window : {}; + if (root.JS_SHA3_NO_WINDOW) { + WINDOW = false; + } + var WEB_WORKER = !WINDOW && typeof self === "object"; + var NODE_JS = !root.JS_SHA3_NO_NODE_JS && typeof process === "object" && process.versions && process.versions.node; + if (NODE_JS) { + root = commonjsGlobal; + } else if (WEB_WORKER) { + root = self; + } + var COMMON_JS = !root.JS_SHA3_NO_COMMON_JS && true && module.exports; + var ARRAY_BUFFER = !root.JS_SHA3_NO_ARRAY_BUFFER && typeof ArrayBuffer !== "undefined"; + var HEX_CHARS = "0123456789abcdef".split(""); + var SHAKE_PADDING = [31, 7936, 2031616, 520093696]; + var CSHAKE_PADDING = [4, 1024, 262144, 67108864]; + var KECCAK_PADDING = [1, 256, 65536, 16777216]; + var PADDING = [6, 1536, 393216, 100663296]; + var SHIFT = [0, 8, 16, 24]; + var RC = [ + 1, + 0, + 32898, + 0, + 32906, + 2147483648, + 2147516416, + 2147483648, + 32907, + 0, + 2147483649, + 0, + 2147516545, + 2147483648, + 32777, + 2147483648, + 138, + 0, + 136, + 0, + 2147516425, + 0, + 2147483658, + 0, + 2147516555, + 0, + 139, + 2147483648, + 32905, + 2147483648, + 32771, + 2147483648, + 32770, + 2147483648, + 128, + 2147483648, + 32778, + 0, + 2147483658, + 2147483648, + 2147516545, + 2147483648, + 32896, + 2147483648, + 2147483649, + 0, + 2147516424, + 2147483648 + ]; + var BITS = [224, 256, 384, 512]; + var SHAKE_BITS = [128, 256]; + var OUTPUT_TYPES = ["hex", "buffer", "arrayBuffer", "array", "digest"]; + var CSHAKE_BYTEPAD = { + "128": 168, + "256": 136 + }; + if (root.JS_SHA3_NO_NODE_JS || !Array.isArray) { + Array.isArray = function(obj) { + return Object.prototype.toString.call(obj) === "[object Array]"; + }; + } + if (ARRAY_BUFFER && (root.JS_SHA3_NO_ARRAY_BUFFER_IS_VIEW || !ArrayBuffer.isView)) { + ArrayBuffer.isView = function(obj) { + return typeof obj === "object" && obj.buffer && obj.buffer.constructor === ArrayBuffer; + }; + } + var createOutputMethod = function(bits2, padding, outputType) { + return function(message) { + return new Keccak(bits2, padding, bits2).update(message)[outputType](); + }; + }; + var createShakeOutputMethod = function(bits2, padding, outputType) { + return function(message, outputBits) { + return new Keccak(bits2, padding, outputBits).update(message)[outputType](); + }; + }; + var createCshakeOutputMethod = function(bits2, padding, outputType) { + return function(message, outputBits, n11, s2) { + return methods["cshake" + bits2].update(message, outputBits, n11, s2)[outputType](); + }; + }; + var createKmacOutputMethod = function(bits2, padding, outputType) { + return function(key, message, outputBits, s2) { + return methods["kmac" + bits2].update(key, message, outputBits, s2)[outputType](); + }; + }; + var createOutputMethods = function(method, createMethod2, bits2, padding) { + for (var i3 = 0; i3 < OUTPUT_TYPES.length; ++i3) { + var type = OUTPUT_TYPES[i3]; + method[type] = createMethod2(bits2, padding, type); + } + return method; + }; + var createMethod = function(bits2, padding) { + var method = createOutputMethod(bits2, padding, "hex"); + method.create = function() { + return new Keccak(bits2, padding, bits2); + }; + method.update = function(message) { + return method.create().update(message); + }; + return createOutputMethods(method, createOutputMethod, bits2, padding); + }; + var createShakeMethod = function(bits2, padding) { + var method = createShakeOutputMethod(bits2, padding, "hex"); + method.create = function(outputBits) { + return new Keccak(bits2, padding, outputBits); + }; + method.update = function(message, outputBits) { + return method.create(outputBits).update(message); + }; + return createOutputMethods(method, createShakeOutputMethod, bits2, padding); + }; + var createCshakeMethod = function(bits2, padding) { + var w = CSHAKE_BYTEPAD[bits2]; + var method = createCshakeOutputMethod(bits2, padding, "hex"); + method.create = function(outputBits, n11, s2) { + if (!n11 && !s2) { + return methods["shake" + bits2].create(outputBits); + } else { + return new Keccak(bits2, padding, outputBits).bytepad([n11, s2], w); + } + }; + method.update = function(message, outputBits, n11, s2) { + return method.create(outputBits, n11, s2).update(message); + }; + return createOutputMethods(method, createCshakeOutputMethod, bits2, padding); + }; + var createKmacMethod = function(bits2, padding) { + var w = CSHAKE_BYTEPAD[bits2]; + var method = createKmacOutputMethod(bits2, padding, "hex"); + method.create = function(key, outputBits, s2) { + return new Kmac(bits2, padding, outputBits).bytepad(["KMAC", s2], w).bytepad([key], w); + }; + method.update = function(key, message, outputBits, s2) { + return method.create(key, outputBits, s2).update(message); + }; + return createOutputMethods(method, createKmacOutputMethod, bits2, padding); + }; + var algorithms = [ + { name: "keccak", padding: KECCAK_PADDING, bits: BITS, createMethod }, + { name: "sha3", padding: PADDING, bits: BITS, createMethod }, + { name: "shake", padding: SHAKE_PADDING, bits: SHAKE_BITS, createMethod: createShakeMethod }, + { name: "cshake", padding: CSHAKE_PADDING, bits: SHAKE_BITS, createMethod: createCshakeMethod }, + { name: "kmac", padding: CSHAKE_PADDING, bits: SHAKE_BITS, createMethod: createKmacMethod } + ]; + var methods = {}, methodNames = []; + for (var i2 = 0; i2 < algorithms.length; ++i2) { + var algorithm = algorithms[i2]; + var bits = algorithm.bits; + for (var j2 = 0; j2 < bits.length; ++j2) { + var methodName = algorithm.name + "_" + bits[j2]; + methodNames.push(methodName); + methods[methodName] = algorithm.createMethod(bits[j2], algorithm.padding); + if (algorithm.name !== "sha3") { + var newMethodName = algorithm.name + bits[j2]; + methodNames.push(newMethodName); + methods[newMethodName] = methods[methodName]; + } + } + } + function Keccak(bits2, padding, outputBits) { + this.blocks = []; + this.s = []; + this.padding = padding; + this.outputBits = outputBits; + this.reset = true; + this.finalized = false; + this.block = 0; + this.start = 0; + this.blockCount = 1600 - (bits2 << 1) >> 5; + this.byteCount = this.blockCount << 2; + this.outputBlocks = outputBits >> 5; + this.extraBytes = (outputBits & 31) >> 3; + for (var i3 = 0; i3 < 50; ++i3) { + this.s[i3] = 0; + } + } + Keccak.prototype.update = function(message) { + if (this.finalized) { + throw new Error(FINALIZE_ERROR); + } + var notString, type = typeof message; + if (type !== "string") { + if (type === "object") { + if (message === null) { + throw new Error(INPUT_ERROR); + } else if (ARRAY_BUFFER && message.constructor === ArrayBuffer) { + message = new Uint8Array(message); + } else if (!Array.isArray(message)) { + if (!ARRAY_BUFFER || !ArrayBuffer.isView(message)) { + throw new Error(INPUT_ERROR); + } + } + } else { + throw new Error(INPUT_ERROR); + } + notString = true; + } + var blocks = this.blocks, byteCount = this.byteCount, length = message.length, blockCount = this.blockCount, index = 0, s2 = this.s, i3, code; + while (index < length) { + if (this.reset) { + this.reset = false; + blocks[0] = this.block; + for (i3 = 1; i3 < blockCount + 1; ++i3) { + blocks[i3] = 0; + } + } + if (notString) { + for (i3 = this.start; index < length && i3 < byteCount; ++index) { + blocks[i3 >> 2] |= message[index] << SHIFT[i3++ & 3]; + } + } else { + for (i3 = this.start; index < length && i3 < byteCount; ++index) { + code = message.charCodeAt(index); + if (code < 128) { + blocks[i3 >> 2] |= code << SHIFT[i3++ & 3]; + } else if (code < 2048) { + blocks[i3 >> 2] |= (192 | code >> 6) << SHIFT[i3++ & 3]; + blocks[i3 >> 2] |= (128 | code & 63) << SHIFT[i3++ & 3]; + } else if (code < 55296 || code >= 57344) { + blocks[i3 >> 2] |= (224 | code >> 12) << SHIFT[i3++ & 3]; + blocks[i3 >> 2] |= (128 | code >> 6 & 63) << SHIFT[i3++ & 3]; + blocks[i3 >> 2] |= (128 | code & 63) << SHIFT[i3++ & 3]; + } else { + code = 65536 + ((code & 1023) << 10 | message.charCodeAt(++index) & 1023); + blocks[i3 >> 2] |= (240 | code >> 18) << SHIFT[i3++ & 3]; + blocks[i3 >> 2] |= (128 | code >> 12 & 63) << SHIFT[i3++ & 3]; + blocks[i3 >> 2] |= (128 | code >> 6 & 63) << SHIFT[i3++ & 3]; + blocks[i3 >> 2] |= (128 | code & 63) << SHIFT[i3++ & 3]; + } + } + } + this.lastByteIndex = i3; + if (i3 >= byteCount) { + this.start = i3 - byteCount; + this.block = blocks[blockCount]; + for (i3 = 0; i3 < blockCount; ++i3) { + s2[i3] ^= blocks[i3]; + } + f2(s2); + this.reset = true; + } else { + this.start = i3; + } + } + return this; + }; + Keccak.prototype.encode = function(x, right) { + var o2 = x & 255, n11 = 1; + var bytes = [o2]; + x = x >> 8; + o2 = x & 255; + while (o2 > 0) { + bytes.unshift(o2); + x = x >> 8; + o2 = x & 255; + ++n11; + } + if (right) { + bytes.push(n11); + } else { + bytes.unshift(n11); + } + this.update(bytes); + return bytes.length; + }; + Keccak.prototype.encodeString = function(str) { + var notString, type = typeof str; + if (type !== "string") { + if (type === "object") { + if (str === null) { + throw new Error(INPUT_ERROR); + } else if (ARRAY_BUFFER && str.constructor === ArrayBuffer) { + str = new Uint8Array(str); + } else if (!Array.isArray(str)) { + if (!ARRAY_BUFFER || !ArrayBuffer.isView(str)) { + throw new Error(INPUT_ERROR); + } + } + } else { + throw new Error(INPUT_ERROR); + } + notString = true; + } + var bytes = 0, length = str.length; + if (notString) { + bytes = length; + } else { + for (var i3 = 0; i3 < str.length; ++i3) { + var code = str.charCodeAt(i3); + if (code < 128) { + bytes += 1; + } else if (code < 2048) { + bytes += 2; + } else if (code < 55296 || code >= 57344) { + bytes += 3; + } else { + code = 65536 + ((code & 1023) << 10 | str.charCodeAt(++i3) & 1023); + bytes += 4; + } + } + } + bytes += this.encode(bytes * 8); + this.update(str); + return bytes; + }; + Keccak.prototype.bytepad = function(strs, w) { + var bytes = this.encode(w); + for (var i3 = 0; i3 < strs.length; ++i3) { + bytes += this.encodeString(strs[i3]); + } + var paddingBytes = w - bytes % w; + var zeros = []; + zeros.length = paddingBytes; + this.update(zeros); + return this; + }; + Keccak.prototype.finalize = function() { + if (this.finalized) { + return; + } + this.finalized = true; + var blocks = this.blocks, i3 = this.lastByteIndex, blockCount = this.blockCount, s2 = this.s; + blocks[i3 >> 2] |= this.padding[i3 & 3]; + if (this.lastByteIndex === this.byteCount) { + blocks[0] = blocks[blockCount]; + for (i3 = 1; i3 < blockCount + 1; ++i3) { + blocks[i3] = 0; + } + } + blocks[blockCount - 1] |= 2147483648; + for (i3 = 0; i3 < blockCount; ++i3) { + s2[i3] ^= blocks[i3]; + } + f2(s2); + }; + Keccak.prototype.toString = Keccak.prototype.hex = function() { + this.finalize(); + var blockCount = this.blockCount, s2 = this.s, outputBlocks = this.outputBlocks, extraBytes = this.extraBytes, i3 = 0, j3 = 0; + var hex = "", block; + while (j3 < outputBlocks) { + for (i3 = 0; i3 < blockCount && j3 < outputBlocks; ++i3, ++j3) { + block = s2[i3]; + hex += HEX_CHARS[block >> 4 & 15] + HEX_CHARS[block & 15] + HEX_CHARS[block >> 12 & 15] + HEX_CHARS[block >> 8 & 15] + HEX_CHARS[block >> 20 & 15] + HEX_CHARS[block >> 16 & 15] + HEX_CHARS[block >> 28 & 15] + HEX_CHARS[block >> 24 & 15]; + } + if (j3 % blockCount === 0) { + f2(s2); + i3 = 0; + } + } + if (extraBytes) { + block = s2[i3]; + hex += HEX_CHARS[block >> 4 & 15] + HEX_CHARS[block & 15]; + if (extraBytes > 1) { + hex += HEX_CHARS[block >> 12 & 15] + HEX_CHARS[block >> 8 & 15]; + } + if (extraBytes > 2) { + hex += HEX_CHARS[block >> 20 & 15] + HEX_CHARS[block >> 16 & 15]; + } + } + return hex; + }; + Keccak.prototype.arrayBuffer = function() { + this.finalize(); + var blockCount = this.blockCount, s2 = this.s, outputBlocks = this.outputBlocks, extraBytes = this.extraBytes, i3 = 0, j3 = 0; + var bytes = this.outputBits >> 3; + var buffer; + if (extraBytes) { + buffer = new ArrayBuffer(outputBlocks + 1 << 2); + } else { + buffer = new ArrayBuffer(bytes); + } + var array = new Uint32Array(buffer); + while (j3 < outputBlocks) { + for (i3 = 0; i3 < blockCount && j3 < outputBlocks; ++i3, ++j3) { + array[j3] = s2[i3]; + } + if (j3 % blockCount === 0) { + f2(s2); + } + } + if (extraBytes) { + array[i3] = s2[i3]; + buffer = buffer.slice(0, bytes); + } + return buffer; + }; + Keccak.prototype.buffer = Keccak.prototype.arrayBuffer; + Keccak.prototype.digest = Keccak.prototype.array = function() { + this.finalize(); + var blockCount = this.blockCount, s2 = this.s, outputBlocks = this.outputBlocks, extraBytes = this.extraBytes, i3 = 0, j3 = 0; + var array = [], offset, block; + while (j3 < outputBlocks) { + for (i3 = 0; i3 < blockCount && j3 < outputBlocks; ++i3, ++j3) { + offset = j3 << 2; + block = s2[i3]; + array[offset] = block & 255; + array[offset + 1] = block >> 8 & 255; + array[offset + 2] = block >> 16 & 255; + array[offset + 3] = block >> 24 & 255; + } + if (j3 % blockCount === 0) { + f2(s2); + } + } + if (extraBytes) { + offset = j3 << 2; + block = s2[i3]; + array[offset] = block & 255; + if (extraBytes > 1) { + array[offset + 1] = block >> 8 & 255; + } + if (extraBytes > 2) { + array[offset + 2] = block >> 16 & 255; + } + } + return array; + }; + function Kmac(bits2, padding, outputBits) { + Keccak.call(this, bits2, padding, outputBits); + } + Kmac.prototype = new Keccak(); + Kmac.prototype.finalize = function() { + this.encode(this.outputBits, true); + return Keccak.prototype.finalize.call(this); + }; + var f2 = function(s2) { + var h2, l2, n11, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39, b40, b41, b42, b43, b44, b45, b46, b47, b48, b49; + for (n11 = 0; n11 < 48; n11 += 2) { + c0 = s2[0] ^ s2[10] ^ s2[20] ^ s2[30] ^ s2[40]; + c1 = s2[1] ^ s2[11] ^ s2[21] ^ s2[31] ^ s2[41]; + c2 = s2[2] ^ s2[12] ^ s2[22] ^ s2[32] ^ s2[42]; + c3 = s2[3] ^ s2[13] ^ s2[23] ^ s2[33] ^ s2[43]; + c4 = s2[4] ^ s2[14] ^ s2[24] ^ s2[34] ^ s2[44]; + c5 = s2[5] ^ s2[15] ^ s2[25] ^ s2[35] ^ s2[45]; + c6 = s2[6] ^ s2[16] ^ s2[26] ^ s2[36] ^ s2[46]; + c7 = s2[7] ^ s2[17] ^ s2[27] ^ s2[37] ^ s2[47]; + c8 = s2[8] ^ s2[18] ^ s2[28] ^ s2[38] ^ s2[48]; + c9 = s2[9] ^ s2[19] ^ s2[29] ^ s2[39] ^ s2[49]; + h2 = c8 ^ (c2 << 1 | c3 >>> 31); + l2 = c9 ^ (c3 << 1 | c2 >>> 31); + s2[0] ^= h2; + s2[1] ^= l2; + s2[10] ^= h2; + s2[11] ^= l2; + s2[20] ^= h2; + s2[21] ^= l2; + s2[30] ^= h2; + s2[31] ^= l2; + s2[40] ^= h2; + s2[41] ^= l2; + h2 = c0 ^ (c4 << 1 | c5 >>> 31); + l2 = c1 ^ (c5 << 1 | c4 >>> 31); + s2[2] ^= h2; + s2[3] ^= l2; + s2[12] ^= h2; + s2[13] ^= l2; + s2[22] ^= h2; + s2[23] ^= l2; + s2[32] ^= h2; + s2[33] ^= l2; + s2[42] ^= h2; + s2[43] ^= l2; + h2 = c2 ^ (c6 << 1 | c7 >>> 31); + l2 = c3 ^ (c7 << 1 | c6 >>> 31); + s2[4] ^= h2; + s2[5] ^= l2; + s2[14] ^= h2; + s2[15] ^= l2; + s2[24] ^= h2; + s2[25] ^= l2; + s2[34] ^= h2; + s2[35] ^= l2; + s2[44] ^= h2; + s2[45] ^= l2; + h2 = c4 ^ (c8 << 1 | c9 >>> 31); + l2 = c5 ^ (c9 << 1 | c8 >>> 31); + s2[6] ^= h2; + s2[7] ^= l2; + s2[16] ^= h2; + s2[17] ^= l2; + s2[26] ^= h2; + s2[27] ^= l2; + s2[36] ^= h2; + s2[37] ^= l2; + s2[46] ^= h2; + s2[47] ^= l2; + h2 = c6 ^ (c0 << 1 | c1 >>> 31); + l2 = c7 ^ (c1 << 1 | c0 >>> 31); + s2[8] ^= h2; + s2[9] ^= l2; + s2[18] ^= h2; + s2[19] ^= l2; + s2[28] ^= h2; + s2[29] ^= l2; + s2[38] ^= h2; + s2[39] ^= l2; + s2[48] ^= h2; + s2[49] ^= l2; + b0 = s2[0]; + b1 = s2[1]; + b32 = s2[11] << 4 | s2[10] >>> 28; + b33 = s2[10] << 4 | s2[11] >>> 28; + b14 = s2[20] << 3 | s2[21] >>> 29; + b15 = s2[21] << 3 | s2[20] >>> 29; + b46 = s2[31] << 9 | s2[30] >>> 23; + b47 = s2[30] << 9 | s2[31] >>> 23; + b28 = s2[40] << 18 | s2[41] >>> 14; + b29 = s2[41] << 18 | s2[40] >>> 14; + b20 = s2[2] << 1 | s2[3] >>> 31; + b21 = s2[3] << 1 | s2[2] >>> 31; + b2 = s2[13] << 12 | s2[12] >>> 20; + b3 = s2[12] << 12 | s2[13] >>> 20; + b34 = s2[22] << 10 | s2[23] >>> 22; + b35 = s2[23] << 10 | s2[22] >>> 22; + b16 = s2[33] << 13 | s2[32] >>> 19; + b17 = s2[32] << 13 | s2[33] >>> 19; + b48 = s2[42] << 2 | s2[43] >>> 30; + b49 = s2[43] << 2 | s2[42] >>> 30; + b40 = s2[5] << 30 | s2[4] >>> 2; + b41 = s2[4] << 30 | s2[5] >>> 2; + b22 = s2[14] << 6 | s2[15] >>> 26; + b23 = s2[15] << 6 | s2[14] >>> 26; + b4 = s2[25] << 11 | s2[24] >>> 21; + b5 = s2[24] << 11 | s2[25] >>> 21; + b36 = s2[34] << 15 | s2[35] >>> 17; + b37 = s2[35] << 15 | s2[34] >>> 17; + b18 = s2[45] << 29 | s2[44] >>> 3; + b19 = s2[44] << 29 | s2[45] >>> 3; + b10 = s2[6] << 28 | s2[7] >>> 4; + b11 = s2[7] << 28 | s2[6] >>> 4; + b42 = s2[17] << 23 | s2[16] >>> 9; + b43 = s2[16] << 23 | s2[17] >>> 9; + b24 = s2[26] << 25 | s2[27] >>> 7; + b25 = s2[27] << 25 | s2[26] >>> 7; + b6 = s2[36] << 21 | s2[37] >>> 11; + b7 = s2[37] << 21 | s2[36] >>> 11; + b38 = s2[47] << 24 | s2[46] >>> 8; + b39 = s2[46] << 24 | s2[47] >>> 8; + b30 = s2[8] << 27 | s2[9] >>> 5; + b31 = s2[9] << 27 | s2[8] >>> 5; + b12 = s2[18] << 20 | s2[19] >>> 12; + b13 = s2[19] << 20 | s2[18] >>> 12; + b44 = s2[29] << 7 | s2[28] >>> 25; + b45 = s2[28] << 7 | s2[29] >>> 25; + b26 = s2[38] << 8 | s2[39] >>> 24; + b27 = s2[39] << 8 | s2[38] >>> 24; + b8 = s2[48] << 14 | s2[49] >>> 18; + b9 = s2[49] << 14 | s2[48] >>> 18; + s2[0] = b0 ^ ~b2 & b4; + s2[1] = b1 ^ ~b3 & b5; + s2[10] = b10 ^ ~b12 & b14; + s2[11] = b11 ^ ~b13 & b15; + s2[20] = b20 ^ ~b22 & b24; + s2[21] = b21 ^ ~b23 & b25; + s2[30] = b30 ^ ~b32 & b34; + s2[31] = b31 ^ ~b33 & b35; + s2[40] = b40 ^ ~b42 & b44; + s2[41] = b41 ^ ~b43 & b45; + s2[2] = b2 ^ ~b4 & b6; + s2[3] = b3 ^ ~b5 & b7; + s2[12] = b12 ^ ~b14 & b16; + s2[13] = b13 ^ ~b15 & b17; + s2[22] = b22 ^ ~b24 & b26; + s2[23] = b23 ^ ~b25 & b27; + s2[32] = b32 ^ ~b34 & b36; + s2[33] = b33 ^ ~b35 & b37; + s2[42] = b42 ^ ~b44 & b46; + s2[43] = b43 ^ ~b45 & b47; + s2[4] = b4 ^ ~b6 & b8; + s2[5] = b5 ^ ~b7 & b9; + s2[14] = b14 ^ ~b16 & b18; + s2[15] = b15 ^ ~b17 & b19; + s2[24] = b24 ^ ~b26 & b28; + s2[25] = b25 ^ ~b27 & b29; + s2[34] = b34 ^ ~b36 & b38; + s2[35] = b35 ^ ~b37 & b39; + s2[44] = b44 ^ ~b46 & b48; + s2[45] = b45 ^ ~b47 & b49; + s2[6] = b6 ^ ~b8 & b0; + s2[7] = b7 ^ ~b9 & b1; + s2[16] = b16 ^ ~b18 & b10; + s2[17] = b17 ^ ~b19 & b11; + s2[26] = b26 ^ ~b28 & b20; + s2[27] = b27 ^ ~b29 & b21; + s2[36] = b36 ^ ~b38 & b30; + s2[37] = b37 ^ ~b39 & b31; + s2[46] = b46 ^ ~b48 & b40; + s2[47] = b47 ^ ~b49 & b41; + s2[8] = b8 ^ ~b0 & b2; + s2[9] = b9 ^ ~b1 & b3; + s2[18] = b18 ^ ~b10 & b12; + s2[19] = b19 ^ ~b11 & b13; + s2[28] = b28 ^ ~b20 & b22; + s2[29] = b29 ^ ~b21 & b23; + s2[38] = b38 ^ ~b30 & b32; + s2[39] = b39 ^ ~b31 & b33; + s2[48] = b48 ^ ~b40 & b42; + s2[49] = b49 ^ ~b41 & b43; + s2[0] ^= RC[n11]; + s2[1] ^= RC[n11 + 1]; + } + }; + if (COMMON_JS) { + module.exports = methods; + } else { + for (i2 = 0; i2 < methodNames.length; ++i2) { + root[methodNames[i2]] = methods[methodNames[i2]]; + } + } + })(); +})(sha3$1); +var sha3Exports = sha3$1.exports; +const sha3 = /* @__PURE__ */ getDefaultExportFromCjs(sha3Exports); +function keccak256(data) { + return "0x" + sha3.keccak_256(arrayify(data)); +} +const version$1 = "address/5.7.0"; +const logger$4 = new Logger(version$1); +function getChecksumAddress(address) { + if (!isHexString(address, 20)) { + logger$4.throwArgumentError("invalid address", "address", address); + } + address = address.toLowerCase(); + const chars = address.substring(2).split(""); + const expanded = new Uint8Array(40); + for (let i2 = 0; i2 < 40; i2++) { + expanded[i2] = chars[i2].charCodeAt(0); + } + const hashed = arrayify(keccak256(expanded)); + for (let i2 = 0; i2 < 40; i2 += 2) { + if (hashed[i2 >> 1] >> 4 >= 8) { + chars[i2] = chars[i2].toUpperCase(); + } + if ((hashed[i2 >> 1] & 15) >= 8) { + chars[i2 + 1] = chars[i2 + 1].toUpperCase(); + } + } + return "0x" + chars.join(""); +} +const MAX_SAFE_INTEGER = 9007199254740991; +function log10(x) { + if (Math.log10) { + return Math.log10(x); + } + return Math.log(x) / Math.LN10; +} +const ibanLookup = {}; +for (let i2 = 0; i2 < 10; i2++) { + ibanLookup[String(i2)] = String(i2); +} +for (let i2 = 0; i2 < 26; i2++) { + ibanLookup[String.fromCharCode(65 + i2)] = String(10 + i2); +} +const safeDigits = Math.floor(log10(MAX_SAFE_INTEGER)); +function ibanChecksum(address) { + address = address.toUpperCase(); + address = address.substring(4) + address.substring(0, 2) + "00"; + let expanded = address.split("").map((c2) => { + return ibanLookup[c2]; + }).join(""); + while (expanded.length >= safeDigits) { + let block = expanded.substring(0, safeDigits); + expanded = parseInt(block, 10) % 97 + expanded.substring(block.length); + } + let checksum = String(98 - parseInt(expanded, 10) % 97); + while (checksum.length < 2) { + checksum = "0" + checksum; + } + return checksum; +} +function getAddress(address) { + let result = null; + if (typeof address !== "string") { + logger$4.throwArgumentError("invalid address", "address", address); + } + if (address.match(/^(0x)?[0-9a-fA-F]{40}$/)) { + if (address.substring(0, 2) !== "0x") { + address = "0x" + address; + } + result = getChecksumAddress(address); + if (address.match(/([A-F].*[a-f])|([a-f].*[A-F])/) && result !== address) { + logger$4.throwArgumentError("bad address checksum", "address", address); + } + } else if (address.match(/^XE[0-9]{2}[0-9A-Za-z]{30,31}$/)) { + if (address.substring(2, 4) !== ibanChecksum(address)) { + logger$4.throwArgumentError("bad icap checksum", "address", address); + } + result = _base36To16(address.substring(4)); + while (result.length < 40) { + result = "0" + result; + } + result = getChecksumAddress("0x" + result); + } else { + logger$4.throwArgumentError("invalid address", "address", address); + } + return result; +} +class AddressCoder extends Coder { + constructor(localName) { + super("address", "address", localName, false); + } + defaultValue() { + return "0x0000000000000000000000000000000000000000"; + } + encode(writer, value) { + try { + value = getAddress(value); + } catch (error) { + this._throwError(error.message, value); + } + return writer.writeValue(value); + } + decode(reader) { + return getAddress(hexZeroPad(reader.readValue().toHexString(), 20)); + } +} +class AnonymousCoder extends Coder { + constructor(coder) { + super(coder.name, coder.type, void 0, coder.dynamic); + this.coder = coder; + } + defaultValue() { + return this.coder.defaultValue(); + } + encode(writer, value) { + return this.coder.encode(writer, value); + } + decode(reader) { + return this.coder.decode(reader); + } +} +const logger$3 = new Logger(version$2); +function pack(writer, coders, values) { + let arrayValues = null; + if (Array.isArray(values)) { + arrayValues = values; + } else if (values && typeof values === "object") { + let unique = {}; + arrayValues = coders.map((coder) => { + const name = coder.localName; + if (!name) { + logger$3.throwError("cannot encode object for signature with missing names", Logger.errors.INVALID_ARGUMENT, { + argument: "values", + coder, + value: values + }); + } + if (unique[name]) { + logger$3.throwError("cannot encode object for signature with duplicate names", Logger.errors.INVALID_ARGUMENT, { + argument: "values", + coder, + value: values + }); + } + unique[name] = true; + return values[name]; + }); + } else { + logger$3.throwArgumentError("invalid tuple value", "tuple", values); + } + if (coders.length !== arrayValues.length) { + logger$3.throwArgumentError("types/value length mismatch", "tuple", values); + } + let staticWriter = new Writer(writer.wordSize); + let dynamicWriter = new Writer(writer.wordSize); + let updateFuncs = []; + coders.forEach((coder, index) => { + let value = arrayValues[index]; + if (coder.dynamic) { + let dynamicOffset = dynamicWriter.length; + coder.encode(dynamicWriter, value); + let updateFunc = staticWriter.writeUpdatableValue(); + updateFuncs.push((baseOffset) => { + updateFunc(baseOffset + dynamicOffset); + }); + } else { + coder.encode(staticWriter, value); + } + }); + updateFuncs.forEach((func) => { + func(staticWriter.length); + }); + let length = writer.appendWriter(staticWriter); + length += writer.appendWriter(dynamicWriter); + return length; +} +function unpack(reader, coders) { + let values = []; + let baseReader = reader.subReader(0); + coders.forEach((coder) => { + let value = null; + if (coder.dynamic) { + let offset = reader.readValue(); + let offsetReader = baseReader.subReader(offset.toNumber()); + try { + value = coder.decode(offsetReader); + } catch (error) { + if (error.code === Logger.errors.BUFFER_OVERRUN) { + throw error; + } + value = error; + value.baseType = coder.name; + value.name = coder.localName; + value.type = coder.type; + } + } else { + try { + value = coder.decode(reader); + } catch (error) { + if (error.code === Logger.errors.BUFFER_OVERRUN) { + throw error; + } + value = error; + value.baseType = coder.name; + value.name = coder.localName; + value.type = coder.type; + } + } + if (value != void 0) { + values.push(value); + } + }); + const uniqueNames = coders.reduce((accum, coder) => { + const name = coder.localName; + if (name) { + if (!accum[name]) { + accum[name] = 0; + } + accum[name]++; + } + return accum; + }, {}); + coders.forEach((coder, index) => { + let name = coder.localName; + if (!name || uniqueNames[name] !== 1) { + return; + } + if (name === "length") { + name = "_length"; + } + if (values[name] != null) { + return; + } + const value = values[index]; + if (value instanceof Error) { + Object.defineProperty(values, name, { + enumerable: true, + get: () => { + throw value; + } + }); + } else { + values[name] = value; + } + }); + for (let i2 = 0; i2 < values.length; i2++) { + const value = values[i2]; + if (value instanceof Error) { + Object.defineProperty(values, i2, { + enumerable: true, + get: () => { + throw value; + } + }); + } + } + return Object.freeze(values); +} +class ArrayCoder extends Coder { + constructor(coder, length, localName) { + const type = coder.type + "[" + (length >= 0 ? length : "") + "]"; + const dynamic = length === -1 || coder.dynamic; + super("array", type, localName, dynamic); + this.coder = coder; + this.length = length; + } + defaultValue() { + const defaultChild = this.coder.defaultValue(); + const result = []; + for (let i2 = 0; i2 < this.length; i2++) { + result.push(defaultChild); + } + return result; + } + encode(writer, value) { + if (!Array.isArray(value)) { + this._throwError("expected array value", value); + } + let count = this.length; + if (count === -1) { + count = value.length; + writer.writeValue(value.length); + } + logger$3.checkArgumentCount(value.length, count, "coder array" + (this.localName ? " " + this.localName : "")); + let coders = []; + for (let i2 = 0; i2 < value.length; i2++) { + coders.push(this.coder); + } + return pack(writer, coders, value); + } + decode(reader) { + let count = this.length; + if (count === -1) { + count = reader.readValue().toNumber(); + if (count * 32 > reader._data.length) { + logger$3.throwError("insufficient data length", Logger.errors.BUFFER_OVERRUN, { + length: reader._data.length, + count + }); + } + } + let coders = []; + for (let i2 = 0; i2 < count; i2++) { + coders.push(new AnonymousCoder(this.coder)); + } + return reader.coerce(this.name, unpack(reader, coders)); + } +} +class BooleanCoder extends Coder { + constructor(localName) { + super("bool", "bool", localName, false); + } + defaultValue() { + return false; + } + encode(writer, value) { + return writer.writeValue(value ? 1 : 0); + } + decode(reader) { + return reader.coerce(this.type, !reader.readValue().isZero()); + } +} +class DynamicBytesCoder extends Coder { + constructor(type, localName) { + super(type, type, localName, true); + } + defaultValue() { + return "0x"; + } + encode(writer, value) { + value = arrayify(value); + let length = writer.writeValue(value.length); + length += writer.writeBytes(value); + return length; + } + decode(reader) { + return reader.readBytes(reader.readValue().toNumber(), true); + } +} +class BytesCoder extends DynamicBytesCoder { + constructor(localName) { + super("bytes", localName); + } + decode(reader) { + return reader.coerce(this.name, hexlify(super.decode(reader))); + } +} +class FixedBytesCoder extends Coder { + constructor(size, localName) { + let name = "bytes" + String(size); + super(name, name, localName, false); + this.size = size; + } + defaultValue() { + return "0x0000000000000000000000000000000000000000000000000000000000000000".substring(0, 2 + this.size * 2); + } + encode(writer, value) { + let data = arrayify(value); + if (data.length !== this.size) { + this._throwError("incorrect data length", value); + } + return writer.writeBytes(data); + } + decode(reader) { + return reader.coerce(this.name, hexlify(reader.readBytes(this.size))); + } +} +class NullCoder extends Coder { + constructor(localName) { + super("null", "", localName, false); + } + defaultValue() { + return null; + } + encode(writer, value) { + if (value != null) { + this._throwError("not null", value); + } + return writer.writeBytes([]); + } + decode(reader) { + reader.readBytes(0); + return reader.coerce(this.name, null); + } +} +const NegativeOne = /* @__PURE__ */ BigNumber.from(-1); +const Zero = /* @__PURE__ */ BigNumber.from(0); +const One = /* @__PURE__ */ BigNumber.from(1); +const MaxUint256 = /* @__PURE__ */ BigNumber.from("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); +class NumberCoder extends Coder { + constructor(size, signed, localName) { + const name = (signed ? "int" : "uint") + size * 8; + super(name, name, localName, false); + this.size = size; + this.signed = signed; + } + defaultValue() { + return 0; + } + encode(writer, value) { + let v2 = BigNumber.from(value); + let maxUintValue = MaxUint256.mask(writer.wordSize * 8); + if (this.signed) { + let bounds = maxUintValue.mask(this.size * 8 - 1); + if (v2.gt(bounds) || v2.lt(bounds.add(One).mul(NegativeOne))) { + this._throwError("value out-of-bounds", value); + } + } else if (v2.lt(Zero) || v2.gt(maxUintValue.mask(this.size * 8))) { + this._throwError("value out-of-bounds", value); + } + v2 = v2.toTwos(this.size * 8).mask(this.size * 8); + if (this.signed) { + v2 = v2.fromTwos(this.size * 8).toTwos(8 * writer.wordSize); + } + return writer.writeValue(v2); + } + decode(reader) { + let value = reader.readValue().mask(this.size * 8); + if (this.signed) { + value = value.fromTwos(this.size * 8); + } + return reader.coerce(this.name, value); + } +} +const version = "strings/5.7.0"; +const logger$2 = new Logger(version); +var UnicodeNormalizationForm; +(function(UnicodeNormalizationForm2) { + UnicodeNormalizationForm2["current"] = ""; + UnicodeNormalizationForm2["NFC"] = "NFC"; + UnicodeNormalizationForm2["NFD"] = "NFD"; + UnicodeNormalizationForm2["NFKC"] = "NFKC"; + UnicodeNormalizationForm2["NFKD"] = "NFKD"; +})(UnicodeNormalizationForm || (UnicodeNormalizationForm = {})); +var Utf8ErrorReason; +(function(Utf8ErrorReason2) { + Utf8ErrorReason2["UNEXPECTED_CONTINUE"] = "unexpected continuation byte"; + Utf8ErrorReason2["BAD_PREFIX"] = "bad codepoint prefix"; + Utf8ErrorReason2["OVERRUN"] = "string overrun"; + Utf8ErrorReason2["MISSING_CONTINUE"] = "missing continuation byte"; + Utf8ErrorReason2["OUT_OF_RANGE"] = "out of UTF-8 range"; + Utf8ErrorReason2["UTF16_SURROGATE"] = "UTF-16 surrogate"; + Utf8ErrorReason2["OVERLONG"] = "overlong representation"; +})(Utf8ErrorReason || (Utf8ErrorReason = {})); +function errorFunc(reason, offset, bytes, output, badCodepoint) { + return logger$2.throwArgumentError(`invalid codepoint at offset ${offset}; ${reason}`, "bytes", bytes); +} +function ignoreFunc(reason, offset, bytes, output, badCodepoint) { + if (reason === Utf8ErrorReason.BAD_PREFIX || reason === Utf8ErrorReason.UNEXPECTED_CONTINUE) { + let i2 = 0; + for (let o2 = offset + 1; o2 < bytes.length; o2++) { + if (bytes[o2] >> 6 !== 2) { + break; + } + i2++; + } + return i2; + } + if (reason === Utf8ErrorReason.OVERRUN) { + return bytes.length - offset - 1; + } + return 0; +} +function replaceFunc(reason, offset, bytes, output, badCodepoint) { + if (reason === Utf8ErrorReason.OVERLONG) { + output.push(badCodepoint); + return 0; + } + output.push(65533); + return ignoreFunc(reason, offset, bytes); +} +const Utf8ErrorFuncs = Object.freeze({ + error: errorFunc, + ignore: ignoreFunc, + replace: replaceFunc +}); +function getUtf8CodePoints(bytes, onError) { + if (onError == null) { + onError = Utf8ErrorFuncs.error; + } + bytes = arrayify(bytes); + const result = []; + let i2 = 0; + while (i2 < bytes.length) { + const c2 = bytes[i2++]; + if (c2 >> 7 === 0) { + result.push(c2); + continue; + } + let extraLength = null; + let overlongMask = null; + if ((c2 & 224) === 192) { + extraLength = 1; + overlongMask = 127; + } else if ((c2 & 240) === 224) { + extraLength = 2; + overlongMask = 2047; + } else if ((c2 & 248) === 240) { + extraLength = 3; + overlongMask = 65535; + } else { + if ((c2 & 192) === 128) { + i2 += onError(Utf8ErrorReason.UNEXPECTED_CONTINUE, i2 - 1, bytes, result); + } else { + i2 += onError(Utf8ErrorReason.BAD_PREFIX, i2 - 1, bytes, result); + } + continue; + } + if (i2 - 1 + extraLength >= bytes.length) { + i2 += onError(Utf8ErrorReason.OVERRUN, i2 - 1, bytes, result); + continue; + } + let res = c2 & (1 << 8 - extraLength - 1) - 1; + for (let j2 = 0; j2 < extraLength; j2++) { + let nextChar = bytes[i2]; + if ((nextChar & 192) != 128) { + i2 += onError(Utf8ErrorReason.MISSING_CONTINUE, i2, bytes, result); + res = null; + break; + } + res = res << 6 | nextChar & 63; + i2++; + } + if (res === null) { + continue; + } + if (res > 1114111) { + i2 += onError(Utf8ErrorReason.OUT_OF_RANGE, i2 - 1 - extraLength, bytes, result, res); + continue; + } + if (res >= 55296 && res <= 57343) { + i2 += onError(Utf8ErrorReason.UTF16_SURROGATE, i2 - 1 - extraLength, bytes, result, res); + continue; + } + if (res <= overlongMask) { + i2 += onError(Utf8ErrorReason.OVERLONG, i2 - 1 - extraLength, bytes, result, res); + continue; + } + result.push(res); + } + return result; +} +function toUtf8Bytes(str, form = UnicodeNormalizationForm.current) { + if (form != UnicodeNormalizationForm.current) { + logger$2.checkNormalize(); + str = str.normalize(form); + } + let result = []; + for (let i2 = 0; i2 < str.length; i2++) { + const c2 = str.charCodeAt(i2); + if (c2 < 128) { + result.push(c2); + } else if (c2 < 2048) { + result.push(c2 >> 6 | 192); + result.push(c2 & 63 | 128); + } else if ((c2 & 64512) == 55296) { + i2++; + const c22 = str.charCodeAt(i2); + if (i2 >= str.length || (c22 & 64512) !== 56320) { + throw new Error("invalid utf-8 string"); + } + const pair = 65536 + ((c2 & 1023) << 10) + (c22 & 1023); + result.push(pair >> 18 | 240); + result.push(pair >> 12 & 63 | 128); + result.push(pair >> 6 & 63 | 128); + result.push(pair & 63 | 128); + } else { + result.push(c2 >> 12 | 224); + result.push(c2 >> 6 & 63 | 128); + result.push(c2 & 63 | 128); + } + } + return arrayify(result); +} +function _toUtf8String(codePoints) { + return codePoints.map((codePoint) => { + if (codePoint <= 65535) { + return String.fromCharCode(codePoint); + } + codePoint -= 65536; + return String.fromCharCode((codePoint >> 10 & 1023) + 55296, (codePoint & 1023) + 56320); + }).join(""); +} +function toUtf8String(bytes, onError) { + return _toUtf8String(getUtf8CodePoints(bytes, onError)); +} +class StringCoder extends DynamicBytesCoder { + constructor(localName) { + super("string", localName); + } + defaultValue() { + return ""; + } + encode(writer, value) { + return super.encode(writer, toUtf8Bytes(value)); + } + decode(reader) { + return toUtf8String(super.decode(reader)); + } +} +class TupleCoder extends Coder { + constructor(coders, localName) { + let dynamic = false; + const types = []; + coders.forEach((coder) => { + if (coder.dynamic) { + dynamic = true; + } + types.push(coder.type); + }); + const type = "tuple(" + types.join(",") + ")"; + super("tuple", type, localName, dynamic); + this.coders = coders; + } + defaultValue() { + const values = []; + this.coders.forEach((coder) => { + values.push(coder.defaultValue()); + }); + const uniqueNames = this.coders.reduce((accum, coder) => { + const name = coder.localName; + if (name) { + if (!accum[name]) { + accum[name] = 0; + } + accum[name]++; + } + return accum; + }, {}); + this.coders.forEach((coder, index) => { + let name = coder.localName; + if (!name || uniqueNames[name] !== 1) { + return; + } + if (name === "length") { + name = "_length"; + } + if (values[name] != null) { + return; + } + values[name] = values[index]; + }); + return Object.freeze(values); + } + encode(writer, value) { + return pack(writer, this.coders, value); + } + decode(reader) { + return reader.coerce(this.name, unpack(reader, this.coders)); + } +} +const logger$1 = new Logger(version$2); +const paramTypeBytes = new RegExp(/^bytes([0-9]*)$/); +const paramTypeNumber = new RegExp(/^(u?int)([0-9]*)$/); +class AbiCoder { + constructor(coerceFunc) { + defineReadOnly(this, "coerceFunc", coerceFunc || null); + } + _getCoder(param) { + switch (param.baseType) { + case "address": + return new AddressCoder(param.name); + case "bool": + return new BooleanCoder(param.name); + case "string": + return new StringCoder(param.name); + case "bytes": + return new BytesCoder(param.name); + case "array": + return new ArrayCoder(this._getCoder(param.arrayChildren), param.arrayLength, param.name); + case "tuple": + return new TupleCoder((param.components || []).map((component) => { + return this._getCoder(component); + }), param.name); + case "": + return new NullCoder(param.name); + } + let match = param.type.match(paramTypeNumber); + if (match) { + let size = parseInt(match[2] || "256"); + if (size === 0 || size > 256 || size % 8 !== 0) { + logger$1.throwArgumentError("invalid " + match[1] + " bit length", "param", param); + } + return new NumberCoder(size / 8, match[1] === "int", param.name); + } + match = param.type.match(paramTypeBytes); + if (match) { + let size = parseInt(match[1]); + if (size === 0 || size > 32) { + logger$1.throwArgumentError("invalid bytes length", "param", param); + } + return new FixedBytesCoder(size, param.name); + } + return logger$1.throwArgumentError("invalid type", "type", param.type); + } + _getWordSize() { + return 32; + } + _getReader(data, allowLoose) { + return new Reader(data, this._getWordSize(), this.coerceFunc, allowLoose); + } + _getWriter() { + return new Writer(this._getWordSize()); + } + getDefaultValue(types) { + const coders = types.map((type) => this._getCoder(ParamType.from(type))); + const coder = new TupleCoder(coders, "_"); + return coder.defaultValue(); + } + encode(types, values) { + if (types.length !== values.length) { + logger$1.throwError("types/values length mismatch", Logger.errors.INVALID_ARGUMENT, { + count: { types: types.length, values: values.length }, + value: { types, values } + }); + } + const coders = types.map((type) => this._getCoder(ParamType.from(type))); + const coder = new TupleCoder(coders, "_"); + const writer = this._getWriter(); + coder.encode(writer, values); + return writer.data; + } + decode(types, data, loose) { + const coders = types.map((type) => this._getCoder(ParamType.from(type))); + const coder = new TupleCoder(coders, "_"); + return coder.decode(this._getReader(arrayify(data), loose)); + } +} +const defaultAbiCoder = new AbiCoder(); +function id(text) { + return keccak256(toUtf8Bytes(text)); +} +const logger = new Logger(version$2); +class LogDescription extends Description { +} +class TransactionDescription extends Description { +} +class ErrorDescription extends Description { +} +class Indexed extends Description { + static isIndexed(value) { + return !!(value && value._isIndexed); + } +} +const BuiltinErrors = { + "0x08c379a0": { signature: "Error(string)", name: "Error", inputs: ["string"], reason: true }, + "0x4e487b71": { signature: "Panic(uint256)", name: "Panic", inputs: ["uint256"] } +}; +function wrapAccessError(property, error) { + const wrap = new Error(`deferred error during ABI decoding triggered accessing ${property}`); + wrap.error = error; + return wrap; +} +class Interface { + constructor(fragments) { + let abi = []; + if (typeof fragments === "string") { + abi = JSON.parse(fragments); + } else { + abi = fragments; + } + defineReadOnly(this, "fragments", abi.map((fragment) => { + return Fragment.from(fragment); + }).filter((fragment) => fragment != null)); + defineReadOnly(this, "_abiCoder", getStatic(new.target, "getAbiCoder")()); + defineReadOnly(this, "functions", {}); + defineReadOnly(this, "errors", {}); + defineReadOnly(this, "events", {}); + defineReadOnly(this, "structs", {}); + this.fragments.forEach((fragment) => { + let bucket = null; + switch (fragment.type) { + case "constructor": + if (this.deploy) { + logger.warn("duplicate definition - constructor"); + return; + } + defineReadOnly(this, "deploy", fragment); + return; + case "function": + bucket = this.functions; + break; + case "event": + bucket = this.events; + break; + case "error": + bucket = this.errors; + break; + default: + return; + } + let signature = fragment.format(); + if (bucket[signature]) { + logger.warn("duplicate definition - " + signature); + return; + } + bucket[signature] = fragment; + }); + if (!this.deploy) { + defineReadOnly(this, "deploy", ConstructorFragment.from({ + payable: false, + type: "constructor" + })); + } + defineReadOnly(this, "_isInterface", true); + } + format(format) { + if (!format) { + format = FormatTypes.full; + } + if (format === FormatTypes.sighash) { + logger.throwArgumentError("interface does not support formatting sighash", "format", format); + } + const abi = this.fragments.map((fragment) => fragment.format(format)); + if (format === FormatTypes.json) { + return JSON.stringify(abi.map((j2) => JSON.parse(j2))); + } + return abi; + } + // Sub-classes can override these to handle other blockchains + static getAbiCoder() { + return defaultAbiCoder; + } + static getAddress(address) { + return getAddress(address); + } + static getSighash(fragment) { + return hexDataSlice(id(fragment.format()), 0, 4); + } + static getEventTopic(eventFragment) { + return id(eventFragment.format()); + } + // Find a function definition by any means necessary (unless it is ambiguous) + getFunction(nameOrSignatureOrSighash) { + if (isHexString(nameOrSignatureOrSighash)) { + for (const name in this.functions) { + if (nameOrSignatureOrSighash === this.getSighash(name)) { + return this.functions[name]; + } + } + logger.throwArgumentError("no matching function", "sighash", nameOrSignatureOrSighash); + } + if (nameOrSignatureOrSighash.indexOf("(") === -1) { + const name = nameOrSignatureOrSighash.trim(); + const matching = Object.keys(this.functions).filter((f2) => f2.split( + "(" + /* fix:) */ + )[0] === name); + if (matching.length === 0) { + logger.throwArgumentError("no matching function", "name", name); + } else if (matching.length > 1) { + logger.throwArgumentError("multiple matching functions", "name", name); + } + return this.functions[matching[0]]; + } + const result = this.functions[FunctionFragment.fromString(nameOrSignatureOrSighash).format()]; + if (!result) { + logger.throwArgumentError("no matching function", "signature", nameOrSignatureOrSighash); + } + return result; + } + // Find an event definition by any means necessary (unless it is ambiguous) + getEvent(nameOrSignatureOrTopic) { + if (isHexString(nameOrSignatureOrTopic)) { + const topichash = nameOrSignatureOrTopic.toLowerCase(); + for (const name in this.events) { + if (topichash === this.getEventTopic(name)) { + return this.events[name]; + } + } + logger.throwArgumentError("no matching event", "topichash", topichash); + } + if (nameOrSignatureOrTopic.indexOf("(") === -1) { + const name = nameOrSignatureOrTopic.trim(); + const matching = Object.keys(this.events).filter((f2) => f2.split( + "(" + /* fix:) */ + )[0] === name); + if (matching.length === 0) { + logger.throwArgumentError("no matching event", "name", name); + } else if (matching.length > 1) { + logger.throwArgumentError("multiple matching events", "name", name); + } + return this.events[matching[0]]; + } + const result = this.events[EventFragment.fromString(nameOrSignatureOrTopic).format()]; + if (!result) { + logger.throwArgumentError("no matching event", "signature", nameOrSignatureOrTopic); + } + return result; + } + // Find a function definition by any means necessary (unless it is ambiguous) + getError(nameOrSignatureOrSighash) { + if (isHexString(nameOrSignatureOrSighash)) { + const getSighash = getStatic(this.constructor, "getSighash"); + for (const name in this.errors) { + const error = this.errors[name]; + if (nameOrSignatureOrSighash === getSighash(error)) { + return this.errors[name]; + } + } + logger.throwArgumentError("no matching error", "sighash", nameOrSignatureOrSighash); + } + if (nameOrSignatureOrSighash.indexOf("(") === -1) { + const name = nameOrSignatureOrSighash.trim(); + const matching = Object.keys(this.errors).filter((f2) => f2.split( + "(" + /* fix:) */ + )[0] === name); + if (matching.length === 0) { + logger.throwArgumentError("no matching error", "name", name); + } else if (matching.length > 1) { + logger.throwArgumentError("multiple matching errors", "name", name); + } + return this.errors[matching[0]]; + } + const result = this.errors[FunctionFragment.fromString(nameOrSignatureOrSighash).format()]; + if (!result) { + logger.throwArgumentError("no matching error", "signature", nameOrSignatureOrSighash); + } + return result; + } + // Get the sighash (the bytes4 selector) used by Solidity to identify a function + getSighash(fragment) { + if (typeof fragment === "string") { + try { + fragment = this.getFunction(fragment); + } catch (error) { + try { + fragment = this.getError(fragment); + } catch (_2) { + throw error; + } + } + } + return getStatic(this.constructor, "getSighash")(fragment); + } + // Get the topic (the bytes32 hash) used by Solidity to identify an event + getEventTopic(eventFragment) { + if (typeof eventFragment === "string") { + eventFragment = this.getEvent(eventFragment); + } + return getStatic(this.constructor, "getEventTopic")(eventFragment); + } + _decodeParams(params, data) { + return this._abiCoder.decode(params, data); + } + _encodeParams(params, values) { + return this._abiCoder.encode(params, values); + } + encodeDeploy(values) { + return this._encodeParams(this.deploy.inputs, values || []); + } + decodeErrorResult(fragment, data) { + if (typeof fragment === "string") { + fragment = this.getError(fragment); + } + const bytes = arrayify(data); + if (hexlify(bytes.slice(0, 4)) !== this.getSighash(fragment)) { + logger.throwArgumentError(`data signature does not match error ${fragment.name}.`, "data", hexlify(bytes)); + } + return this._decodeParams(fragment.inputs, bytes.slice(4)); + } + encodeErrorResult(fragment, values) { + if (typeof fragment === "string") { + fragment = this.getError(fragment); + } + return hexlify(concat([ + this.getSighash(fragment), + this._encodeParams(fragment.inputs, values || []) + ])); + } + // Decode the data for a function call (e.g. tx.data) + decodeFunctionData(functionFragment, data) { + if (typeof functionFragment === "string") { + functionFragment = this.getFunction(functionFragment); + } + const bytes = arrayify(data); + if (hexlify(bytes.slice(0, 4)) !== this.getSighash(functionFragment)) { + logger.throwArgumentError(`data signature does not match function ${functionFragment.name}.`, "data", hexlify(bytes)); + } + return this._decodeParams(functionFragment.inputs, bytes.slice(4)); + } + // Encode the data for a function call (e.g. tx.data) + encodeFunctionData(functionFragment, values) { + if (typeof functionFragment === "string") { + functionFragment = this.getFunction(functionFragment); + } + return hexlify(concat([ + this.getSighash(functionFragment), + this._encodeParams(functionFragment.inputs, values || []) + ])); + } + // Decode the result from a function call (e.g. from eth_call) + decodeFunctionResult(functionFragment, data) { + if (typeof functionFragment === "string") { + functionFragment = this.getFunction(functionFragment); + } + let bytes = arrayify(data); + let reason = null; + let message = ""; + let errorArgs = null; + let errorName = null; + let errorSignature = null; + switch (bytes.length % this._abiCoder._getWordSize()) { + case 0: + try { + return this._abiCoder.decode(functionFragment.outputs, bytes); + } catch (error) { + } + break; + case 4: { + const selector = hexlify(bytes.slice(0, 4)); + const builtin = BuiltinErrors[selector]; + if (builtin) { + errorArgs = this._abiCoder.decode(builtin.inputs, bytes.slice(4)); + errorName = builtin.name; + errorSignature = builtin.signature; + if (builtin.reason) { + reason = errorArgs[0]; + } + if (errorName === "Error") { + message = `; VM Exception while processing transaction: reverted with reason string ${JSON.stringify(errorArgs[0])}`; + } else if (errorName === "Panic") { + message = `; VM Exception while processing transaction: reverted with panic code ${errorArgs[0]}`; + } + } else { + try { + const error = this.getError(selector); + errorArgs = this._abiCoder.decode(error.inputs, bytes.slice(4)); + errorName = error.name; + errorSignature = error.format(); + } catch (error) { + } + } + break; + } + } + return logger.throwError("call revert exception" + message, Logger.errors.CALL_EXCEPTION, { + method: functionFragment.format(), + data: hexlify(data), + errorArgs, + errorName, + errorSignature, + reason + }); + } + // Encode the result for a function call (e.g. for eth_call) + encodeFunctionResult(functionFragment, values) { + if (typeof functionFragment === "string") { + functionFragment = this.getFunction(functionFragment); + } + return hexlify(this._abiCoder.encode(functionFragment.outputs, values || [])); + } + // Create the filter for the event with search criteria (e.g. for eth_filterLog) + encodeFilterTopics(eventFragment, values) { + if (typeof eventFragment === "string") { + eventFragment = this.getEvent(eventFragment); + } + if (values.length > eventFragment.inputs.length) { + logger.throwError("too many arguments for " + eventFragment.format(), Logger.errors.UNEXPECTED_ARGUMENT, { + argument: "values", + value: values + }); + } + let topics = []; + if (!eventFragment.anonymous) { + topics.push(this.getEventTopic(eventFragment)); + } + const encodeTopic = (param, value) => { + if (param.type === "string") { + return id(value); + } else if (param.type === "bytes") { + return keccak256(hexlify(value)); + } + if (param.type === "bool" && typeof value === "boolean") { + value = value ? "0x01" : "0x00"; + } + if (param.type.match(/^u?int/)) { + value = BigNumber.from(value).toHexString(); + } + if (param.type === "address") { + this._abiCoder.encode(["address"], [value]); + } + return hexZeroPad(hexlify(value), 32); + }; + values.forEach((value, index) => { + let param = eventFragment.inputs[index]; + if (!param.indexed) { + if (value != null) { + logger.throwArgumentError("cannot filter non-indexed parameters; must be null", "contract." + param.name, value); + } + return; + } + if (value == null) { + topics.push(null); + } else if (param.baseType === "array" || param.baseType === "tuple") { + logger.throwArgumentError("filtering with tuples or arrays not supported", "contract." + param.name, value); + } else if (Array.isArray(value)) { + topics.push(value.map((value2) => encodeTopic(param, value2))); + } else { + topics.push(encodeTopic(param, value)); + } + }); + while (topics.length && topics[topics.length - 1] === null) { + topics.pop(); + } + return topics; + } + encodeEventLog(eventFragment, values) { + if (typeof eventFragment === "string") { + eventFragment = this.getEvent(eventFragment); + } + const topics = []; + const dataTypes = []; + const dataValues = []; + if (!eventFragment.anonymous) { + topics.push(this.getEventTopic(eventFragment)); + } + if (values.length !== eventFragment.inputs.length) { + logger.throwArgumentError("event arguments/values mismatch", "values", values); + } + eventFragment.inputs.forEach((param, index) => { + const value = values[index]; + if (param.indexed) { + if (param.type === "string") { + topics.push(id(value)); + } else if (param.type === "bytes") { + topics.push(keccak256(value)); + } else if (param.baseType === "tuple" || param.baseType === "array") { + throw new Error("not implemented"); + } else { + topics.push(this._abiCoder.encode([param.type], [value])); + } + } else { + dataTypes.push(param); + dataValues.push(value); + } + }); + return { + data: this._abiCoder.encode(dataTypes, dataValues), + topics + }; + } + // Decode a filter for the event and the search criteria + decodeEventLog(eventFragment, data, topics) { + if (typeof eventFragment === "string") { + eventFragment = this.getEvent(eventFragment); + } + if (topics != null && !eventFragment.anonymous) { + let topicHash = this.getEventTopic(eventFragment); + if (!isHexString(topics[0], 32) || topics[0].toLowerCase() !== topicHash) { + logger.throwError("fragment/topic mismatch", Logger.errors.INVALID_ARGUMENT, { argument: "topics[0]", expected: topicHash, value: topics[0] }); + } + topics = topics.slice(1); + } + let indexed = []; + let nonIndexed = []; + let dynamic = []; + eventFragment.inputs.forEach((param, index) => { + if (param.indexed) { + if (param.type === "string" || param.type === "bytes" || param.baseType === "tuple" || param.baseType === "array") { + indexed.push(ParamType.fromObject({ type: "bytes32", name: param.name })); + dynamic.push(true); + } else { + indexed.push(param); + dynamic.push(false); + } + } else { + nonIndexed.push(param); + dynamic.push(false); + } + }); + let resultIndexed = topics != null ? this._abiCoder.decode(indexed, concat(topics)) : null; + let resultNonIndexed = this._abiCoder.decode(nonIndexed, data, true); + let result = []; + let nonIndexedIndex = 0, indexedIndex = 0; + eventFragment.inputs.forEach((param, index) => { + if (param.indexed) { + if (resultIndexed == null) { + result[index] = new Indexed({ _isIndexed: true, hash: null }); + } else if (dynamic[index]) { + result[index] = new Indexed({ _isIndexed: true, hash: resultIndexed[indexedIndex++] }); + } else { + try { + result[index] = resultIndexed[indexedIndex++]; + } catch (error) { + result[index] = error; + } + } + } else { + try { + result[index] = resultNonIndexed[nonIndexedIndex++]; + } catch (error) { + result[index] = error; + } + } + if (param.name && result[param.name] == null) { + const value = result[index]; + if (value instanceof Error) { + Object.defineProperty(result, param.name, { + enumerable: true, + get: () => { + throw wrapAccessError(`property ${JSON.stringify(param.name)}`, value); + } + }); + } else { + result[param.name] = value; + } + } + }); + for (let i2 = 0; i2 < result.length; i2++) { + const value = result[i2]; + if (value instanceof Error) { + Object.defineProperty(result, i2, { + enumerable: true, + get: () => { + throw wrapAccessError(`index ${i2}`, value); + } + }); + } + } + return Object.freeze(result); + } + // Given a transaction, find the matching function fragment (if any) and + // determine all its properties and call parameters + parseTransaction(tx) { + let fragment = this.getFunction(tx.data.substring(0, 10).toLowerCase()); + if (!fragment) { + return null; + } + return new TransactionDescription({ + args: this._abiCoder.decode(fragment.inputs, "0x" + tx.data.substring(10)), + functionFragment: fragment, + name: fragment.name, + signature: fragment.format(), + sighash: this.getSighash(fragment), + value: BigNumber.from(tx.value || "0") + }); + } + // @TODO + //parseCallResult(data: BytesLike): ?? + // Given an event log, find the matching event fragment (if any) and + // determine all its properties and values + parseLog(log) { + let fragment = this.getEvent(log.topics[0]); + if (!fragment || fragment.anonymous) { + return null; + } + return new LogDescription({ + eventFragment: fragment, + name: fragment.name, + signature: fragment.format(), + topic: this.getEventTopic(fragment), + args: this.decodeEventLog(fragment, log.data, log.topics) + }); + } + parseError(data) { + const hexData = hexlify(data); + let fragment = this.getError(hexData.substring(0, 10).toLowerCase()); + if (!fragment) { + return null; + } + return new ErrorDescription({ + args: this._abiCoder.decode(fragment.inputs, "0x" + hexData.substring(10)), + errorFragment: fragment, + name: fragment.name, + signature: fragment.format(), + sighash: this.getSighash(fragment) + }); + } + /* + static from(value: Array | string | Interface) { + if (Interface.isInterface(value)) { + return value; + } + if (typeof(value) === "string") { + return new Interface(JSON.parse(value)); + } + return new Interface(value); + } + */ + static isInterface(value) { + return !!(value && value._isInterface); + } +} +function e$2(e2) { + if (e2 === void 0) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + return e2; +} +function t$2(e2, t3, n11, s2, r2, i2, o2) { + try { + var a2 = e2[i2](o2); + var c2 = a2.value; + } catch (e3) { + n11(e3); + return; + } + if (a2.done) { + t3(c2); + } else { + Promise.resolve(c2).then(s2, r2); + } +} +function n$2(e2) { + return function() { + var n11 = this, s2 = arguments; + return new Promise(function(r2, i2) { + var o2 = e2.apply(n11, s2); + function a2(e3) { + t$2(o2, r2, i2, a2, c2, "next", e3); + } + function c2(e3) { + t$2(o2, r2, i2, a2, c2, "throw", e3); + } + a2(void 0); + }); + }; +} +function s$2(e2, t3) { + if (!(e2 instanceof t3)) { + throw new TypeError("Cannot call a class as a function"); + } +} +function r$2(e2, t3) { + for (var n11 = 0; n11 < t3.length; n11++) { + var s2 = t3[n11]; + s2.enumerable = s2.enumerable || false; + s2.configurable = true; + if ("value" in s2) + s2.writable = true; + Object.defineProperty(e2, s2.key, s2); + } +} +function i$2(e2, t3, n11) { + if (t3) + r$2(e2.prototype, t3); + if (n11) + r$2(e2, n11); + return e2; +} +function o$2(e2) { + o$2 = Object.setPrototypeOf ? Object.getPrototypeOf : function e3(e3) { + return e3.__proto__ || Object.getPrototypeOf(e3); + }; + return o$2(e2); +} +function a$2(e2, t3) { + if (typeof t3 !== "function" && t3 !== null) { + throw new TypeError("Super expression must either be null or a function"); + } + e2.prototype = Object.create(t3 && t3.prototype, { constructor: { value: e2, writable: true, configurable: true } }); + if (t3) + h$1(e2, t3); +} +function c$2(e2, t3) { + if (t3 != null && typeof Symbol !== "undefined" && t3[Symbol.hasInstance]) { + return !!t3[Symbol.hasInstance](e2); + } else { + return e2 instanceof t3; + } +} +function u$2(t3, n11) { + if (n11 && (l$1(n11) === "object" || typeof n11 === "function")) { + return n11; + } + return e$2(t3); +} +function h$1(e2, t3) { + h$1 = Object.setPrototypeOf || function e3(e3, t4) { + e3.__proto__ = t4; + return e3; + }; + return h$1(e2, t3); +} +function l$1(e2) { + "@swc/helpers - typeof"; + return e2 && typeof Symbol !== "undefined" && e2.constructor === Symbol ? "symbol" : typeof e2; +} +function d() { + if (typeof Reflect === "undefined" || !Reflect.construct) + return false; + if (Reflect.construct.sham) + return false; + if (typeof Proxy === "function") + return true; + try { + Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() { + })); + return true; + } catch (e2) { + return false; + } +} +function f$1(e2) { + var t3 = d(); + return function n11() { + var n12 = o$2(e2), s2; + if (t3) { + var r2 = o$2(this).constructor; + s2 = Reflect.construct(n12, arguments, r2); + } else { + s2 = n12.apply(this, arguments); + } + return u$2(this, s2); + }; +} +function p$1(e2, t3) { + var n11, s2, r2, i2, o2 = { label: 0, sent: function() { + if (r2[0] & 1) + throw r2[1]; + return r2[1]; + }, trys: [], ops: [] }; + return i2 = { next: a2(0), "throw": a2(1), "return": a2(2) }, typeof Symbol === "function" && (i2[Symbol.iterator] = function() { + return this; + }), i2; + function a2(e3) { + return function(t4) { + return c2([e3, t4]); + }; + } + function c2(i3) { + if (n11) + throw new TypeError("Generator is already executing."); + while (o2) + try { + if (n11 = 1, s2 && (r2 = i3[0] & 2 ? s2["return"] : i3[0] ? s2["throw"] || ((r2 = s2["return"]) && r2.call(s2), 0) : s2.next) && !(r2 = r2.call(s2, i3[1])).done) + return r2; + if (s2 = 0, r2) + i3 = [i3[0] & 2, r2.value]; + switch (i3[0]) { + case 0: + case 1: + r2 = i3; + break; + case 4: + o2.label++; + return { value: i3[1], done: false }; + case 5: + o2.label++; + s2 = i3[1]; + i3 = [0]; + continue; + case 7: + i3 = o2.ops.pop(); + o2.trys.pop(); + continue; + default: + if (!(r2 = o2.trys, r2 = r2.length > 0 && r2[r2.length - 1]) && (i3[0] === 6 || i3[0] === 2)) { + o2 = 0; + continue; + } + if (i3[0] === 3 && (!r2 || i3[1] > r2[0] && i3[1] < r2[3])) { + o2.label = i3[1]; + break; + } + if (i3[0] === 6 && o2.label < r2[1]) { + o2.label = r2[1]; + r2 = i3; + break; + } + if (r2 && o2.label < r2[2]) { + o2.label = r2[2]; + o2.ops.push(i3); + break; + } + if (r2[2]) + o2.ops.pop(); + o2.trys.pop(); + continue; + } + i3 = t3.call(e2, o2); + } catch (e3) { + i3 = [6, e3]; + s2 = 0; + } finally { + n11 = r2 = 0; + } + if (i3[0] & 5) + throw i3[1]; + return { value: i3[0] ? i3[1] : void 0, done: true }; + } +} +var y$1 = Object.defineProperty; +var v$1 = function(e2, t3, n11) { + return t3 in e2 ? y$1(e2, t3, { enumerable: true, configurable: true, writable: true, value: n11 }) : e2[t3] = n11; +}; +var _ = function(e2, t3, n11) { + return v$1(e2, (typeof t3 === "undefined" ? "undefined" : l$1(t3)) != "symbol" ? t3 + "" : t3, n11), n11; +}; +var Q = "connect-session", U = "connect-domains", V = "wss://nbstream.binance.com/wallet-connector", F = ["https://rpc.ankr.com/bsc", "https://binance.nodereal.io", "https://bscrpc.com", "https://bsc-dataseed2.ninicoin.io"]; +var W = function(t3) { + a$2(r2, t3); + var n11 = f$1(r2); + function r2() { + s$2(this, r2); + var t4; + t4 = n11.call.apply(n11, [this].concat(Array.prototype.slice.call(arguments))); + _(e$2(t4), "pending", false); + _(e$2(t4), "callbacks", /* @__PURE__ */ new Map()); + _(e$2(t4), "clientMeta"); + _(e$2(t4), "relay"); + _(e$2(t4), "_key", null); + _(e$2(t4), "_clientId", ""); + _(e$2(t4), "_peerId", ""); + _(e$2(t4), "_peerMeta", null); + _(e$2(t4), "_handshakeId", 0); + _(e$2(t4), "_handshakeTopic", ""); + _(e$2(t4), "_connected", false); + _(e$2(t4), "_accounts", []); + _(e$2(t4), "_chainId", "0x0"); + return t4; + } + i$2(r2, [{ key: "key", get: function e2() { + return this._key ? eD(this._key, true) : ""; + }, set: function e2(e2) { + if (!e2) + return; + var t4 = ej(e2); + this._key = t4; + } }, { key: "clientId", get: function e2() { + var e3 = this._clientId; + return e3 || (e3 = this._clientId = q$1()), this._clientId; + }, set: function e2(e2) { + e2 && (this._clientId = e2); + } }, { key: "peerId", get: function e2() { + return this._peerId; + }, set: function e2(e2) { + e2 && (this._peerId = e2); + } }, { key: "peerMeta", get: function e2() { + return this._peerMeta; + }, set: function e2(e2) { + this._peerMeta = e2; + } }, { key: "handshakeTopic", get: function e2() { + return this._handshakeTopic; + }, set: function e2(e2) { + e2 && (this._handshakeTopic = e2); + } }, { key: "handshakeId", get: function e2() { + return this._handshakeId; + }, set: function e2(e2) { + e2 && (this._handshakeId = e2); + } }, { key: "uri", get: function e2() { + return "wc:".concat(this.handshakeTopic, "@1?bridge=").concat(this.relay, "&key=").concat(this.key, "&scene=bid"); + } }, { key: "chainId", get: function e2() { + return this._chainId; + }, set: function e2(e2) { + this._chainId = e2; + } }, { key: "accounts", get: function e2() { + return this._accounts; + }, set: function e2(e2) { + this._accounts = e2; + } }, { key: "connected", get: function e2() { + return this._connected; + }, set: function e2(e2) { + } }, { key: "session", get: function e2() { + return { connected: this.connected, accounts: this.accounts, chainId: this.chainId, relay: this.relay, key: this.key, clientId: this.clientId, clientMeta: this.clientMeta, peerId: this.peerId, peerMeta: this.peerMeta, handshakeId: this.handshakeId, handshakeTopic: this.handshakeTopic }; + }, set: function e2(e2) { + e2 && (this._connected = e2.connected, this.accounts = e2.accounts, this.chainId = e2.chainId, this.relay = e2.relay, this.key = e2.key, this.clientId = e2.clientId, this.clientMeta = e2.clientMeta, this.peerId = e2.peerId, this.peerMeta = e2.peerMeta, this.handshakeId = e2.handshakeId, this.handshakeTopic = e2.handshakeTopic); + } }]); + return r2; +}(rh), Y = function(e2) { + a$2(n11, e2); + var t3 = f$1(n11); + function n11() { + s$2(this, n11); + return t3.apply(this, arguments); + } + i$2(n11, [{ key: "getStorageSession", value: function e3() { + try { + return rl(Q); + } catch (e4) { + } + return null; + } }, { key: "setStorageSession", value: function e3() { + rd(Q, this.session); + } }, { key: "removeStorageSession", value: function e3() { + rp(Q); + } }, { key: "manageStorageSession", value: function e3() { + this._connected ? this.setStorageSession() : this.removeStorageSession(); + } }]); + return n11; +}(W); +function es() { + return er.apply(this, arguments); +} +function er() { + er = n$2(function() { + var e2, t3; + return p$1(this, function(n11) { + switch (n11.label) { + case 0: + return [4, Promise.any(F.map(function(e3) { + return et$1.request({ url: e3, method: "POST", data: { jsonrpc: "2.0", id: Date.now(), method: "eth_call", params: [{ to: "0x76054B318785b588A3164B2A6eA5476F7cBA51e0", data: "0x97b5f450" }, "latest"] } }); + }))]; + case 1: + e2 = n11.sent(), t3 = new Interface(["function apiDomains() view returns (string)"]); + return [2, decode(t3.decodeFunctionResult("apiDomains", e2.data.result)[0]).split(",")]; + } + }); + }); + return er.apply(this, arguments); +} +function ei(e2) { + return e2.filter(function(e3) { + return e3.ttl > 0; + }).sort(function(e3, t3) { + return e3.ttl - t3.ttl; + }).map(function(e3) { + return e3.url; + }); +} +function eo() { + return ea.apply(this, arguments); +} +function ea() { + ea = n$2(function() { + var e2, t3; + return p$1(this, function(n11) { + switch (n11.label) { + case 0: + return [4, es()]; + case 1: + e2 = n11.sent(); + return [4, Promise.all(e2.map(function(e3) { + var t4 = e3.split(".").slice(1).join("."); + return b$2("wss://nbstream.".concat(t4, "/wallet-connector")); + }))]; + case 2: + t3 = n11.sent(); + return [2, ei(t3)]; + } + }); + }); + return ea.apply(this, arguments); +} +var ec = Promise.resolve([]); +if (!eh$1()) { + var eu = rl(U); + ec = Promise.resolve(eu), (!eu || eu.length === 0) && (ec = eo().then(function(e2) { + return console.log("🚀 ~ file: relay.ts:63 ~ .then ~ domains:", e2), rd(U, e2), e2; + }).catch(function() { + return []; + })); +} +function eh() { + return el.apply(this, arguments); +} +function el() { + el = n$2(function() { + var e2; + return p$1(this, function(t3) { + switch (t3.label) { + case 0: + return [4, ec]; + case 1: + e2 = t3.sent(); + return [2, (e2.length === 0 && e2.push(V), e2)]; + } + }); + }); + return el.apply(this, arguments); +} +function ed(e2) { + var t3 = rl(U); + if (!t3) + return; + var n11 = t3.filter(function(t4) { + return t4 !== e2; + }); + rd(U, n11); +} +function ef() { + rp(U); +} +function e_(e2) { + return e2.code === -32050 || e2.code === -32e3 || e2.code === 1e3 ? new rA(rx.REJECT_ERR.code, rx.REJECT_ERR.message) : e2.code === -32603 ? new rA(rN.INTERNAL_ERR.code, rN.INTERNAL_ERR.message) : e2.code === -32600 || e2.code === -32602 ? new rA(rx.INVALID_PARAM.code, rx.INVALID_PARAM.message) : e2; +} +function em(e2) { + var t3 = e2.indexOf("?"); + return t3 > -1 ? e2.slice(0, t3) : e2; +} +var eI = function(t3) { + a$2(o2, t3); + var r2 = f$1(o2); + function o2() { + s$2(this, o2); + var t4; + t4 = r2.call(this); + _(e$2(t4), "transport"); + _(e$2(t4), "lng"); + t4.clientMeta = r_(); + var n11 = t4.getStorageSession(); + n11 && (t4.session = n11), t4.handshakeId && t4.subscribeToSessionResponse(t4.handshakeId), t4.initTransport(), t4.subscribeInternalEvent(); + return t4; + } + i$2(o2, [{ key: "request", value: function e2(e2) { + var t4 = this; + return n$2(function() { + return p$1(this, function(n11) { + if (!t4.connected) + throw new rA(rS.PROVIDER_NOT_READY.code, rS.PROVIDER_NOT_READY.message); + if (ef$1.indexOf(e2.method) < 0) + throw new rA(rx.METHOD_NOT_SUPPORT.code, rx.METHOD_NOT_SUPPORT.message); + switch (e2.method) { + case "eth_requestAccounts": + return [2, t4.accounts]; + case "eth_accounts": + return [2, t4.accounts]; + case "eth_chainId": + return [2, eM(t4.chainId)]; + case "eth_signTransaction": + case "eth_sendTransaction": + case "eth_sign": + case "personal_sign": + case "eth_signTypedData": + case "eth_signTypedData_v1": + case "eth_signTypedData_v2": + case "eth_signTypedData_v3": + case "eth_signTypedData_v4": + case "wallet_switchEthereumChain": + case "wallet_watchAsset": + return [2, new Promise(function(n12, s2) { + e2.id || (e2.id = W$2()), t4.callbacks.set("response-".concat(e2.id), function(e3, t5) { + e3 ? s2(e_(e3)) : t5 ? n12(t5.result) : s2(new rA(rx.MISSING_RESPONSE.code, rx.MISSING_RESPONSE.message)); + }), t4.sendRequest(e2), t4.events.emit("call_request_sent"); + })]; + } + return [2]; + }); + })(); + } }, { key: "killSession", value: function e2() { + if (!this.connected) + return; + var e3 = { approved: false, chainId: null, networkId: null, accounts: null }, t4 = { id: W$2(), method: "wc_sessionUpdate", params: [e3] }; + this.sendRequest(t4), this.handleSessionDisconnect(h$2.DisconnectAtClient); + } }, { key: "connect", value: function e2() { + var e3 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, t4 = e3.chainId, s2 = e3.lng, r3 = e3.showQrCodeModal; + var i2 = this; + return n$2(function() { + return p$1(this, function(e4) { + return [2, (i2.lng = s2, i2.connected ? { chainId: i2.chainId, accounts: i2.accounts } : new Promise(function(e5, n11) { + i2.on("modal_closed", function(e6) { + n11(e6); + }), i2.on("session_error", function(e6) { + n11(e6); + }), i2.on("connect", function(t5) { + e5(t5); + }), i2.createSession({ chainId: t4, showQrCodeModal: r3 }); + }))]; + }); + })(); + } }, { key: "createSession", value: function e2(e2) { + var t4 = e2.chainId, n11 = e2.showQrCodeModal; + try { + if (this.connected) + throw new rA(rS.CONNECTED.code, rS.CONNECTED.message); + if (this.pending || this._handshakeTopic) + throw new rA(rS.CONNECTING.code, rS.CONNECTING.message); + this.pending = true, this._key = rs(), this.handshakeId = W$2(), this.handshakeTopic = q$1(); + var s2 = { id: this.handshakeId, method: "wc_sessionRequest", params: [{ peerId: this.clientId, peerMeta: this.clientMeta, chainId: t4 ? Number(t4) : null }] }; + this.sendRequest(s2, this.handshakeTopic), this.subscribeToSessionResponse(this.handshakeId), this.events.emit("display_uri", { showQrCodeModal: n11 }); + } catch (e3) { + this.pending = false; + var r3 = "response-".concat(this.handshakeId); + this.callbacks.get(r3) && this.callbacks.delete(r3); + var i2 = e3.message, o3 = c$2(e3, rA) ? e3 : new rA(rN.INTERNAL_ERR.code, "".concat(rN.INTERNAL_ERR.message, ": ").concat(i2)); + throw this.handleRejectSessionConnection(o3), rm.error("[binance-w3w] create connection failed: ".concat(i2)), o3; + } + } }, { key: "initTransport", value: function e2() { + var e3 = this; + return n$2(function() { + var t4, n11, s2, r3; + return p$1(this, function(i2) { + switch (i2.label) { + case 0: + e3.transport = new v$2({ version: 1, subscriptions: [e3.clientId] }), e3.transport.on("message", function(t5) { + return e3.setIncomingMessages(t5); + }), e3.transport.on("open", function(t5) { + e3.events.emit("transport_open", t5); + }), e3.transport.on("close", function() { + e3.events.emit("transport_close"); + }), e3.transport.on("error", function(t5, n12) { + e3.events.emit("transport_error", t5, n12); + }); + i2.label = 1; + case 1: + i2.trys.push([1, 5, , 6]); + if (!e3.session.relay) + return [3, 2]; + e3.transport.open([e3.session.relay]); + return [3, 4]; + case 2: + return [4, eh()]; + case 3: + t4 = i2.sent(); + e3.transport.open(t4); + i2.label = 4; + case 4: + return [3, 6]; + case 5: + n11 = i2.sent(); + ef(); + s2 = n11.message, r3 = new rA(rN.INTERNAL_ERR.code, "".concat(rN.INTERNAL_ERR.message, ": ").concat(s2)); + throw e3.handleRejectSessionConnection(r3), r3; + case 6: + return [2]; + } + }); + })(); + } }, { key: "setIncomingMessages", value: function e2(e2) { + if (![this.clientId, this.handshakeTopic].includes(e2.topic)) + return; + var t4; + try { + t4 = JSON.parse(e2.payload); + } catch (e3) { + return; + } + var n11 = this.decrypt(t4); + if (!n11) + return; + if ("method" in n11 && n11.method) { + this.events.emit(n11.method, null, n11); + return; + } + var s2 = n11.id, r3 = "response-".concat(s2), i2 = this.callbacks.get(r3); + if (i2) { + if ("error" in n11 && n11.error) { + var o3 = new rA(n11.error.code, n11.error.message); + i2(o3, null); + } else + "result" in n11 && n11.result && i2(null, n11); + this.callbacks.delete(r3); + } else + rm.error("[binance-w3w] callback id: ".concat(s2, " not found")); + } }, { key: "encrypt", value: function e2(e2) { + var t4 = this._key; + return t4 ? rc(e2, t4) : null; + } }, { key: "decrypt", value: function e2(e2) { + var t4 = this._key; + return t4 ? rf(e2, t4) : null; + } }, { key: "sendRequest", value: function e2(e2, t4) { + var n11 = G$1(e2.method, e2.params, e2.id), s2 = this.encrypt(n11), r3 = t4 || this.peerId, i2 = JSON.stringify(s2); + this.transport.send(i2, r3, true); + } }, { key: "subscribeInternalEvent", value: function e2() { + var e3 = this; + this.on("display_uri", function(t4) { + var n11 = t4.showQrCodeModal; + n11 !== false && (eo$1.open({ cb: function() { + e3.events.emit("modal_closed", new rA(rS.CLOSE_MODAL.code, rS.CLOSE_MODAL.message)); + }, lng: e3.lng }), e3.transport.connected ? (e3.events.emit("uri_ready", e3.uri), e3.key && eo$1.ready(e3.uri)) : e3.transport.retryFailed && eo$1.fail()); + }), this.on("transport_open", function(t4) { + e3.relay = t4, e3.events.emit("uri_ready", e3.uri), e3.key && eo$1.ready(e3.uri); + }), this.on("transport_error", function(e4, t4) { + t4 ? ed(em(t4)) : (ef(), eo$1.fail()); + }), this.on("modal_closed", function() { + var t4 = "response-".concat(e3.handshakeId); + e3.callbacks.get(t4) && e3.callbacks.delete(t4), e3.clearConnectionStatus(); + }), this.on("connect", function() { + e3.pending = false, eo$1.close(); + }), this.on("call_request_sent", function() { + rj(); + }), this.on("wc_sessionUpdate", function(t4, n11) { + if (t4) { + e3.handleSessionResponse(); + return; + } + n11.params && Array.isArray(n11.params) ? e3.handleSessionResponse(n11.params[0]) : n11.error && e3.handleSessionResponse(); + }); + } }, { key: "subscribeToSessionResponse", value: function e2(e2) { + var t4 = this; + this.callbacks.set("response-".concat(e2), function(e3, n11) { + if (e3) { + t4.handleSessionResponse(); + return; + } + n11 && (n11.result ? t4.handleSessionResponse(n11.result) : n11.error && n11.error.message ? t4.handleSessionResponse() : t4.handleSessionResponse()); + }); + } }, { key: "handleSessionResponse", value: function e2(e2) { + e2 ? e2.approved ? (this._connected ? (e2.chainId && this.setChainId(e2.chainId), e2.accounts && this.setAddress(e2.accounts)) : (this._connected = true, e2.chainId && this.setChainId(e2.chainId), e2.accounts && this.setAddress(e2.accounts), e2.peerId && !this.peerId && (this.peerId = e2.peerId), e2.peerMeta && !this.peerMeta && (this.peerMeta = e2.peerMeta), this.events.emit("connect", { chainId: this.chainId, accounts: this.accounts })), this.manageStorageSession()) : this.connected ? this.handleSessionDisconnect(h$2.DisconnectAtWallet) : this.handleRejectSessionConnection(new rA(rS.REJECT_SESSION.code, rS.REJECT_SESSION.message)) : this.handleRejectSessionConnection(new rA(rS.REJECT_SESSION.code, rS.REJECT_SESSION.message)); + } }, { key: "handleRejectSessionConnection", value: function e2(e2) { + eo$1.close(), this.clearConnectionStatus(), this.events.emit("session_error", e2); + } }, { key: "handleSessionDisconnect", value: function e2(e2) { + this._connected || eo$1.close(), this.events.emit("disconnect", e2), this.clearConnectionStatus(); + } }, { key: "clearConnectionStatus", value: function e2() { + this._connected && (this._connected = false), this._handshakeId && (this._handshakeId = 0), this._handshakeTopic && (this._handshakeTopic = ""), this._peerId && (this._peerId = ""), this._clientId && (this._clientId = ""), this.pending && (this.pending = false), this.callbacks.clear(), this._peerMeta = null, this._accounts = [], this._chainId = "0x0", this.offConnectEvents(), this.removeStorageSession(), this.transport.close(); + } }, { key: "offConnectEvents", value: function e2() { + this.removeListener("connect"); + } }, { key: "setChainId", value: function e2(e2) { + var t4 = eM(e2); + if (t4 === "0x0") { + this.chainId = t4; + return; + } + l$1(this.chainId) < "u" && this.chainId !== t4 && this.events.emit("chainChanged", t4), this.chainId = t4; + } }, { key: "setAddress", value: function e2() { + var e3 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : []; + var t4 = e3.filter(function(e4) { + return typeof e4 == "string"; + }).map(function(e4) { + return e4.toLowerCase(); + }).filter(Boolean); + JSON.stringify(this.accounts) !== JSON.stringify(t4) && this.events.emit("accountsChanged", t4), this.accounts = t4; + } }]); + return o2; +}(Y); +function n$1(n11) { + if (n11 === void 0) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + return n11; +} +function e$1(n11, e2, t3, o2, r2, c2, i2) { + try { + var u2 = n11[c2](i2); + var s2 = u2.value; + } catch (n12) { + t3(n12); + return; + } + if (u2.done) { + e2(s2); + } else { + Promise.resolve(s2).then(o2, r2); + } +} +function t$1(n11) { + return function() { + var t3 = this, o2 = arguments; + return new Promise(function(r2, c2) { + var i2 = n11.apply(t3, o2); + function u2(n12) { + e$1(i2, r2, c2, u2, s2, "next", n12); + } + function s2(n12) { + e$1(i2, r2, c2, u2, s2, "throw", n12); + } + u2(void 0); + }); + }; +} +function o$1(n11, e2) { + if (!(n11 instanceof e2)) { + throw new TypeError("Cannot call a class as a function"); + } +} +function r$1(n11, e2) { + for (var t3 = 0; t3 < e2.length; t3++) { + var o2 = e2[t3]; + o2.enumerable = o2.enumerable || false; + o2.configurable = true; + if ("value" in o2) + o2.writable = true; + Object.defineProperty(n11, o2.key, o2); + } +} +function c$1(n11, e2, t3) { + if (e2) + r$1(n11.prototype, e2); + if (t3) + r$1(n11, t3); + return n11; +} +function i$1(n11) { + i$1 = Object.setPrototypeOf ? Object.getPrototypeOf : function n12(n12) { + return n12.__proto__ || Object.getPrototypeOf(n12); + }; + return i$1(n11); +} +function u$1(n11, e2) { + if (typeof e2 !== "function" && e2 !== null) { + throw new TypeError("Super expression must either be null or a function"); + } + n11.prototype = Object.create(e2 && e2.prototype, { constructor: { value: n11, writable: true, configurable: true } }); + if (e2) + a$1(n11, e2); +} +function s$1(e2, t3) { + if (t3 && (f(t3) === "object" || typeof t3 === "function")) { + return t3; + } + return n$1(e2); +} +function a$1(n11, e2) { + a$1 = Object.setPrototypeOf || function n12(n12, e3) { + n12.__proto__ = e3; + return n12; + }; + return a$1(n11, e2); +} +function f(n11) { + "@swc/helpers - typeof"; + return n11 && typeof Symbol !== "undefined" && n11.constructor === Symbol ? "symbol" : typeof n11; +} +function l() { + if (typeof Reflect === "undefined" || !Reflect.construct) + return false; + if (Reflect.construct.sham) + return false; + if (typeof Proxy === "function") + return true; + try { + Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() { + })); + return true; + } catch (n11) { + return false; + } +} +function h(n11) { + var e2 = l(); + return function t3() { + var t4 = i$1(n11), o2; + if (e2) { + var r2 = i$1(this).constructor; + o2 = Reflect.construct(t4, arguments, r2); + } else { + o2 = t4.apply(this, arguments); + } + return s$1(this, o2); + }; +} +function p(n11, e2) { + var t3, o2, r2, c2, i2 = { label: 0, sent: function() { + if (r2[0] & 1) + throw r2[1]; + return r2[1]; + }, trys: [], ops: [] }; + return c2 = { next: u2(0), "throw": u2(1), "return": u2(2) }, typeof Symbol === "function" && (c2[Symbol.iterator] = function() { + return this; + }), c2; + function u2(n12) { + return function(e3) { + return s2([n12, e3]); + }; + } + function s2(c3) { + if (t3) + throw new TypeError("Generator is already executing."); + while (i2) + try { + if (t3 = 1, o2 && (r2 = c3[0] & 2 ? o2["return"] : c3[0] ? o2["throw"] || ((r2 = o2["return"]) && r2.call(o2), 0) : o2.next) && !(r2 = r2.call(o2, c3[1])).done) + return r2; + if (o2 = 0, r2) + c3 = [c3[0] & 2, r2.value]; + switch (c3[0]) { + case 0: + case 1: + r2 = c3; + break; + case 4: + i2.label++; + return { value: c3[1], done: false }; + case 5: + i2.label++; + o2 = c3[1]; + c3 = [0]; + continue; + case 7: + c3 = i2.ops.pop(); + i2.trys.pop(); + continue; + default: + if (!(r2 = i2.trys, r2 = r2.length > 0 && r2[r2.length - 1]) && (c3[0] === 6 || c3[0] === 2)) { + i2 = 0; + continue; + } + if (c3[0] === 3 && (!r2 || c3[1] > r2[0] && c3[1] < r2[3])) { + i2.label = c3[1]; + break; + } + if (c3[0] === 6 && i2.label < r2[1]) { + i2.label = r2[1]; + r2 = c3; + break; + } + if (r2 && i2.label < r2[2]) { + i2.label = r2[2]; + i2.ops.push(c3); + break; + } + if (r2[2]) + i2.ops.pop(); + i2.trys.pop(); + continue; + } + c3 = e2.call(n11, i2); + } catch (n12) { + c3 = [6, n12]; + o2 = 0; + } finally { + t3 = r2 = 0; + } + if (c3[0] & 5) + throw c3[1]; + return { value: c3[0] ? c3[1] : void 0, done: true }; + } +} +var y = Object.defineProperty; +var b$1 = function(n11, e2, t3) { + return e2 in n11 ? y(n11, e2, { enumerable: true, configurable: true, writable: true, value: t3 }) : n11[e2] = t3; +}; +var v = function(n11, e2, t3) { + return b$1(n11, (typeof e2 === "undefined" ? "undefined" : f(e2)) != "symbol" ? e2 + "" : e2, t3), t3; +}; +var g = function(e2) { + u$1(i2, e2); + var r2 = h(i2); + function i2() { + o$1(this, i2); + var e3; + e3 = r2.call(this); + v(n$1(e3), "accounts", []); + v(n$1(e3), "coreConnection"); + e3.register(); + return e3; + } + c$1(i2, [{ key: "chainId", get: function n11() { + return this.coreConnection ? this.coreConnection.chainId : "0x0"; + } }, { key: "connected", get: function n11() { + return this.coreConnection ? this.coreConnection.connected : false; + } }, { key: "connecting", get: function n11() { + return this.coreConnection ? this.coreConnection.pending : false; + } }, { key: "open", value: function n11(n11) { + var e3 = n11.requestChainId, o2 = n11.lng, r3 = n11.showQrCodeModal; + var c2 = this; + return t$1(function() { + var n12, t3; + return p(this, function(i3) { + switch (i3.label) { + case 0: + if (c2.register(), c2.coreConnection.connected) + return [2]; + return [4, c2.coreConnection.connect({ chainId: e3, lng: o2, showQrCodeModal: r3 })]; + case 1: + n12 = i3.sent(), t3 = n12.accounts; + c2.accounts = t3; + return [2]; + } + }); + })(); + } }, { key: "request", value: function n11(n11) { + var e3 = this; + return t$1(function() { + var t3; + return p(this, function(o2) { + switch (o2.label) { + case 0: + t3 = e3.connected; + if (t3) + return [3, 2]; + return [4, e3.open({})]; + case 1: + t3 = o2.sent(); + o2.label = 2; + case 2: + return [2, e3.coreConnection.request(n11)]; + } + }); + })(); + } }, { key: "disconnect", value: function n11() { + this.connected && (this.coreConnection.killSession(), this.onClose(h$2.DisconnectAtClient)); + } }, { key: "register", value: function n11() { + if (this.coreConnection) + return this.coreConnection; + this.coreConnection = new eI(), this.accounts = this.coreConnection.accounts, this.subscribeEvents(); + } }, { key: "subscribeEvents", value: function n11() { + var n12 = this; + this.coreConnection.on("chainChanged", function(e3) { + n12.events.emit("chainChanged", e3); + }), this.coreConnection.on("accountsChanged", function(e3) { + n12.accounts = e3, n12.events.emit("accountsChanged", e3); + }), this.coreConnection.on("uri_ready", function(e3) { + n12.events.emit("uri_ready", e3); + }), this.coreConnection.on("disconnect", function(e3) { + n12.onClose(e3); + }); + } }, { key: "onClose", value: function n11(n11) { + this.coreConnection = null, this.events.emit("disconnect", n11); + } }]); + return i2; +}(rh); +function e(e2, n11, t3, i2, r2, o2, s2) { + try { + var u2 = e2[o2](s2); + var c2 = u2.value; + } catch (e3) { + t3(e3); + return; + } + if (u2.done) { + n11(c2); + } else { + Promise.resolve(c2).then(i2, r2); + } +} +function n10(n11) { + return function() { + var t3 = this, i2 = arguments; + return new Promise(function(r2, o2) { + var s2 = n11.apply(t3, i2); + function u2(n12) { + e(s2, r2, o2, u2, c2, "next", n12); + } + function c2(n12) { + e(s2, r2, o2, u2, c2, "throw", n12); + } + u2(void 0); + }); + }; +} +function t2(e2, n11) { + if (!(e2 instanceof n11)) { + throw new TypeError("Cannot call a class as a function"); + } +} +function i(e2, n11) { + for (var t3 = 0; t3 < n11.length; t3++) { + var i2 = n11[t3]; + i2.enumerable = i2.enumerable || false; + i2.configurable = true; + if ("value" in i2) + i2.writable = true; + Object.defineProperty(e2, i2.key, i2); + } +} +function r(e2, n11, t3) { + if (n11) + i(e2.prototype, n11); + if (t3) + i(e2, t3); + return e2; +} +function o(e2) { + "@swc/helpers - typeof"; + return e2 && typeof Symbol !== "undefined" && e2.constructor === Symbol ? "symbol" : typeof e2; +} +function s(e2, n11) { + var t3, i2, r2, o2, s2 = { label: 0, sent: function() { + if (r2[0] & 1) + throw r2[1]; + return r2[1]; + }, trys: [], ops: [] }; + return o2 = { next: u2(0), "throw": u2(1), "return": u2(2) }, typeof Symbol === "function" && (o2[Symbol.iterator] = function() { + return this; + }), o2; + function u2(e3) { + return function(n12) { + return c2([e3, n12]); + }; + } + function c2(o3) { + if (t3) + throw new TypeError("Generator is already executing."); + while (s2) + try { + if (t3 = 1, i2 && (r2 = o3[0] & 2 ? i2["return"] : o3[0] ? i2["throw"] || ((r2 = i2["return"]) && r2.call(i2), 0) : i2.next) && !(r2 = r2.call(i2, o3[1])).done) + return r2; + if (i2 = 0, r2) + o3 = [o3[0] & 2, r2.value]; + switch (o3[0]) { + case 0: + case 1: + r2 = o3; + break; + case 4: + s2.label++; + return { value: o3[1], done: false }; + case 5: + s2.label++; + i2 = o3[1]; + o3 = [0]; + continue; + case 7: + o3 = s2.ops.pop(); + s2.trys.pop(); + continue; + default: + if (!(r2 = s2.trys, r2 = r2.length > 0 && r2[r2.length - 1]) && (o3[0] === 6 || o3[0] === 2)) { + s2 = 0; + continue; + } + if (o3[0] === 3 && (!r2 || o3[1] > r2[0] && o3[1] < r2[3])) { + s2.label = o3[1]; + break; + } + if (o3[0] === 6 && s2.label < r2[1]) { + s2.label = r2[1]; + r2 = o3; + break; + } + if (r2 && s2.label < r2[2]) { + s2.label = r2[2]; + s2.ops.push(o3); + break; + } + if (r2[2]) + s2.ops.pop(); + s2.trys.pop(); + continue; + } + o3 = n11.call(e2, s2); + } catch (e3) { + o3 = [6, e3]; + i2 = 0; + } finally { + t3 = r2 = 0; + } + if (o3[0] & 5) + throw o3[1]; + return { value: o3[0] ? o3[1] : void 0, done: true }; + } +} +var u = Object.defineProperty; +var c = function(e2, n11, t3) { + return n11 in e2 ? u(e2, n11, { enumerable: true, configurable: true, writable: true, value: t3 }) : e2[n11] = t3; +}; +var a = function(e2, n11, t3) { + return c(e2, (typeof n11 === "undefined" ? "undefined" : o(n11)) != "symbol" ? n11 + "" : n11, t3), t3; +}; +var b = function() { + function e2(n11) { + t2(this, e2); + a(this, "events", new O()); + a(this, "signClient"); + a(this, "rpc"); + a(this, "httpClient"); + a(this, "optsChainId"); + a(this, "lng"); + a(this, "showQrCodeModal"); + this.rpc = { infuraId: n11 === null || n11 === void 0 ? void 0 : n11.infuraId, custom: n11 === null || n11 === void 0 ? void 0 : n11.rpc }, this.lng = (n11 === null || n11 === void 0 ? void 0 : n11.lng) || "en", this.showQrCodeModal = n11 === null || n11 === void 0 ? void 0 : n11.showQrCodeModal, this.signClient = new g(), this.optsChainId = Number(this.signClient.coreConnection.chainId) || (n11 === null || n11 === void 0 ? void 0 : n11.chainId) || 56, this.registerEventListeners(), this.httpClient = this.setHttpProvider(this.optsChainId); + } + r(e2, [{ key: "connected", get: function e3() { + return this.signClient.connected; + } }, { key: "connector", get: function e3() { + return this.signClient; + } }, { key: "accounts", get: function e3() { + return this.signClient.accounts; + } }, { key: "chainId", get: function e3() { + return rm.debug("provider get chainId", this.signClient.chainId), this.signClient.chainId; + } }, { key: "rpcUrl", get: function e3() { + return this.httpClient.url || ""; + } }, { key: "request", value: function e3(e3) { + var t3 = this; + return n10(function() { + var n11, i2, r2; + return s(this, function(s2) { + switch (s2.label) { + case 0: + n11 = (rm.debug("ethereum-provider request", e3), e3.method); + switch (n11) { + case "eth_requestAccounts": + return [3, 1]; + case "eth_chainId": + return [3, 3]; + case "eth_accounts": + return [3, 4]; + case "wallet_switchEthereumChain": + return [3, 5]; + } + return [3, 6]; + case 1: + return [4, t3.connect()]; + case 2: + return [2, (s2.sent(), t3.accounts)]; + case 3: + return [2, t3.chainId]; + case 4: + return [2, t3.accounts]; + case 5: + return [2, t3.switchChain(e3)]; + case 6: + return [3, 7]; + case 7: + i2 = G$1(e3.method, e3.params || []); + if (ef$1.includes(e3.method)) + return [2, t3.signClient.request(i2)]; + if (o(t3.httpClient) > "u") + throw new Error("Cannot request JSON-RPC method (".concat(e3.method, ") without provided rpc url")); + return [4, t3.httpClient.request(i2)]; + case 8: + r2 = s2.sent(); + if (ee$1(r2)) + return [2, r2.result]; + throw new Error(r2.error.message); + } + }); + })(); + } }, { key: "signMessage", value: function e3(e3) { + var t3 = this; + return n10(function() { + var n11; + return s(this, function(i2) { + switch (i2.label) { + case 0: + rm.debug("signMessage", e3); + n11 = t3.accounts.length; + if (n11) + return [3, 2]; + return [4, t3.enable()]; + case 1: + n11 = i2.sent(); + i2.label = 2; + case 2: + return [4, t3.request({ method: "personal_sign", params: [eC(e3), t3.accounts[0]] })]; + case 3: + return [2, i2.sent()]; + } + }); + })(); + } }, { key: "sendAsync", value: function e3(e3, n11) { + this.request(e3).then(function(e4) { + return n11(null, e4); + }).catch(function(e4) { + return n11(e4, void 0); + }); + } }, { key: "setLng", value: function e3(e3) { + this.lng = e3; + } }, { key: "enable", value: function e3(e3) { + var t3 = this; + return n10(function() { + return s(this, function(n11) { + switch (n11.label) { + case 0: + return [4, t3.connect(e3)]; + case 1: + return [2, (n11.sent(), t3.accounts)]; + } + }); + })(); + } }, { key: "switchChain", value: function e3(e3) { + var t3 = this; + return n10(function() { + var n11; + return s(this, function(i2) { + switch (i2.label) { + case 0: + n11 = G$1(e3.method, e3.params || []); + return [4, Promise.race([t3.signClient.request(n11), new Promise(function(n12) { + return t3.on("chainChanged", function(t4) { + t4 === e3.params[0].chainId && n12(t4); + }); + })])]; + case 1: + return [2, i2.sent()]; + } + }); + })(); + } }, { key: "connect", value: function e3(e3) { + var t3 = this; + return n10(function() { + var n11; + return s(this, function(r2) { + switch (r2.label) { + case 0: + if (!t3.connected) + return [3, 1]; + rm.info("already connected"); + return [3, 3]; + case 1: + return [4, t3.signClient.open({ requestChainId: (n11 = e3 === null || e3 === void 0 ? void 0 : e3.toString()) !== null && n11 !== void 0 ? n11 : t3.optsChainId.toString(), lng: t3.lng, showQrCodeModal: t3.showQrCodeModal })]; + case 2: + r2.sent(); + r2.label = 3; + case 3: + return [2]; + } + }); + })(); + } }, { key: "disconnect", value: function e3() { + this.connected && this.signClient.disconnect(); + } }, { key: "on", value: function e3(e3, n11) { + this.events.on(e3, n11); + } }, { key: "once", value: function e3(e3, n11) { + this.events.once(e3, n11); + } }, { key: "removeListener", value: function e3(e3, n11) { + this.events.removeListener(e3, n11); + } }, { key: "off", value: function e3(e3, n11) { + this.events.off(e3, n11); + } }, { key: "isWalletConnect", get: function e3() { + return true; + } }, { key: "registerEventListeners", value: function e3() { + var e4 = this; + this.signClient.on("accountsChanged", function(n11) { + e4.events.emit("accountsChanged", n11); + }), this.signClient.on("chainChanged", function(n11) { + e4.httpClient = e4.setHttpProvider(ey(n11)), e4.events.emit("chainChanged", n11); + }), this.signClient.on("disconnect", function() { + e4.events.emit("disconnect"); + }), this.signClient.on("uri_ready", function(n11) { + e4.events.emit("uri_ready", n11); + }); + } }, { key: "setHttpProvider", value: function e3(e3) { + var n11 = ev(e3, this.rpc); + if (!((typeof n11 === "undefined" ? "undefined" : o(n11)) > "u")) + return new E(n11); + } }]); + return e2; +}(), k = function(e2) { + if (rD()) { + var n11 = (typeof window === "undefined" ? "undefined" : o(window)) < "u" ? window.ethereum : void 0; + if (n11) + return n11.setLng = function() { + }, n11.disconnect = function() { + }, n11; + } + return new b(e2); +}, I = b; +export { + I as default, + k as getProvider +}; diff --git a/assets/index-65eb4c16.js b/assets/index-c4fcfadf.js similarity index 99% rename from assets/index-65eb4c16.js rename to assets/index-c4fcfadf.js index 96d57af..c7041e0 100644 --- a/assets/index-65eb4c16.js +++ b/assets/index-c4fcfadf.js @@ -1,5 +1,5 @@ -import { T as ThemeCtrl, M as ModalCtrl, R as RouterCtrl, E as ExplorerCtrl, C as CoreUtil, a as ToastCtrl, b as EventsCtrl, O as OptionsCtrl, c as ConfigCtrl } from "./index-51f3a68c.js"; -import { j as dijkstraExports } from "./index-945462c7.js"; +import { T as ThemeCtrl, M as ModalCtrl, R as RouterCtrl, E as ExplorerCtrl, C as CoreUtil, a as ToastCtrl, b as EventsCtrl, O as OptionsCtrl, c as ConfigCtrl } from "./index-c58b4767.js"; +import { a4 as dijkstraExports } from "./index-f38a281b.js"; /** * @license * Copyright 2019 Google LLC diff --git a/assets/index-51f3a68c.js b/assets/index-c58b4767.js similarity index 96% rename from assets/index-51f3a68c.js rename to assets/index-c58b4767.js index e2bfa6f..c20d8ed 100644 --- a/assets/index-51f3a68c.js +++ b/assets/index-c58b4767.js @@ -1,4 +1,4 @@ -import { _ as __vitePreload } from "./index-945462c7.js"; +import { S as __vitePreload } from "./index-f38a281b.js"; const t = Symbol(); const s = Object.getPrototypeOf, c = /* @__PURE__ */ new WeakMap(), l = (e) => e && (c.has(e) ? c.get(e) : s(e) === Object.prototype || s(e) === Array.prototype), y = (e) => l(e) && e[t] || null, h = (e, t2 = true) => { c.set(e, t2); @@ -89,7 +89,7 @@ const buildProxyFunction = (objectIs = Object.is, newProxy = (target, handler) = }; const propProxyStates = /* @__PURE__ */ new Map(); const addPropListener = (prop, propProxyState) => { - if (({ "BASE_URL": "./", "MODE": "production", "DEV": false, "PROD": true, "SSR": false } ? "production" : void 0) !== "production" && propProxyStates.has(prop)) { + if (({ "BASE_URL": "/", "MODE": "production", "DEV": false, "PROD": true, "SSR": false } ? "production" : void 0) !== "production" && propProxyStates.has(prop)) { throw new Error("prop listener already exists"); } if (listeners.size) { @@ -111,7 +111,7 @@ const buildProxyFunction = (objectIs = Object.is, newProxy = (target, handler) = listeners.add(listener); if (listeners.size === 1) { propProxyStates.forEach(([propProxyState, prevRemove], prop) => { - if (({ "BASE_URL": "./", "MODE": "production", "DEV": false, "PROD": true, "SSR": false } ? "production" : void 0) !== "production" && prevRemove) { + if (({ "BASE_URL": "/", "MODE": "production", "DEV": false, "PROD": true, "SSR": false } ? "production" : void 0) !== "production" && prevRemove) { throw new Error("remove already exists"); } const remove = propProxyState[3](createPropListener(prop)); @@ -221,7 +221,7 @@ function proxy(initialObject = {}) { } function subscribe(proxyObject, callback, notifyInSync) { const proxyState = proxyStateMap.get(proxyObject); - if (({ "BASE_URL": "./", "MODE": "production", "DEV": false, "PROD": true, "SSR": false } ? "production" : void 0) !== "production" && !proxyState) { + if (({ "BASE_URL": "/", "MODE": "production", "DEV": false, "PROD": true, "SSR": false } ? "production" : void 0) !== "production" && !proxyState) { console.warn("Please use proxy object"); } let promise; @@ -252,7 +252,7 @@ function subscribe(proxyObject, callback, notifyInSync) { } function snapshot(proxyObject, handlePromise) { const proxyState = proxyStateMap.get(proxyObject); - if (({ "BASE_URL": "./", "MODE": "production", "DEV": false, "PROD": true, "SSR": false } ? "production" : void 0) !== "production" && !proxyState) { + if (({ "BASE_URL": "/", "MODE": "production", "DEV": false, "PROD": true, "SSR": false } ? "production" : void 0) !== "production" && !proxyState) { console.warn("Please use proxy object"); } const [target, ensureVersion, createSnapshot] = proxyState; @@ -791,7 +791,7 @@ class WalletConnectModal { } async initUi() { if (typeof window !== "undefined") { - await __vitePreload(() => import("./index-65eb4c16.js"), true ? ["./index-65eb4c16.js","./index-945462c7.js","./index-01b56244.css"] : void 0, import.meta.url); + await __vitePreload(() => import("./index-c4fcfadf.js"), true ? ["assets/index-c4fcfadf.js","assets/index-f38a281b.js","assets/index-01b56244.css"] : void 0); const modal = document.createElement("wcm-modal"); document.body.insertAdjacentElement("beforeend", modal); OptionsCtrl.setIsUiLoaded(true); diff --git a/assets/index-c7451d23.js b/assets/index-e7f7ebea.js similarity index 99% rename from assets/index-c7451d23.js rename to assets/index-e7f7ebea.js index 71f4a9b..c12686c 100644 --- a/assets/index-c7451d23.js +++ b/assets/index-e7f7ebea.js @@ -1,7 +1,7 @@ -import { c as commonjsGlobal, e as bnExports, f as safeBufferExports, b as getAugmentedNamespace, h as buffer, r as require$$0$2, i as eventemitter3Exports, g as getDefaultExportFromCjs } from "./index-945462c7.js"; -import { i as inherits_browserExports, e as eventsExports } from "./events-b5445255.js"; +import { m as commonjsGlobal, X as bnExports, Y as safeBufferExports, Z as inherits_browserExports, T as getAugmentedNamespace, $ as buffer, a0 as require$$0$2, a1 as eventemitter3Exports, k as getDefaultExportFromCjs } from "./index-f38a281b.js"; import { p as preact_module, a as clsx_m, b as hooks_module } from "./hooks.module-1f3364a3.js"; -import { b as browserExports } from "./browser-480bf3e4.js"; +import { e as eventsExports } from "./events-ac009f6f.js"; +import { b as browserExports } from "./browser-8302b9c5.js"; function _mergeNamespaces(n, m) { for (var i = 0; i < m.length; i++) { const e = m[i]; diff --git a/assets/index-945462c7.js b/assets/index-f38a281b.js similarity index 87% rename from assets/index-945462c7.js rename to assets/index-f38a281b.js index 62f7e90..a76e83d 100644 --- a/assets/index-945462c7.js +++ b/assets/index-f38a281b.js @@ -35,6 +35,25 @@ var __privateMethod = (obj, member, method) => { return method; }; var _focused, _cleanup, _setup, _a2, _online, _cleanup2, _setup2, _b, _gcTimeout, _c, _initialState, _revertState, _cache, _retryer, _defaultOptions, _abortSignalConsumed, _dispatch, dispatch_fn, _d, _queries, _e, _observers, _mutationCache, _retryer2, _dispatch2, dispatch_fn2, _f, _mutations, _mutationId, _g, _queryCache, _mutationCache2, _defaultOptions2, _queryDefaults, _mutationDefaults, _mountCount, _unsubscribeFocus, _unsubscribeOnline, _h, _client, _currentResult, _currentMutation, _mutateOptions, _updateResult, updateResult_fn, _notify, notify_fn, _i, _names, _data, _dataLength, _writeData, writeData_fn, _data2, _offset, _bytesRead, _parent, _maxInflation, _incrementBytesRead, incrementBytesRead_fn, _peekBytes, peekBytes_fn, _r, _s, _v, _networkV, _privateKey, _options, _type, _to, _data3, _nonce, _gasLimit, _gasPrice, _maxPriorityFeePerGas, _maxFeePerGas, _value, _chainId, _sig, _accessList, _maxFeePerBlobGas, _blobVersionedHashes, _kzg, _blobs, _getSerialized, getSerialized_fn, _j, _types, _fullTypes, _encoderCache, _getEncoder, getEncoder_fn, _k, _offset2, _tokens, _subTokenString, subTokenString_fn, _l, _walkAsync, walkAsync_fn, _m, _getCoder, getCoder_fn, _throwUnsupported, throwUnsupported_fn, _signingKey, _data4, _checksum, _words, _loadWords, loadWords_fn, _account, account_fn, _fromSeed, fromSeed_fn, _offset3, _tokens2, _subTokenString2, subTokenString_fn2, _walkAsync2, walkAsync_fn2, _errors, _events, _functions, _abiCoder, _getFunction, getFunction_fn, _getEvent, getEvent_fn, _types2, _fullTypes2, _encoderCache2, _getEncoder2, getEncoder_fn2; +function _mergeNamespaces(n2, m2) { + for (var i = 0; i < m2.length; i++) { + const e18 = m2[i]; + if (typeof e18 !== "string" && !Array.isArray(e18)) { + for (const k2 in e18) { + if (k2 !== "default" && !(k2 in n2)) { + const d2 = Object.getOwnPropertyDescriptor(e18, k2); + if (d2) { + Object.defineProperty(n2, k2, d2.get ? d2 : { + enumerable: true, + get: () => e18[k2] + }); + } + } + } + } + } + return Object.freeze(Object.defineProperty(n2, Symbol.toStringTag, { value: "Module" })); +} (function polyfill() { const relList = document.createElement("link").relList; if (relList && relList.supports && relList.supports("modulepreload")) { @@ -85,26 +104,26 @@ function getAugmentedNamespace(n2) { return n2; var f2 = n2.default; if (typeof f2 == "function") { - var a = function a2() { - if (this instanceof a2) { + var a2 = function a3() { + if (this instanceof a3) { return Reflect.construct(f2, arguments, this.constructor); } return f2.apply(this, arguments); }; - a.prototype = f2.prototype; + a2.prototype = f2.prototype; } else - a = {}; - Object.defineProperty(a, "__esModule", { value: true }); + a2 = {}; + Object.defineProperty(a2, "__esModule", { value: true }); Object.keys(n2).forEach(function(k2) { - var d = Object.getOwnPropertyDescriptor(n2, k2); - Object.defineProperty(a, k2, d.get ? d : { + var d2 = Object.getOwnPropertyDescriptor(n2, k2); + Object.defineProperty(a2, k2, d2.get ? d2 : { enumerable: true, get: function() { return n2[k2]; } }); }); - return a; + return a2; } var jsxRuntime = { exports: {} }; var reactJsxRuntime_production_min = {}; @@ -119,88 +138,88 @@ var react_production_min = {}; * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ -var l$2 = Symbol.for("react.element"), n$4 = Symbol.for("react.portal"), p$4 = Symbol.for("react.fragment"), q$3 = Symbol.for("react.strict_mode"), r$2 = Symbol.for("react.profiler"), t$2 = Symbol.for("react.provider"), u$2 = Symbol.for("react.context"), v$2 = Symbol.for("react.forward_ref"), w$1 = Symbol.for("react.suspense"), x = Symbol.for("react.memo"), y = Symbol.for("react.lazy"), z$1 = Symbol.iterator; -function A$1(a) { - if (null === a || "object" !== typeof a) +var l$3 = Symbol.for("react.element"), n$6 = Symbol.for("react.portal"), p$5 = Symbol.for("react.fragment"), q$4 = Symbol.for("react.strict_mode"), r$5 = Symbol.for("react.profiler"), t$4 = Symbol.for("react.provider"), u$3 = Symbol.for("react.context"), v$4 = Symbol.for("react.forward_ref"), w$2 = Symbol.for("react.suspense"), x$1 = Symbol.for("react.memo"), y$1 = Symbol.for("react.lazy"), z$2 = Symbol.iterator; +function A$2(a2) { + if (null === a2 || "object" !== typeof a2) return null; - a = z$1 && a[z$1] || a["@@iterator"]; - return "function" === typeof a ? a : null; + a2 = z$2 && a2[z$2] || a2["@@iterator"]; + return "function" === typeof a2 ? a2 : null; } -var B$1 = { isMounted: function() { +var B$2 = { isMounted: function() { return false; }, enqueueForceUpdate: function() { }, enqueueReplaceState: function() { }, enqueueSetState: function() { -} }, C$1 = Object.assign, D$1 = {}; -function E$1(a, b2, e2) { - this.props = a; +} }, C$2 = Object.assign, D$2 = {}; +function E$2(a2, b2, e18) { + this.props = a2; this.context = b2; - this.refs = D$1; - this.updater = e2 || B$1; + this.refs = D$2; + this.updater = e18 || B$2; } -E$1.prototype.isReactComponent = {}; -E$1.prototype.setState = function(a, b2) { - if ("object" !== typeof a && "function" !== typeof a && null != a) +E$2.prototype.isReactComponent = {}; +E$2.prototype.setState = function(a2, b2) { + if ("object" !== typeof a2 && "function" !== typeof a2 && null != a2) throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables."); - this.updater.enqueueSetState(this, a, b2, "setState"); + this.updater.enqueueSetState(this, a2, b2, "setState"); }; -E$1.prototype.forceUpdate = function(a) { - this.updater.enqueueForceUpdate(this, a, "forceUpdate"); +E$2.prototype.forceUpdate = function(a2) { + this.updater.enqueueForceUpdate(this, a2, "forceUpdate"); }; function F() { } -F.prototype = E$1.prototype; -function G$1(a, b2, e2) { - this.props = a; +F.prototype = E$2.prototype; +function G$2(a2, b2, e18) { + this.props = a2; this.context = b2; - this.refs = D$1; - this.updater = e2 || B$1; -} -var H$1 = G$1.prototype = new F(); -H$1.constructor = G$1; -C$1(H$1, E$1.prototype); -H$1.isPureReactComponent = true; -var I$1 = Array.isArray, J = Object.prototype.hasOwnProperty, K$1 = { current: null }, L$1 = { key: true, ref: true, __self: true, __source: true }; -function M$1(a, b2, e2) { - var d, c = {}, k2 = null, h2 = null; + this.refs = D$2; + this.updater = e18 || B$2; +} +var H$2 = G$2.prototype = new F(); +H$2.constructor = G$2; +C$2(H$2, E$2.prototype); +H$2.isPureReactComponent = true; +var I$2 = Array.isArray, J$1 = Object.prototype.hasOwnProperty, K$2 = { current: null }, L$1 = { key: true, ref: true, __self: true, __source: true }; +function M$2(a2, b2, e18) { + var d2, c2 = {}, k2 = null, h2 = null; if (null != b2) - for (d in void 0 !== b2.ref && (h2 = b2.ref), void 0 !== b2.key && (k2 = "" + b2.key), b2) - J.call(b2, d) && !L$1.hasOwnProperty(d) && (c[d] = b2[d]); - var g = arguments.length - 2; - if (1 === g) - c.children = e2; - else if (1 < g) { - for (var f2 = Array(g), m2 = 0; m2 < g; m2++) + for (d2 in void 0 !== b2.ref && (h2 = b2.ref), void 0 !== b2.key && (k2 = "" + b2.key), b2) + J$1.call(b2, d2) && !L$1.hasOwnProperty(d2) && (c2[d2] = b2[d2]); + var g2 = arguments.length - 2; + if (1 === g2) + c2.children = e18; + else if (1 < g2) { + for (var f2 = Array(g2), m2 = 0; m2 < g2; m2++) f2[m2] = arguments[m2 + 2]; - c.children = f2; + c2.children = f2; } - if (a && a.defaultProps) - for (d in g = a.defaultProps, g) - void 0 === c[d] && (c[d] = g[d]); - return { $$typeof: l$2, type: a, key: k2, ref: h2, props: c, _owner: K$1.current }; + if (a2 && a2.defaultProps) + for (d2 in g2 = a2.defaultProps, g2) + void 0 === c2[d2] && (c2[d2] = g2[d2]); + return { $$typeof: l$3, type: a2, key: k2, ref: h2, props: c2, _owner: K$2.current }; } -function N$2(a, b2) { - return { $$typeof: l$2, type: a.type, key: b2, ref: a.ref, props: a.props, _owner: a._owner }; +function N$3(a2, b2) { + return { $$typeof: l$3, type: a2.type, key: b2, ref: a2.ref, props: a2.props, _owner: a2._owner }; } -function O$1(a) { - return "object" === typeof a && null !== a && a.$$typeof === l$2; +function O$3(a2) { + return "object" === typeof a2 && null !== a2 && a2.$$typeof === l$3; } -function escape(a) { +function escape(a2) { var b2 = { "=": "=0", ":": "=2" }; - return "$" + a.replace(/[=:]/g, function(a2) { - return b2[a2]; + return "$" + a2.replace(/[=:]/g, function(a3) { + return b2[a3]; }); } -var P$1 = /\/+/g; -function Q$1(a, b2) { - return "object" === typeof a && null !== a && null != a.key ? escape("" + a.key) : b2.toString(36); +var P$2 = /\/+/g; +function Q$2(a2, b2) { + return "object" === typeof a2 && null !== a2 && null != a2.key ? escape("" + a2.key) : b2.toString(36); } -function R$1(a, b2, e2, d, c) { - var k2 = typeof a; +function R$2(a2, b2, e18, d2, c2) { + var k2 = typeof a2; if ("undefined" === k2 || "boolean" === k2) - a = null; + a2 = null; var h2 = false; - if (null === a) + if (null === a2) h2 = true; else switch (k2) { @@ -209,195 +228,195 @@ function R$1(a, b2, e2, d, c) { h2 = true; break; case "object": - switch (a.$$typeof) { - case l$2: - case n$4: + switch (a2.$$typeof) { + case l$3: + case n$6: h2 = true; } } if (h2) - return h2 = a, c = c(h2), a = "" === d ? "." + Q$1(h2, 0) : d, I$1(c) ? (e2 = "", null != a && (e2 = a.replace(P$1, "$&/") + "/"), R$1(c, b2, e2, "", function(a2) { - return a2; - })) : null != c && (O$1(c) && (c = N$2(c, e2 + (!c.key || h2 && h2.key === c.key ? "" : ("" + c.key).replace(P$1, "$&/") + "/") + a)), b2.push(c)), 1; + return h2 = a2, c2 = c2(h2), a2 = "" === d2 ? "." + Q$2(h2, 0) : d2, I$2(c2) ? (e18 = "", null != a2 && (e18 = a2.replace(P$2, "$&/") + "/"), R$2(c2, b2, e18, "", function(a3) { + return a3; + })) : null != c2 && (O$3(c2) && (c2 = N$3(c2, e18 + (!c2.key || h2 && h2.key === c2.key ? "" : ("" + c2.key).replace(P$2, "$&/") + "/") + a2)), b2.push(c2)), 1; h2 = 0; - d = "" === d ? "." : d + ":"; - if (I$1(a)) - for (var g = 0; g < a.length; g++) { - k2 = a[g]; - var f2 = d + Q$1(k2, g); - h2 += R$1(k2, b2, e2, f2, c); - } - else if (f2 = A$1(a), "function" === typeof f2) - for (a = f2.call(a), g = 0; !(k2 = a.next()).done; ) - k2 = k2.value, f2 = d + Q$1(k2, g++), h2 += R$1(k2, b2, e2, f2, c); + d2 = "" === d2 ? "." : d2 + ":"; + if (I$2(a2)) + for (var g2 = 0; g2 < a2.length; g2++) { + k2 = a2[g2]; + var f2 = d2 + Q$2(k2, g2); + h2 += R$2(k2, b2, e18, f2, c2); + } + else if (f2 = A$2(a2), "function" === typeof f2) + for (a2 = f2.call(a2), g2 = 0; !(k2 = a2.next()).done; ) + k2 = k2.value, f2 = d2 + Q$2(k2, g2++), h2 += R$2(k2, b2, e18, f2, c2); else if ("object" === k2) - throw b2 = String(a), Error("Objects are not valid as a React child (found: " + ("[object Object]" === b2 ? "object with keys {" + Object.keys(a).join(", ") + "}" : b2) + "). If you meant to render a collection of children, use an array instead."); + throw b2 = String(a2), Error("Objects are not valid as a React child (found: " + ("[object Object]" === b2 ? "object with keys {" + Object.keys(a2).join(", ") + "}" : b2) + "). If you meant to render a collection of children, use an array instead."); return h2; } -function S$2(a, b2, e2) { - if (null == a) - return a; - var d = [], c = 0; - R$1(a, d, "", "", function(a2) { - return b2.call(e2, a2, c++); +function S$3(a2, b2, e18) { + if (null == a2) + return a2; + var d2 = [], c2 = 0; + R$2(a2, d2, "", "", function(a3) { + return b2.call(e18, a3, c2++); }); - return d; + return d2; } -function T$1(a) { - if (-1 === a._status) { - var b2 = a._result; +function T$2(a2) { + if (-1 === a2._status) { + var b2 = a2._result; b2 = b2(); b2.then(function(b3) { - if (0 === a._status || -1 === a._status) - a._status = 1, a._result = b3; + if (0 === a2._status || -1 === a2._status) + a2._status = 1, a2._result = b3; }, function(b3) { - if (0 === a._status || -1 === a._status) - a._status = 2, a._result = b3; + if (0 === a2._status || -1 === a2._status) + a2._status = 2, a2._result = b3; }); - -1 === a._status && (a._status = 0, a._result = b2); + -1 === a2._status && (a2._status = 0, a2._result = b2); } - if (1 === a._status) - return a._result.default; - throw a._result; + if (1 === a2._status) + return a2._result.default; + throw a2._result; } -var U$1 = { current: null }, V$1 = { transition: null }, W$1 = { ReactCurrentDispatcher: U$1, ReactCurrentBatchConfig: V$1, ReactCurrentOwner: K$1 }; -function X$1() { +var U$2 = { current: null }, V$2 = { transition: null }, W$3 = { ReactCurrentDispatcher: U$2, ReactCurrentBatchConfig: V$2, ReactCurrentOwner: K$2 }; +function X$2() { throw Error("act(...) is not supported in production builds of React."); } -react_production_min.Children = { map: S$2, forEach: function(a, b2, e2) { - S$2(a, function() { +react_production_min.Children = { map: S$3, forEach: function(a2, b2, e18) { + S$3(a2, function() { b2.apply(this, arguments); - }, e2); -}, count: function(a) { + }, e18); +}, count: function(a2) { var b2 = 0; - S$2(a, function() { + S$3(a2, function() { b2++; }); return b2; -}, toArray: function(a) { - return S$2(a, function(a2) { - return a2; +}, toArray: function(a2) { + return S$3(a2, function(a3) { + return a3; }) || []; -}, only: function(a) { - if (!O$1(a)) +}, only: function(a2) { + if (!O$3(a2)) throw Error("React.Children.only expected to receive a single React element child."); - return a; + return a2; } }; -react_production_min.Component = E$1; -react_production_min.Fragment = p$4; -react_production_min.Profiler = r$2; -react_production_min.PureComponent = G$1; -react_production_min.StrictMode = q$3; -react_production_min.Suspense = w$1; -react_production_min.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = W$1; -react_production_min.act = X$1; -react_production_min.cloneElement = function(a, b2, e2) { - if (null === a || void 0 === a) - throw Error("React.cloneElement(...): The argument must be a React element, but you passed " + a + "."); - var d = C$1({}, a.props), c = a.key, k2 = a.ref, h2 = a._owner; +react_production_min.Component = E$2; +react_production_min.Fragment = p$5; +react_production_min.Profiler = r$5; +react_production_min.PureComponent = G$2; +react_production_min.StrictMode = q$4; +react_production_min.Suspense = w$2; +react_production_min.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = W$3; +react_production_min.act = X$2; +react_production_min.cloneElement = function(a2, b2, e18) { + if (null === a2 || void 0 === a2) + throw Error("React.cloneElement(...): The argument must be a React element, but you passed " + a2 + "."); + var d2 = C$2({}, a2.props), c2 = a2.key, k2 = a2.ref, h2 = a2._owner; if (null != b2) { - void 0 !== b2.ref && (k2 = b2.ref, h2 = K$1.current); - void 0 !== b2.key && (c = "" + b2.key); - if (a.type && a.type.defaultProps) - var g = a.type.defaultProps; + void 0 !== b2.ref && (k2 = b2.ref, h2 = K$2.current); + void 0 !== b2.key && (c2 = "" + b2.key); + if (a2.type && a2.type.defaultProps) + var g2 = a2.type.defaultProps; for (f2 in b2) - J.call(b2, f2) && !L$1.hasOwnProperty(f2) && (d[f2] = void 0 === b2[f2] && void 0 !== g ? g[f2] : b2[f2]); + J$1.call(b2, f2) && !L$1.hasOwnProperty(f2) && (d2[f2] = void 0 === b2[f2] && void 0 !== g2 ? g2[f2] : b2[f2]); } var f2 = arguments.length - 2; if (1 === f2) - d.children = e2; + d2.children = e18; else if (1 < f2) { - g = Array(f2); + g2 = Array(f2); for (var m2 = 0; m2 < f2; m2++) - g[m2] = arguments[m2 + 2]; - d.children = g; + g2[m2] = arguments[m2 + 2]; + d2.children = g2; } - return { $$typeof: l$2, type: a.type, key: c, ref: k2, props: d, _owner: h2 }; + return { $$typeof: l$3, type: a2.type, key: c2, ref: k2, props: d2, _owner: h2 }; }; -react_production_min.createContext = function(a) { - a = { $$typeof: u$2, _currentValue: a, _currentValue2: a, _threadCount: 0, Provider: null, Consumer: null, _defaultValue: null, _globalName: null }; - a.Provider = { $$typeof: t$2, _context: a }; - return a.Consumer = a; +react_production_min.createContext = function(a2) { + a2 = { $$typeof: u$3, _currentValue: a2, _currentValue2: a2, _threadCount: 0, Provider: null, Consumer: null, _defaultValue: null, _globalName: null }; + a2.Provider = { $$typeof: t$4, _context: a2 }; + return a2.Consumer = a2; }; -react_production_min.createElement = M$1; -react_production_min.createFactory = function(a) { - var b2 = M$1.bind(null, a); - b2.type = a; +react_production_min.createElement = M$2; +react_production_min.createFactory = function(a2) { + var b2 = M$2.bind(null, a2); + b2.type = a2; return b2; }; react_production_min.createRef = function() { return { current: null }; }; -react_production_min.forwardRef = function(a) { - return { $$typeof: v$2, render: a }; +react_production_min.forwardRef = function(a2) { + return { $$typeof: v$4, render: a2 }; }; -react_production_min.isValidElement = O$1; -react_production_min.lazy = function(a) { - return { $$typeof: y, _payload: { _status: -1, _result: a }, _init: T$1 }; +react_production_min.isValidElement = O$3; +react_production_min.lazy = function(a2) { + return { $$typeof: y$1, _payload: { _status: -1, _result: a2 }, _init: T$2 }; }; -react_production_min.memo = function(a, b2) { - return { $$typeof: x, type: a, compare: void 0 === b2 ? null : b2 }; +react_production_min.memo = function(a2, b2) { + return { $$typeof: x$1, type: a2, compare: void 0 === b2 ? null : b2 }; }; -react_production_min.startTransition = function(a) { - var b2 = V$1.transition; - V$1.transition = {}; +react_production_min.startTransition = function(a2) { + var b2 = V$2.transition; + V$2.transition = {}; try { - a(); + a2(); } finally { - V$1.transition = b2; + V$2.transition = b2; } }; -react_production_min.unstable_act = X$1; -react_production_min.useCallback = function(a, b2) { - return U$1.current.useCallback(a, b2); +react_production_min.unstable_act = X$2; +react_production_min.useCallback = function(a2, b2) { + return U$2.current.useCallback(a2, b2); }; -react_production_min.useContext = function(a) { - return U$1.current.useContext(a); +react_production_min.useContext = function(a2) { + return U$2.current.useContext(a2); }; react_production_min.useDebugValue = function() { }; -react_production_min.useDeferredValue = function(a) { - return U$1.current.useDeferredValue(a); +react_production_min.useDeferredValue = function(a2) { + return U$2.current.useDeferredValue(a2); }; -react_production_min.useEffect = function(a, b2) { - return U$1.current.useEffect(a, b2); +react_production_min.useEffect = function(a2, b2) { + return U$2.current.useEffect(a2, b2); }; react_production_min.useId = function() { - return U$1.current.useId(); + return U$2.current.useId(); }; -react_production_min.useImperativeHandle = function(a, b2, e2) { - return U$1.current.useImperativeHandle(a, b2, e2); +react_production_min.useImperativeHandle = function(a2, b2, e18) { + return U$2.current.useImperativeHandle(a2, b2, e18); }; -react_production_min.useInsertionEffect = function(a, b2) { - return U$1.current.useInsertionEffect(a, b2); +react_production_min.useInsertionEffect = function(a2, b2) { + return U$2.current.useInsertionEffect(a2, b2); }; -react_production_min.useLayoutEffect = function(a, b2) { - return U$1.current.useLayoutEffect(a, b2); +react_production_min.useLayoutEffect = function(a2, b2) { + return U$2.current.useLayoutEffect(a2, b2); }; -react_production_min.useMemo = function(a, b2) { - return U$1.current.useMemo(a, b2); +react_production_min.useMemo = function(a2, b2) { + return U$2.current.useMemo(a2, b2); }; -react_production_min.useReducer = function(a, b2, e2) { - return U$1.current.useReducer(a, b2, e2); +react_production_min.useReducer = function(a2, b2, e18) { + return U$2.current.useReducer(a2, b2, e18); }; -react_production_min.useRef = function(a) { - return U$1.current.useRef(a); +react_production_min.useRef = function(a2) { + return U$2.current.useRef(a2); }; -react_production_min.useState = function(a) { - return U$1.current.useState(a); +react_production_min.useState = function(a2) { + return U$2.current.useState(a2); }; -react_production_min.useSyncExternalStore = function(a, b2, e2) { - return U$1.current.useSyncExternalStore(a, b2, e2); +react_production_min.useSyncExternalStore = function(a2, b2, e18) { + return U$2.current.useSyncExternalStore(a2, b2, e18); }; react_production_min.useTransition = function() { - return U$1.current.useTransition(); + return U$2.current.useTransition(); }; react_production_min.version = "18.3.1"; { react.exports = react_production_min; } var reactExports = react.exports; -const React = /* @__PURE__ */ getDefaultExportFromCjs$1(reactExports); +const W$2 = /* @__PURE__ */ getDefaultExportFromCjs$1(reactExports); /** * @license React * react-jsx-runtime.production.min.js @@ -407,22 +426,22 @@ const React = /* @__PURE__ */ getDefaultExportFromCjs$1(reactExports); * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ -var f$2 = reactExports, k$1 = Symbol.for("react.element"), l$1 = Symbol.for("react.fragment"), m$2 = Object.prototype.hasOwnProperty, n$3 = f$2.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, p$3 = { key: true, ref: true, __self: true, __source: true }; -function q$2(c, a, g) { - var b2, d = {}, e2 = null, h2 = null; - void 0 !== g && (e2 = "" + g); - void 0 !== a.key && (e2 = "" + a.key); - void 0 !== a.ref && (h2 = a.ref); - for (b2 in a) - m$2.call(a, b2) && !p$3.hasOwnProperty(b2) && (d[b2] = a[b2]); - if (c && c.defaultProps) - for (b2 in a = c.defaultProps, a) - void 0 === d[b2] && (d[b2] = a[b2]); - return { $$typeof: k$1, type: c, key: e2, ref: h2, props: d, _owner: n$3.current }; -} -reactJsxRuntime_production_min.Fragment = l$1; -reactJsxRuntime_production_min.jsx = q$2; -reactJsxRuntime_production_min.jsxs = q$2; +var f$4 = reactExports, k$1 = Symbol.for("react.element"), l$2 = Symbol.for("react.fragment"), m$4 = Object.prototype.hasOwnProperty, n$5 = f$4.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, p$4 = { key: true, ref: true, __self: true, __source: true }; +function q$3(c2, a2, g2) { + var b2, d2 = {}, e18 = null, h2 = null; + void 0 !== g2 && (e18 = "" + g2); + void 0 !== a2.key && (e18 = "" + a2.key); + void 0 !== a2.ref && (h2 = a2.ref); + for (b2 in a2) + m$4.call(a2, b2) && !p$4.hasOwnProperty(b2) && (d2[b2] = a2[b2]); + if (c2 && c2.defaultProps) + for (b2 in a2 = c2.defaultProps, a2) + void 0 === d2[b2] && (d2[b2] = a2[b2]); + return { $$typeof: k$1, type: c2, key: e18, ref: h2, props: d2, _owner: n$5.current }; +} +reactJsxRuntime_production_min.Fragment = l$2; +reactJsxRuntime_production_min.jsx = q$3; +reactJsxRuntime_production_min.jsxs = q$3; { jsxRuntime.exports = reactJsxRuntime_production_min; } @@ -443,43 +462,43 @@ var scheduler_production_min = {}; * LICENSE file in the root directory of this source tree. */ (function(exports) { - function f2(a, b2) { - var c = a.length; - a.push(b2); + function f2(a2, b2) { + var c2 = a2.length; + a2.push(b2); a: - for (; 0 < c; ) { - var d = c - 1 >>> 1, e2 = a[d]; - if (0 < g(e2, b2)) - a[d] = b2, a[c] = e2, c = d; + for (; 0 < c2; ) { + var d2 = c2 - 1 >>> 1, e18 = a2[d2]; + if (0 < g2(e18, b2)) + a2[d2] = b2, a2[c2] = e18, c2 = d2; else break a; } } - function h2(a) { - return 0 === a.length ? null : a[0]; + function h2(a2) { + return 0 === a2.length ? null : a2[0]; } - function k2(a) { - if (0 === a.length) + function k2(a2) { + if (0 === a2.length) return null; - var b2 = a[0], c = a.pop(); - if (c !== b2) { - a[0] = c; + var b2 = a2[0], c2 = a2.pop(); + if (c2 !== b2) { + a2[0] = c2; a: - for (var d = 0, e2 = a.length, w2 = e2 >>> 1; d < w2; ) { - var m2 = 2 * (d + 1) - 1, C2 = a[m2], n2 = m2 + 1, x2 = a[n2]; - if (0 > g(C2, c)) - n2 < e2 && 0 > g(x2, C2) ? (a[d] = x2, a[n2] = c, d = n2) : (a[d] = C2, a[m2] = c, d = m2); - else if (n2 < e2 && 0 > g(x2, c)) - a[d] = x2, a[n2] = c, d = n2; + for (var d2 = 0, e18 = a2.length, w2 = e18 >>> 1; d2 < w2; ) { + var m2 = 2 * (d2 + 1) - 1, C2 = a2[m2], n2 = m2 + 1, x2 = a2[n2]; + if (0 > g2(C2, c2)) + n2 < e18 && 0 > g2(x2, C2) ? (a2[d2] = x2, a2[n2] = c2, d2 = n2) : (a2[d2] = C2, a2[m2] = c2, d2 = m2); + else if (n2 < e18 && 0 > g2(x2, c2)) + a2[d2] = x2, a2[n2] = c2, d2 = n2; else break a; } } return b2; } - function g(a, b2) { - var c = a.sortIndex - b2.sortIndex; - return 0 !== c ? c : a.id - b2.id; + function g2(a2, b2) { + var c2 = a2.sortIndex - b2.sortIndex; + return 0 !== c2 ? c2 : a2.id - b2.id; } if ("object" === typeof performance && "function" === typeof performance.now) { var l2 = performance; @@ -494,43 +513,43 @@ var scheduler_production_min = {}; } var r2 = [], t2 = [], u2 = 1, v2 = null, y2 = 3, z2 = false, A2 = false, B2 = false, D2 = "function" === typeof setTimeout ? setTimeout : null, E2 = "function" === typeof clearTimeout ? clearTimeout : null, F2 = "undefined" !== typeof setImmediate ? setImmediate : null; "undefined" !== typeof navigator && void 0 !== navigator.scheduling && void 0 !== navigator.scheduling.isInputPending && navigator.scheduling.isInputPending.bind(navigator.scheduling); - function G2(a) { + function G2(a2) { for (var b2 = h2(t2); null !== b2; ) { if (null === b2.callback) k2(t2); - else if (b2.startTime <= a) + else if (b2.startTime <= a2) k2(t2), b2.sortIndex = b2.expirationTime, f2(r2, b2); else break; b2 = h2(t2); } } - function H2(a) { + function H2(a2) { B2 = false; - G2(a); + G2(a2); if (!A2) if (null !== h2(r2)) A2 = true, I2(J2); else { var b2 = h2(t2); - null !== b2 && K2(H2, b2.startTime - a); + null !== b2 && K2(H2, b2.startTime - a2); } } - function J2(a, b2) { + function J2(a2, b2) { A2 = false; B2 && (B2 = false, E2(L2), L2 = -1); z2 = true; - var c = y2; + var c2 = y2; try { G2(b2); - for (v2 = h2(r2); null !== v2 && (!(v2.expirationTime > b2) || a && !M2()); ) { - var d = v2.callback; - if ("function" === typeof d) { + for (v2 = h2(r2); null !== v2 && (!(v2.expirationTime > b2) || a2 && !M2()); ) { + var d2 = v2.callback; + if ("function" === typeof d2) { v2.callback = null; y2 = v2.priorityLevel; - var e2 = d(v2.expirationTime <= b2); + var e18 = d2(v2.expirationTime <= b2); b2 = exports.unstable_now(); - "function" === typeof e2 ? v2.callback = e2 : v2 === h2(r2) && k2(r2); + "function" === typeof e18 ? v2.callback = e18 : v2 === h2(r2) && k2(r2); G2(b2); } else k2(r2); @@ -545,7 +564,7 @@ var scheduler_production_min = {}; } return w2; } finally { - v2 = null, y2 = c, z2 = false; + v2 = null, y2 = c2, z2 = false; } } var N2 = false, O2 = null, L2 = -1, P2 = 5, Q2 = -1; @@ -554,11 +573,11 @@ var scheduler_production_min = {}; } function R2() { if (null !== O2) { - var a = exports.unstable_now(); - Q2 = a; + var a2 = exports.unstable_now(); + Q2 = a2; var b2 = true; try { - b2 = O2(true, a); + b2 = O2(true, a2); } finally { b2 ? S2() : (N2 = false, O2 = null); } @@ -580,13 +599,13 @@ var scheduler_production_min = {}; S2 = function() { D2(R2, 0); }; - function I2(a) { - O2 = a; + function I2(a2) { + O2 = a2; N2 || (N2 = true, S2()); } - function K2(a, b2) { + function K2(a2, b2) { L2 = D2(function() { - a(exports.unstable_now()); + a2(exports.unstable_now()); }, b2); } exports.unstable_IdlePriority = 5; @@ -595,14 +614,14 @@ var scheduler_production_min = {}; exports.unstable_NormalPriority = 3; exports.unstable_Profiling = null; exports.unstable_UserBlockingPriority = 2; - exports.unstable_cancelCallback = function(a) { - a.callback = null; + exports.unstable_cancelCallback = function(a2) { + a2.callback = null; }; exports.unstable_continueExecution = function() { A2 || z2 || (A2 = true, I2(J2)); }; - exports.unstable_forceFrameRate = function(a) { - 0 > a || 125 < a ? console.error("forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported") : P2 = 0 < a ? Math.floor(1e3 / a) : 5; + exports.unstable_forceFrameRate = function(a2) { + 0 > a2 || 125 < a2 ? console.error("forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported") : P2 = 0 < a2 ? Math.floor(1e3 / a2) : 5; }; exports.unstable_getCurrentPriorityLevel = function() { return y2; @@ -610,7 +629,7 @@ var scheduler_production_min = {}; exports.unstable_getFirstCallbackNode = function() { return h2(r2); }; - exports.unstable_next = function(a) { + exports.unstable_next = function(a2) { switch (y2) { case 1: case 2: @@ -620,20 +639,20 @@ var scheduler_production_min = {}; default: b2 = y2; } - var c = y2; + var c2 = y2; y2 = b2; try { - return a(); + return a2(); } finally { - y2 = c; + y2 = c2; } }; exports.unstable_pauseExecution = function() { }; exports.unstable_requestPaint = function() { }; - exports.unstable_runWithPriority = function(a, b2) { - switch (a) { + exports.unstable_runWithPriority = function(a2, b2) { + switch (a2) { case 1: case 2: case 3: @@ -641,50 +660,50 @@ var scheduler_production_min = {}; case 5: break; default: - a = 3; + a2 = 3; } - var c = y2; - y2 = a; + var c2 = y2; + y2 = a2; try { return b2(); } finally { - y2 = c; + y2 = c2; } }; - exports.unstable_scheduleCallback = function(a, b2, c) { - var d = exports.unstable_now(); - "object" === typeof c && null !== c ? (c = c.delay, c = "number" === typeof c && 0 < c ? d + c : d) : c = d; - switch (a) { + exports.unstable_scheduleCallback = function(a2, b2, c2) { + var d2 = exports.unstable_now(); + "object" === typeof c2 && null !== c2 ? (c2 = c2.delay, c2 = "number" === typeof c2 && 0 < c2 ? d2 + c2 : d2) : c2 = d2; + switch (a2) { case 1: - var e2 = -1; + var e18 = -1; break; case 2: - e2 = 250; + e18 = 250; break; case 5: - e2 = 1073741823; + e18 = 1073741823; break; case 4: - e2 = 1e4; + e18 = 1e4; break; default: - e2 = 5e3; + e18 = 5e3; } - e2 = c + e2; - a = { id: u2++, callback: b2, priorityLevel: a, startTime: c, expirationTime: e2, sortIndex: -1 }; - c > d ? (a.sortIndex = c, f2(t2, a), null === h2(r2) && a === h2(t2) && (B2 ? (E2(L2), L2 = -1) : B2 = true, K2(H2, c - d))) : (a.sortIndex = e2, f2(r2, a), A2 || z2 || (A2 = true, I2(J2))); - return a; + e18 = c2 + e18; + a2 = { id: u2++, callback: b2, priorityLevel: a2, startTime: c2, expirationTime: e18, sortIndex: -1 }; + c2 > d2 ? (a2.sortIndex = c2, f2(t2, a2), null === h2(r2) && a2 === h2(t2) && (B2 ? (E2(L2), L2 = -1) : B2 = true, K2(H2, c2 - d2))) : (a2.sortIndex = e18, f2(r2, a2), A2 || z2 || (A2 = true, I2(J2))); + return a2; }; exports.unstable_shouldYield = M2; - exports.unstable_wrapCallback = function(a) { + exports.unstable_wrapCallback = function(a2) { var b2 = y2; return function() { - var c = y2; + var c2 = y2; y2 = b2; try { - return a.apply(this, arguments); + return a2.apply(this, arguments); } finally { - y2 = c; + y2 = c2; } }; }; @@ -703,57 +722,57 @@ var schedulerExports = scheduler.exports; * LICENSE file in the root directory of this source tree. */ var aa = reactExports, ca = schedulerExports; -function p$2(a) { - for (var b2 = "https://reactjs.org/docs/error-decoder.html?invariant=" + a, c = 1; c < arguments.length; c++) - b2 += "&args[]=" + encodeURIComponent(arguments[c]); - return "Minified React error #" + a + "; visit " + b2 + " for the full message or use the non-minified dev environment for full errors and additional helpful warnings."; +function p$3(a2) { + for (var b2 = "https://reactjs.org/docs/error-decoder.html?invariant=" + a2, c2 = 1; c2 < arguments.length; c2++) + b2 += "&args[]=" + encodeURIComponent(arguments[c2]); + return "Minified React error #" + a2 + "; visit " + b2 + " for the full message or use the non-minified dev environment for full errors and additional helpful warnings."; } -var da = /* @__PURE__ */ new Set(), ea = {}; -function fa(a, b2) { - ha(a, b2); - ha(a + "Capture", b2); +var da = /* @__PURE__ */ new Set(), ea$1 = {}; +function fa(a2, b2) { + ha(a2, b2); + ha(a2 + "Capture", b2); } -function ha(a, b2) { - ea[a] = b2; - for (a = 0; a < b2.length; a++) - da.add(b2[a]); +function ha(a2, b2) { + ea$1[a2] = b2; + for (a2 = 0; a2 < b2.length; a2++) + da.add(b2[a2]); } var ia = !("undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement), ja = Object.prototype.hasOwnProperty, ka = /^[:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD][:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\-.0-9\u00B7\u0300-\u036F\u203F-\u2040]*$/, la = {}, ma = {}; -function oa(a) { - if (ja.call(ma, a)) +function oa(a2) { + if (ja.call(ma, a2)) return true; - if (ja.call(la, a)) + if (ja.call(la, a2)) return false; - if (ka.test(a)) - return ma[a] = true; - la[a] = true; + if (ka.test(a2)) + return ma[a2] = true; + la[a2] = true; return false; } -function pa(a, b2, c, d) { - if (null !== c && 0 === c.type) +function pa(a2, b2, c2, d2) { + if (null !== c2 && 0 === c2.type) return false; switch (typeof b2) { case "function": case "symbol": return true; case "boolean": - if (d) + if (d2) return false; - if (null !== c) - return !c.acceptsBooleans; - a = a.toLowerCase().slice(0, 5); - return "data-" !== a && "aria-" !== a; + if (null !== c2) + return !c2.acceptsBooleans; + a2 = a2.toLowerCase().slice(0, 5); + return "data-" !== a2 && "aria-" !== a2; default: return false; } } -function qa(a, b2, c, d) { - if (null === b2 || "undefined" === typeof b2 || pa(a, b2, c, d)) +function qa(a2, b2, c2, d2) { + if (null === b2 || "undefined" === typeof b2 || pa(a2, b2, c2, d2)) return true; - if (d) + if (d2) return false; - if (null !== c) - switch (c.type) { + if (null !== c2) + switch (c2.type) { case 3: return !b2; case 4: @@ -765,102 +784,102 @@ function qa(a, b2, c, d) { } return false; } -function v$1(a, b2, c, d, e2, f2, g) { +function v$3(a2, b2, c2, d2, e18, f2, g2) { this.acceptsBooleans = 2 === b2 || 3 === b2 || 4 === b2; - this.attributeName = d; - this.attributeNamespace = e2; - this.mustUseProperty = c; - this.propertyName = a; + this.attributeName = d2; + this.attributeNamespace = e18; + this.mustUseProperty = c2; + this.propertyName = a2; this.type = b2; this.sanitizeURL = f2; - this.removeEmptyString = g; + this.removeEmptyString = g2; } -var z = {}; -"children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style".split(" ").forEach(function(a) { - z[a] = new v$1(a, 0, false, a, null, false, false); +var z$1 = {}; +"children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style".split(" ").forEach(function(a2) { + z$1[a2] = new v$3(a2, 0, false, a2, null, false, false); }); -[["acceptCharset", "accept-charset"], ["className", "class"], ["htmlFor", "for"], ["httpEquiv", "http-equiv"]].forEach(function(a) { - var b2 = a[0]; - z[b2] = new v$1(b2, 1, false, a[1], null, false, false); +[["acceptCharset", "accept-charset"], ["className", "class"], ["htmlFor", "for"], ["httpEquiv", "http-equiv"]].forEach(function(a2) { + var b2 = a2[0]; + z$1[b2] = new v$3(b2, 1, false, a2[1], null, false, false); }); -["contentEditable", "draggable", "spellCheck", "value"].forEach(function(a) { - z[a] = new v$1(a, 2, false, a.toLowerCase(), null, false, false); +["contentEditable", "draggable", "spellCheck", "value"].forEach(function(a2) { + z$1[a2] = new v$3(a2, 2, false, a2.toLowerCase(), null, false, false); }); -["autoReverse", "externalResourcesRequired", "focusable", "preserveAlpha"].forEach(function(a) { - z[a] = new v$1(a, 2, false, a, null, false, false); +["autoReverse", "externalResourcesRequired", "focusable", "preserveAlpha"].forEach(function(a2) { + z$1[a2] = new v$3(a2, 2, false, a2, null, false, false); }); -"allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope".split(" ").forEach(function(a) { - z[a] = new v$1(a, 3, false, a.toLowerCase(), null, false, false); +"allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope".split(" ").forEach(function(a2) { + z$1[a2] = new v$3(a2, 3, false, a2.toLowerCase(), null, false, false); }); -["checked", "multiple", "muted", "selected"].forEach(function(a) { - z[a] = new v$1(a, 3, true, a, null, false, false); +["checked", "multiple", "muted", "selected"].forEach(function(a2) { + z$1[a2] = new v$3(a2, 3, true, a2, null, false, false); }); -["capture", "download"].forEach(function(a) { - z[a] = new v$1(a, 4, false, a, null, false, false); +["capture", "download"].forEach(function(a2) { + z$1[a2] = new v$3(a2, 4, false, a2, null, false, false); }); -["cols", "rows", "size", "span"].forEach(function(a) { - z[a] = new v$1(a, 6, false, a, null, false, false); +["cols", "rows", "size", "span"].forEach(function(a2) { + z$1[a2] = new v$3(a2, 6, false, a2, null, false, false); }); -["rowSpan", "start"].forEach(function(a) { - z[a] = new v$1(a, 5, false, a.toLowerCase(), null, false, false); +["rowSpan", "start"].forEach(function(a2) { + z$1[a2] = new v$3(a2, 5, false, a2.toLowerCase(), null, false, false); }); -var ra = /[\-:]([a-z])/g; -function sa(a) { - return a[1].toUpperCase(); +var ra$1 = /[\-:]([a-z])/g; +function sa(a2) { + return a2[1].toUpperCase(); } -"accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height".split(" ").forEach(function(a) { - var b2 = a.replace( - ra, +"accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height".split(" ").forEach(function(a2) { + var b2 = a2.replace( + ra$1, sa ); - z[b2] = new v$1(b2, 1, false, a, null, false, false); + z$1[b2] = new v$3(b2, 1, false, a2, null, false, false); }); -"xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type".split(" ").forEach(function(a) { - var b2 = a.replace(ra, sa); - z[b2] = new v$1(b2, 1, false, a, "http://www.w3.org/1999/xlink", false, false); +"xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type".split(" ").forEach(function(a2) { + var b2 = a2.replace(ra$1, sa); + z$1[b2] = new v$3(b2, 1, false, a2, "http://www.w3.org/1999/xlink", false, false); }); -["xml:base", "xml:lang", "xml:space"].forEach(function(a) { - var b2 = a.replace(ra, sa); - z[b2] = new v$1(b2, 1, false, a, "http://www.w3.org/XML/1998/namespace", false, false); +["xml:base", "xml:lang", "xml:space"].forEach(function(a2) { + var b2 = a2.replace(ra$1, sa); + z$1[b2] = new v$3(b2, 1, false, a2, "http://www.w3.org/XML/1998/namespace", false, false); }); -["tabIndex", "crossOrigin"].forEach(function(a) { - z[a] = new v$1(a, 1, false, a.toLowerCase(), null, false, false); +["tabIndex", "crossOrigin"].forEach(function(a2) { + z$1[a2] = new v$3(a2, 1, false, a2.toLowerCase(), null, false, false); }); -z.xlinkHref = new v$1("xlinkHref", 1, false, "xlink:href", "http://www.w3.org/1999/xlink", true, false); -["src", "href", "action", "formAction"].forEach(function(a) { - z[a] = new v$1(a, 1, false, a.toLowerCase(), null, true, true); +z$1.xlinkHref = new v$3("xlinkHref", 1, false, "xlink:href", "http://www.w3.org/1999/xlink", true, false); +["src", "href", "action", "formAction"].forEach(function(a2) { + z$1[a2] = new v$3(a2, 1, false, a2.toLowerCase(), null, true, true); }); -function ta(a, b2, c, d) { - var e2 = z.hasOwnProperty(b2) ? z[b2] : null; - if (null !== e2 ? 0 !== e2.type : d || !(2 < b2.length) || "o" !== b2[0] && "O" !== b2[0] || "n" !== b2[1] && "N" !== b2[1]) - qa(b2, c, e2, d) && (c = null), d || null === e2 ? oa(b2) && (null === c ? a.removeAttribute(b2) : a.setAttribute(b2, "" + c)) : e2.mustUseProperty ? a[e2.propertyName] = null === c ? 3 === e2.type ? false : "" : c : (b2 = e2.attributeName, d = e2.attributeNamespace, null === c ? a.removeAttribute(b2) : (e2 = e2.type, c = 3 === e2 || 4 === e2 && true === c ? "" : "" + c, d ? a.setAttributeNS(d, b2, c) : a.setAttribute(b2, c))); +function ta(a2, b2, c2, d2) { + var e18 = z$1.hasOwnProperty(b2) ? z$1[b2] : null; + if (null !== e18 ? 0 !== e18.type : d2 || !(2 < b2.length) || "o" !== b2[0] && "O" !== b2[0] || "n" !== b2[1] && "N" !== b2[1]) + qa(b2, c2, e18, d2) && (c2 = null), d2 || null === e18 ? oa(b2) && (null === c2 ? a2.removeAttribute(b2) : a2.setAttribute(b2, "" + c2)) : e18.mustUseProperty ? a2[e18.propertyName] = null === c2 ? 3 === e18.type ? false : "" : c2 : (b2 = e18.attributeName, d2 = e18.attributeNamespace, null === c2 ? a2.removeAttribute(b2) : (e18 = e18.type, c2 = 3 === e18 || 4 === e18 && true === c2 ? "" : "" + c2, d2 ? a2.setAttributeNS(d2, b2, c2) : a2.setAttribute(b2, c2))); } var ua = aa.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, va = Symbol.for("react.element"), wa = Symbol.for("react.portal"), ya = Symbol.for("react.fragment"), za = Symbol.for("react.strict_mode"), Aa = Symbol.for("react.profiler"), Ba = Symbol.for("react.provider"), Ca = Symbol.for("react.context"), Da = Symbol.for("react.forward_ref"), Ea = Symbol.for("react.suspense"), Fa = Symbol.for("react.suspense_list"), Ga = Symbol.for("react.memo"), Ha = Symbol.for("react.lazy"); var Ia = Symbol.for("react.offscreen"); var Ja = Symbol.iterator; -function Ka(a) { - if (null === a || "object" !== typeof a) +function Ka(a2) { + if (null === a2 || "object" !== typeof a2) return null; - a = Ja && a[Ja] || a["@@iterator"]; - return "function" === typeof a ? a : null; + a2 = Ja && a2[Ja] || a2["@@iterator"]; + return "function" === typeof a2 ? a2 : null; } -var A = Object.assign, La; -function Ma(a) { +var A$1 = Object.assign, La; +function Ma(a2) { if (void 0 === La) try { throw Error(); - } catch (c) { - var b2 = c.stack.trim().match(/\n( *(at )?)/); + } catch (c2) { + var b2 = c2.stack.trim().match(/\n( *(at )?)/); La = b2 && b2[1] || ""; } - return "\n" + La + a; + return "\n" + La + a2; } var Na = false; -function Oa(a, b2) { - if (!a || Na) +function Oa(a2, b2) { + if (!a2 || Na) return ""; Na = true; - var c = Error.prepareStackTrace; + var c2 = Error.prepareStackTrace; Error.prepareStackTrace = void 0; try { if (b2) @@ -872,52 +891,52 @@ function Oa(a, b2) { try { Reflect.construct(b2, []); } catch (l2) { - var d = l2; + var d2 = l2; } - Reflect.construct(a, [], b2); + Reflect.construct(a2, [], b2); } else { try { b2.call(); } catch (l2) { - d = l2; + d2 = l2; } - a.call(b2.prototype); + a2.call(b2.prototype); } else { try { throw Error(); } catch (l2) { - d = l2; + d2 = l2; } - a(); + a2(); } } catch (l2) { - if (l2 && d && "string" === typeof l2.stack) { - for (var e2 = l2.stack.split("\n"), f2 = d.stack.split("\n"), g = e2.length - 1, h2 = f2.length - 1; 1 <= g && 0 <= h2 && e2[g] !== f2[h2]; ) + if (l2 && d2 && "string" === typeof l2.stack) { + for (var e18 = l2.stack.split("\n"), f2 = d2.stack.split("\n"), g2 = e18.length - 1, h2 = f2.length - 1; 1 <= g2 && 0 <= h2 && e18[g2] !== f2[h2]; ) h2--; - for (; 1 <= g && 0 <= h2; g--, h2--) - if (e2[g] !== f2[h2]) { - if (1 !== g || 1 !== h2) { + for (; 1 <= g2 && 0 <= h2; g2--, h2--) + if (e18[g2] !== f2[h2]) { + if (1 !== g2 || 1 !== h2) { do - if (g--, h2--, 0 > h2 || e2[g] !== f2[h2]) { - var k2 = "\n" + e2[g].replace(" at new ", " at "); - a.displayName && k2.includes("") && (k2 = k2.replace("", a.displayName)); + if (g2--, h2--, 0 > h2 || e18[g2] !== f2[h2]) { + var k2 = "\n" + e18[g2].replace(" at new ", " at "); + a2.displayName && k2.includes("") && (k2 = k2.replace("", a2.displayName)); return k2; } - while (1 <= g && 0 <= h2); + while (1 <= g2 && 0 <= h2); } break; } } } finally { - Na = false, Error.prepareStackTrace = c; + Na = false, Error.prepareStackTrace = c2; } - return (a = a ? a.displayName || a.name : "") ? Ma(a) : ""; + return (a2 = a2 ? a2.displayName || a2.name : "") ? Ma(a2) : ""; } -function Pa(a) { - switch (a.tag) { +function Pa(a2) { + switch (a2.tag) { case 5: - return Ma(a.type); + return Ma(a2.type); case 16: return Ma("Lazy"); case 13: @@ -927,23 +946,23 @@ function Pa(a) { case 0: case 2: case 15: - return a = Oa(a.type, false), a; + return a2 = Oa(a2.type, false), a2; case 11: - return a = Oa(a.type.render, false), a; + return a2 = Oa(a2.type.render, false), a2; case 1: - return a = Oa(a.type, true), a; + return a2 = Oa(a2.type, true), a2; default: return ""; } } -function Qa(a) { - if (null == a) +function Qa(a2) { + if (null == a2) return null; - if ("function" === typeof a) - return a.displayName || a.name || null; - if ("string" === typeof a) - return a; - switch (a) { + if ("function" === typeof a2) + return a2.displayName || a2.name || null; + if ("string" === typeof a2) + return a2; + switch (a2) { case ya: return "Fragment"; case wa: @@ -957,32 +976,32 @@ function Qa(a) { case Fa: return "SuspenseList"; } - if ("object" === typeof a) - switch (a.$$typeof) { + if ("object" === typeof a2) + switch (a2.$$typeof) { case Ca: - return (a.displayName || "Context") + ".Consumer"; + return (a2.displayName || "Context") + ".Consumer"; case Ba: - return (a._context.displayName || "Context") + ".Provider"; + return (a2._context.displayName || "Context") + ".Provider"; case Da: - var b2 = a.render; - a = a.displayName; - a || (a = b2.displayName || b2.name || "", a = "" !== a ? "ForwardRef(" + a + ")" : "ForwardRef"); - return a; + var b2 = a2.render; + a2 = a2.displayName; + a2 || (a2 = b2.displayName || b2.name || "", a2 = "" !== a2 ? "ForwardRef(" + a2 + ")" : "ForwardRef"); + return a2; case Ga: - return b2 = a.displayName || null, null !== b2 ? b2 : Qa(a.type) || "Memo"; + return b2 = a2.displayName || null, null !== b2 ? b2 : Qa(a2.type) || "Memo"; case Ha: - b2 = a._payload; - a = a._init; + b2 = a2._payload; + a2 = a2._init; try { - return Qa(a(b2)); - } catch (c) { + return Qa(a2(b2)); + } catch (c2) { } } return null; } -function Ra(a) { - var b2 = a.type; - switch (a.tag) { +function Ra(a2) { + var b2 = a2.type; + switch (a2.tag) { case 24: return "Cache"; case 9: @@ -992,7 +1011,7 @@ function Ra(a) { case 18: return "DehydratedFragment"; case 11: - return a = b2.render, a = a.displayName || a.name || "", b2.displayName || ("" !== a ? "ForwardRef(" + a + ")" : "ForwardRef"); + return a2 = b2.render, a2 = a2.displayName || a2.name || "", b2.displayName || ("" !== a2 ? "ForwardRef(" + a2 + ")" : "ForwardRef"); case 7: return "Fragment"; case 5: @@ -1032,175 +1051,175 @@ function Ra(a) { } return null; } -function Sa(a) { - switch (typeof a) { +function Sa(a2) { + switch (typeof a2) { case "boolean": case "number": case "string": case "undefined": - return a; + return a2; case "object": - return a; + return a2; default: return ""; } } -function Ta(a) { - var b2 = a.type; - return (a = a.nodeName) && "input" === a.toLowerCase() && ("checkbox" === b2 || "radio" === b2); +function Ta(a2) { + var b2 = a2.type; + return (a2 = a2.nodeName) && "input" === a2.toLowerCase() && ("checkbox" === b2 || "radio" === b2); } -function Ua(a) { - var b2 = Ta(a) ? "checked" : "value", c = Object.getOwnPropertyDescriptor(a.constructor.prototype, b2), d = "" + a[b2]; - if (!a.hasOwnProperty(b2) && "undefined" !== typeof c && "function" === typeof c.get && "function" === typeof c.set) { - var e2 = c.get, f2 = c.set; - Object.defineProperty(a, b2, { configurable: true, get: function() { - return e2.call(this); - }, set: function(a2) { - d = "" + a2; - f2.call(this, a2); +function Ua(a2) { + var b2 = Ta(a2) ? "checked" : "value", c2 = Object.getOwnPropertyDescriptor(a2.constructor.prototype, b2), d2 = "" + a2[b2]; + if (!a2.hasOwnProperty(b2) && "undefined" !== typeof c2 && "function" === typeof c2.get && "function" === typeof c2.set) { + var e18 = c2.get, f2 = c2.set; + Object.defineProperty(a2, b2, { configurable: true, get: function() { + return e18.call(this); + }, set: function(a3) { + d2 = "" + a3; + f2.call(this, a3); } }); - Object.defineProperty(a, b2, { enumerable: c.enumerable }); + Object.defineProperty(a2, b2, { enumerable: c2.enumerable }); return { getValue: function() { - return d; - }, setValue: function(a2) { - d = "" + a2; + return d2; + }, setValue: function(a3) { + d2 = "" + a3; }, stopTracking: function() { - a._valueTracker = null; - delete a[b2]; + a2._valueTracker = null; + delete a2[b2]; } }; } } -function Va(a) { - a._valueTracker || (a._valueTracker = Ua(a)); +function Va(a2) { + a2._valueTracker || (a2._valueTracker = Ua(a2)); } -function Wa(a) { - if (!a) +function Wa(a2) { + if (!a2) return false; - var b2 = a._valueTracker; + var b2 = a2._valueTracker; if (!b2) return true; - var c = b2.getValue(); - var d = ""; - a && (d = Ta(a) ? a.checked ? "true" : "false" : a.value); - a = d; - return a !== c ? (b2.setValue(a), true) : false; -} -function Xa(a) { - a = a || ("undefined" !== typeof document ? document : void 0); - if ("undefined" === typeof a) + var c2 = b2.getValue(); + var d2 = ""; + a2 && (d2 = Ta(a2) ? a2.checked ? "true" : "false" : a2.value); + a2 = d2; + return a2 !== c2 ? (b2.setValue(a2), true) : false; +} +function Xa(a2) { + a2 = a2 || ("undefined" !== typeof document ? document : void 0); + if ("undefined" === typeof a2) return null; try { - return a.activeElement || a.body; + return a2.activeElement || a2.body; } catch (b2) { - return a.body; + return a2.body; } } -function Ya(a, b2) { - var c = b2.checked; - return A({}, b2, { defaultChecked: void 0, defaultValue: void 0, value: void 0, checked: null != c ? c : a._wrapperState.initialChecked }); +function Ya(a2, b2) { + var c2 = b2.checked; + return A$1({}, b2, { defaultChecked: void 0, defaultValue: void 0, value: void 0, checked: null != c2 ? c2 : a2._wrapperState.initialChecked }); } -function Za(a, b2) { - var c = null == b2.defaultValue ? "" : b2.defaultValue, d = null != b2.checked ? b2.checked : b2.defaultChecked; - c = Sa(null != b2.value ? b2.value : c); - a._wrapperState = { initialChecked: d, initialValue: c, controlled: "checkbox" === b2.type || "radio" === b2.type ? null != b2.checked : null != b2.value }; +function Za(a2, b2) { + var c2 = null == b2.defaultValue ? "" : b2.defaultValue, d2 = null != b2.checked ? b2.checked : b2.defaultChecked; + c2 = Sa(null != b2.value ? b2.value : c2); + a2._wrapperState = { initialChecked: d2, initialValue: c2, controlled: "checkbox" === b2.type || "radio" === b2.type ? null != b2.checked : null != b2.value }; } -function ab(a, b2) { +function ab(a2, b2) { b2 = b2.checked; - null != b2 && ta(a, "checked", b2, false); -} -function bb(a, b2) { - ab(a, b2); - var c = Sa(b2.value), d = b2.type; - if (null != c) - if ("number" === d) { - if (0 === c && "" === a.value || a.value != c) - a.value = "" + c; + null != b2 && ta(a2, "checked", b2, false); +} +function bb(a2, b2) { + ab(a2, b2); + var c2 = Sa(b2.value), d2 = b2.type; + if (null != c2) + if ("number" === d2) { + if (0 === c2 && "" === a2.value || a2.value != c2) + a2.value = "" + c2; } else - a.value !== "" + c && (a.value = "" + c); - else if ("submit" === d || "reset" === d) { - a.removeAttribute("value"); + a2.value !== "" + c2 && (a2.value = "" + c2); + else if ("submit" === d2 || "reset" === d2) { + a2.removeAttribute("value"); return; } - b2.hasOwnProperty("value") ? cb(a, b2.type, c) : b2.hasOwnProperty("defaultValue") && cb(a, b2.type, Sa(b2.defaultValue)); - null == b2.checked && null != b2.defaultChecked && (a.defaultChecked = !!b2.defaultChecked); + b2.hasOwnProperty("value") ? cb(a2, b2.type, c2) : b2.hasOwnProperty("defaultValue") && cb(a2, b2.type, Sa(b2.defaultValue)); + null == b2.checked && null != b2.defaultChecked && (a2.defaultChecked = !!b2.defaultChecked); } -function db(a, b2, c) { +function db(a2, b2, c2) { if (b2.hasOwnProperty("value") || b2.hasOwnProperty("defaultValue")) { - var d = b2.type; - if (!("submit" !== d && "reset" !== d || void 0 !== b2.value && null !== b2.value)) + var d2 = b2.type; + if (!("submit" !== d2 && "reset" !== d2 || void 0 !== b2.value && null !== b2.value)) return; - b2 = "" + a._wrapperState.initialValue; - c || b2 === a.value || (a.value = b2); - a.defaultValue = b2; - } - c = a.name; - "" !== c && (a.name = ""); - a.defaultChecked = !!a._wrapperState.initialChecked; - "" !== c && (a.name = c); -} -function cb(a, b2, c) { - if ("number" !== b2 || Xa(a.ownerDocument) !== a) - null == c ? a.defaultValue = "" + a._wrapperState.initialValue : a.defaultValue !== "" + c && (a.defaultValue = "" + c); -} -var eb = Array.isArray; -function fb(a, b2, c, d) { - a = a.options; + b2 = "" + a2._wrapperState.initialValue; + c2 || b2 === a2.value || (a2.value = b2); + a2.defaultValue = b2; + } + c2 = a2.name; + "" !== c2 && (a2.name = ""); + a2.defaultChecked = !!a2._wrapperState.initialChecked; + "" !== c2 && (a2.name = c2); +} +function cb(a2, b2, c2) { + if ("number" !== b2 || Xa(a2.ownerDocument) !== a2) + null == c2 ? a2.defaultValue = "" + a2._wrapperState.initialValue : a2.defaultValue !== "" + c2 && (a2.defaultValue = "" + c2); +} +var eb$1 = Array.isArray; +function fb(a2, b2, c2, d2) { + a2 = a2.options; if (b2) { b2 = {}; - for (var e2 = 0; e2 < c.length; e2++) - b2["$" + c[e2]] = true; - for (c = 0; c < a.length; c++) - e2 = b2.hasOwnProperty("$" + a[c].value), a[c].selected !== e2 && (a[c].selected = e2), e2 && d && (a[c].defaultSelected = true); + for (var e18 = 0; e18 < c2.length; e18++) + b2["$" + c2[e18]] = true; + for (c2 = 0; c2 < a2.length; c2++) + e18 = b2.hasOwnProperty("$" + a2[c2].value), a2[c2].selected !== e18 && (a2[c2].selected = e18), e18 && d2 && (a2[c2].defaultSelected = true); } else { - c = "" + Sa(c); + c2 = "" + Sa(c2); b2 = null; - for (e2 = 0; e2 < a.length; e2++) { - if (a[e2].value === c) { - a[e2].selected = true; - d && (a[e2].defaultSelected = true); + for (e18 = 0; e18 < a2.length; e18++) { + if (a2[e18].value === c2) { + a2[e18].selected = true; + d2 && (a2[e18].defaultSelected = true); return; } - null !== b2 || a[e2].disabled || (b2 = a[e2]); + null !== b2 || a2[e18].disabled || (b2 = a2[e18]); } null !== b2 && (b2.selected = true); } } -function gb(a, b2) { +function gb(a2, b2) { if (null != b2.dangerouslySetInnerHTML) - throw Error(p$2(91)); - return A({}, b2, { value: void 0, defaultValue: void 0, children: "" + a._wrapperState.initialValue }); + throw Error(p$3(91)); + return A$1({}, b2, { value: void 0, defaultValue: void 0, children: "" + a2._wrapperState.initialValue }); } -function hb(a, b2) { - var c = b2.value; - if (null == c) { - c = b2.children; +function hb(a2, b2) { + var c2 = b2.value; + if (null == c2) { + c2 = b2.children; b2 = b2.defaultValue; - if (null != c) { + if (null != c2) { if (null != b2) - throw Error(p$2(92)); - if (eb(c)) { - if (1 < c.length) - throw Error(p$2(93)); - c = c[0]; + throw Error(p$3(92)); + if (eb$1(c2)) { + if (1 < c2.length) + throw Error(p$3(93)); + c2 = c2[0]; } - b2 = c; + b2 = c2; } null == b2 && (b2 = ""); - c = b2; + c2 = b2; } - a._wrapperState = { initialValue: Sa(c) }; + a2._wrapperState = { initialValue: Sa(c2) }; } -function ib(a, b2) { - var c = Sa(b2.value), d = Sa(b2.defaultValue); - null != c && (c = "" + c, c !== a.value && (a.value = c), null == b2.defaultValue && a.defaultValue !== c && (a.defaultValue = c)); - null != d && (a.defaultValue = "" + d); +function ib(a2, b2) { + var c2 = Sa(b2.value), d2 = Sa(b2.defaultValue); + null != c2 && (c2 = "" + c2, c2 !== a2.value && (a2.value = c2), null == b2.defaultValue && a2.defaultValue !== c2 && (a2.defaultValue = c2)); + null != d2 && (a2.defaultValue = "" + d2); } -function jb(a) { - var b2 = a.textContent; - b2 === a._wrapperState.initialValue && "" !== b2 && null !== b2 && (a.value = b2); +function jb(a2) { + var b2 = a2.textContent; + b2 === a2._wrapperState.initialValue && "" !== b2 && null !== b2 && (a2.value = b2); } -function kb(a) { - switch (a) { +function kb(a2) { + switch (a2) { case "svg": return "http://www.w3.org/2000/svg"; case "math": @@ -1209,36 +1228,36 @@ function kb(a) { return "http://www.w3.org/1999/xhtml"; } } -function lb(a, b2) { - return null == a || "http://www.w3.org/1999/xhtml" === a ? kb(b2) : "http://www.w3.org/2000/svg" === a && "foreignObject" === b2 ? "http://www.w3.org/1999/xhtml" : a; +function lb(a2, b2) { + return null == a2 || "http://www.w3.org/1999/xhtml" === a2 ? kb(b2) : "http://www.w3.org/2000/svg" === a2 && "foreignObject" === b2 ? "http://www.w3.org/1999/xhtml" : a2; } -var mb, nb = function(a) { - return "undefined" !== typeof MSApp && MSApp.execUnsafeLocalFunction ? function(b2, c, d, e2) { +var mb, nb = function(a2) { + return "undefined" !== typeof MSApp && MSApp.execUnsafeLocalFunction ? function(b2, c2, d2, e18) { MSApp.execUnsafeLocalFunction(function() { - return a(b2, c, d, e2); + return a2(b2, c2, d2, e18); }); - } : a; -}(function(a, b2) { - if ("http://www.w3.org/2000/svg" !== a.namespaceURI || "innerHTML" in a) - a.innerHTML = b2; + } : a2; +}(function(a2, b2) { + if ("http://www.w3.org/2000/svg" !== a2.namespaceURI || "innerHTML" in a2) + a2.innerHTML = b2; else { mb = mb || document.createElement("div"); mb.innerHTML = "" + b2.valueOf().toString() + ""; - for (b2 = mb.firstChild; a.firstChild; ) - a.removeChild(a.firstChild); + for (b2 = mb.firstChild; a2.firstChild; ) + a2.removeChild(a2.firstChild); for (; b2.firstChild; ) - a.appendChild(b2.firstChild); + a2.appendChild(b2.firstChild); } }); -function ob(a, b2) { +function ob(a2, b2) { if (b2) { - var c = a.firstChild; - if (c && c === a.lastChild && 3 === c.nodeType) { - c.nodeValue = b2; + var c2 = a2.firstChild; + if (c2 && c2 === a2.lastChild && 3 === c2.nodeType) { + c2.nodeValue = b2; return; } } - a.textContent = b2; + a2.textContent = b2; } var pb = { animationIterationCount: true, @@ -1285,43 +1304,43 @@ var pb = { strokeOpacity: true, strokeWidth: true }, qb = ["Webkit", "ms", "Moz", "O"]; -Object.keys(pb).forEach(function(a) { +Object.keys(pb).forEach(function(a2) { qb.forEach(function(b2) { - b2 = b2 + a.charAt(0).toUpperCase() + a.substring(1); - pb[b2] = pb[a]; + b2 = b2 + a2.charAt(0).toUpperCase() + a2.substring(1); + pb[b2] = pb[a2]; }); }); -function rb(a, b2, c) { - return null == b2 || "boolean" === typeof b2 || "" === b2 ? "" : c || "number" !== typeof b2 || 0 === b2 || pb.hasOwnProperty(a) && pb[a] ? ("" + b2).trim() : b2 + "px"; +function rb$1(a2, b2, c2) { + return null == b2 || "boolean" === typeof b2 || "" === b2 ? "" : c2 || "number" !== typeof b2 || 0 === b2 || pb.hasOwnProperty(a2) && pb[a2] ? ("" + b2).trim() : b2 + "px"; } -function sb(a, b2) { - a = a.style; - for (var c in b2) - if (b2.hasOwnProperty(c)) { - var d = 0 === c.indexOf("--"), e2 = rb(c, b2[c], d); - "float" === c && (c = "cssFloat"); - d ? a.setProperty(c, e2) : a[c] = e2; +function sb(a2, b2) { + a2 = a2.style; + for (var c2 in b2) + if (b2.hasOwnProperty(c2)) { + var d2 = 0 === c2.indexOf("--"), e18 = rb$1(c2, b2[c2], d2); + "float" === c2 && (c2 = "cssFloat"); + d2 ? a2.setProperty(c2, e18) : a2[c2] = e18; } } -var tb = A({ menuitem: true }, { area: true, base: true, br: true, col: true, embed: true, hr: true, img: true, input: true, keygen: true, link: true, meta: true, param: true, source: true, track: true, wbr: true }); -function ub(a, b2) { +var tb = A$1({ menuitem: true }, { area: true, base: true, br: true, col: true, embed: true, hr: true, img: true, input: true, keygen: true, link: true, meta: true, param: true, source: true, track: true, wbr: true }); +function ub(a2, b2) { if (b2) { - if (tb[a] && (null != b2.children || null != b2.dangerouslySetInnerHTML)) - throw Error(p$2(137, a)); + if (tb[a2] && (null != b2.children || null != b2.dangerouslySetInnerHTML)) + throw Error(p$3(137, a2)); if (null != b2.dangerouslySetInnerHTML) { if (null != b2.children) - throw Error(p$2(60)); + throw Error(p$3(60)); if ("object" !== typeof b2.dangerouslySetInnerHTML || !("__html" in b2.dangerouslySetInnerHTML)) - throw Error(p$2(61)); + throw Error(p$3(61)); } if (null != b2.style && "object" !== typeof b2.style) - throw Error(p$2(62)); + throw Error(p$3(62)); } } -function vb(a, b2) { - if (-1 === a.indexOf("-")) +function vb(a2, b2) { + if (-1 === a2.indexOf("-")) return "string" === typeof b2.is; - switch (a) { + switch (a2) { case "annotation-xml": case "color-profile": case "font-face": @@ -1336,58 +1355,58 @@ function vb(a, b2) { } } var wb = null; -function xb(a) { - a = a.target || a.srcElement || window; - a.correspondingUseElement && (a = a.correspondingUseElement); - return 3 === a.nodeType ? a.parentNode : a; +function xb(a2) { + a2 = a2.target || a2.srcElement || window; + a2.correspondingUseElement && (a2 = a2.correspondingUseElement); + return 3 === a2.nodeType ? a2.parentNode : a2; } var yb = null, zb = null, Ab = null; -function Bb(a) { - if (a = Cb(a)) { +function Bb(a2) { + if (a2 = Cb(a2)) { if ("function" !== typeof yb) - throw Error(p$2(280)); - var b2 = a.stateNode; - b2 && (b2 = Db(b2), yb(a.stateNode, a.type, b2)); + throw Error(p$3(280)); + var b2 = a2.stateNode; + b2 && (b2 = Db(b2), yb(a2.stateNode, a2.type, b2)); } } -function Eb(a) { - zb ? Ab ? Ab.push(a) : Ab = [a] : zb = a; +function Eb(a2) { + zb ? Ab ? Ab.push(a2) : Ab = [a2] : zb = a2; } function Fb() { if (zb) { - var a = zb, b2 = Ab; + var a2 = zb, b2 = Ab; Ab = zb = null; - Bb(a); + Bb(a2); if (b2) - for (a = 0; a < b2.length; a++) - Bb(b2[a]); + for (a2 = 0; a2 < b2.length; a2++) + Bb(b2[a2]); } } -function Gb(a, b2) { - return a(b2); +function Gb(a2, b2) { + return a2(b2); } function Hb() { } var Ib = false; -function Jb(a, b2, c) { +function Jb(a2, b2, c2) { if (Ib) - return a(b2, c); + return a2(b2, c2); Ib = true; try { - return Gb(a, b2, c); + return Gb(a2, b2, c2); } finally { if (Ib = false, null !== zb || null !== Ab) Hb(), Fb(); } } -function Kb(a, b2) { - var c = a.stateNode; - if (null === c) +function Kb(a2, b2) { + var c2 = a2.stateNode; + if (null === c2) return null; - var d = Db(c); - if (null === d) + var d2 = Db(c2); + if (null === d2) return null; - c = d[b2]; + c2 = d2[b2]; a: switch (b2) { case "onClick": @@ -1401,17 +1420,17 @@ function Kb(a, b2) { case "onMouseUp": case "onMouseUpCapture": case "onMouseEnter": - (d = !d.disabled) || (a = a.type, d = !("button" === a || "input" === a || "select" === a || "textarea" === a)); - a = !d; + (d2 = !d2.disabled) || (a2 = a2.type, d2 = !("button" === a2 || "input" === a2 || "select" === a2 || "textarea" === a2)); + a2 = !d2; break a; default: - a = false; + a2 = false; } - if (a) + if (a2) return null; - if (c && "function" !== typeof c) - throw Error(p$2(231, b2, typeof c)); - return c; + if (c2 && "function" !== typeof c2) + throw Error(p$3(231, b2, typeof c2)); + return c2; } var Lb = false; if (ia) @@ -1422,27 +1441,27 @@ if (ia) } }); window.addEventListener("test", Mb, Mb); window.removeEventListener("test", Mb, Mb); - } catch (a) { + } catch (a2) { Lb = false; } -function Nb(a, b2, c, d, e2, f2, g, h2, k2) { +function Nb(a2, b2, c2, d2, e18, f2, g2, h2, k2) { var l2 = Array.prototype.slice.call(arguments, 3); try { - b2.apply(c, l2); + b2.apply(c2, l2); } catch (m2) { this.onError(m2); } } -var Ob = false, Pb = null, Qb = false, Rb = null, Sb = { onError: function(a) { +var Ob = false, Pb = null, Qb = false, Rb = null, Sb = { onError: function(a2) { Ob = true; - Pb = a; + Pb = a2; } }; -function Tb(a, b2, c, d, e2, f2, g, h2, k2) { +function Tb(a2, b2, c2, d2, e18, f2, g2, h2, k2) { Ob = false; Pb = null; Nb.apply(Sb, arguments); } -function Ub(a, b2, c, d, e2, f2, g, h2, k2) { +function Ub(a2, b2, c2, d2, e18, f2, g2, h2, k2) { Tb.apply(this, arguments); if (Ob) { if (Ob) { @@ -1450,143 +1469,143 @@ function Ub(a, b2, c, d, e2, f2, g, h2, k2) { Ob = false; Pb = null; } else - throw Error(p$2(198)); + throw Error(p$3(198)); Qb || (Qb = true, Rb = l2); } } -function Vb(a) { - var b2 = a, c = a; - if (a.alternate) +function Vb(a2) { + var b2 = a2, c2 = a2; + if (a2.alternate) for (; b2.return; ) b2 = b2.return; else { - a = b2; + a2 = b2; do - b2 = a, 0 !== (b2.flags & 4098) && (c = b2.return), a = b2.return; - while (a); + b2 = a2, 0 !== (b2.flags & 4098) && (c2 = b2.return), a2 = b2.return; + while (a2); } - return 3 === b2.tag ? c : null; + return 3 === b2.tag ? c2 : null; } -function Wb(a) { - if (13 === a.tag) { - var b2 = a.memoizedState; - null === b2 && (a = a.alternate, null !== a && (b2 = a.memoizedState)); +function Wb(a2) { + if (13 === a2.tag) { + var b2 = a2.memoizedState; + null === b2 && (a2 = a2.alternate, null !== a2 && (b2 = a2.memoizedState)); if (null !== b2) return b2.dehydrated; } return null; } -function Xb(a) { - if (Vb(a) !== a) - throw Error(p$2(188)); +function Xb(a2) { + if (Vb(a2) !== a2) + throw Error(p$3(188)); } -function Yb(a) { - var b2 = a.alternate; +function Yb(a2) { + var b2 = a2.alternate; if (!b2) { - b2 = Vb(a); + b2 = Vb(a2); if (null === b2) - throw Error(p$2(188)); - return b2 !== a ? null : a; + throw Error(p$3(188)); + return b2 !== a2 ? null : a2; } - for (var c = a, d = b2; ; ) { - var e2 = c.return; - if (null === e2) + for (var c2 = a2, d2 = b2; ; ) { + var e18 = c2.return; + if (null === e18) break; - var f2 = e2.alternate; + var f2 = e18.alternate; if (null === f2) { - d = e2.return; - if (null !== d) { - c = d; + d2 = e18.return; + if (null !== d2) { + c2 = d2; continue; } break; } - if (e2.child === f2.child) { - for (f2 = e2.child; f2; ) { - if (f2 === c) - return Xb(e2), a; - if (f2 === d) - return Xb(e2), b2; + if (e18.child === f2.child) { + for (f2 = e18.child; f2; ) { + if (f2 === c2) + return Xb(e18), a2; + if (f2 === d2) + return Xb(e18), b2; f2 = f2.sibling; } - throw Error(p$2(188)); + throw Error(p$3(188)); } - if (c.return !== d.return) - c = e2, d = f2; + if (c2.return !== d2.return) + c2 = e18, d2 = f2; else { - for (var g = false, h2 = e2.child; h2; ) { - if (h2 === c) { - g = true; - c = e2; - d = f2; + for (var g2 = false, h2 = e18.child; h2; ) { + if (h2 === c2) { + g2 = true; + c2 = e18; + d2 = f2; break; } - if (h2 === d) { - g = true; - d = e2; - c = f2; + if (h2 === d2) { + g2 = true; + d2 = e18; + c2 = f2; break; } h2 = h2.sibling; } - if (!g) { + if (!g2) { for (h2 = f2.child; h2; ) { - if (h2 === c) { - g = true; - c = f2; - d = e2; + if (h2 === c2) { + g2 = true; + c2 = f2; + d2 = e18; break; } - if (h2 === d) { - g = true; - d = f2; - c = e2; + if (h2 === d2) { + g2 = true; + d2 = f2; + c2 = e18; break; } h2 = h2.sibling; } - if (!g) - throw Error(p$2(189)); + if (!g2) + throw Error(p$3(189)); } } - if (c.alternate !== d) - throw Error(p$2(190)); + if (c2.alternate !== d2) + throw Error(p$3(190)); } - if (3 !== c.tag) - throw Error(p$2(188)); - return c.stateNode.current === c ? a : b2; + if (3 !== c2.tag) + throw Error(p$3(188)); + return c2.stateNode.current === c2 ? a2 : b2; } -function Zb(a) { - a = Yb(a); - return null !== a ? $b(a) : null; +function Zb(a2) { + a2 = Yb(a2); + return null !== a2 ? $b(a2) : null; } -function $b(a) { - if (5 === a.tag || 6 === a.tag) - return a; - for (a = a.child; null !== a; ) { - var b2 = $b(a); +function $b(a2) { + if (5 === a2.tag || 6 === a2.tag) + return a2; + for (a2 = a2.child; null !== a2; ) { + var b2 = $b(a2); if (null !== b2) return b2; - a = a.sibling; + a2 = a2.sibling; } return null; } -var ac = ca.unstable_scheduleCallback, bc = ca.unstable_cancelCallback, cc = ca.unstable_shouldYield, dc = ca.unstable_requestPaint, B = ca.unstable_now, ec = ca.unstable_getCurrentPriorityLevel, fc = ca.unstable_ImmediatePriority, gc = ca.unstable_UserBlockingPriority, hc = ca.unstable_NormalPriority, ic = ca.unstable_LowPriority, jc = ca.unstable_IdlePriority, kc = null, lc = null; -function mc(a) { +var ac = ca.unstable_scheduleCallback, bc = ca.unstable_cancelCallback, cc = ca.unstable_shouldYield, dc = ca.unstable_requestPaint, B$1 = ca.unstable_now, ec$1 = ca.unstable_getCurrentPriorityLevel, fc = ca.unstable_ImmediatePriority, gc = ca.unstable_UserBlockingPriority, hc = ca.unstable_NormalPriority, ic = ca.unstable_LowPriority, jc = ca.unstable_IdlePriority, kc = null, lc = null; +function mc(a2) { if (lc && "function" === typeof lc.onCommitFiberRoot) try { - lc.onCommitFiberRoot(kc, a, void 0, 128 === (a.current.flags & 128)); + lc.onCommitFiberRoot(kc, a2, void 0, 128 === (a2.current.flags & 128)); } catch (b2) { } } var oc = Math.clz32 ? Math.clz32 : nc, pc = Math.log, qc = Math.LN2; -function nc(a) { - a >>>= 0; - return 0 === a ? 32 : 31 - (pc(a) / qc | 0) | 0; +function nc(a2) { + a2 >>>= 0; + return 0 === a2 ? 32 : 31 - (pc(a2) / qc | 0) | 0; } -var rc = 64, sc = 4194304; -function tc(a) { - switch (a & -a) { +var rc$1 = 64, sc = 4194304; +function tc(a2) { + switch (a2 & -a2) { case 1: return 1; case 2: @@ -1615,13 +1634,13 @@ function tc(a) { case 524288: case 1048576: case 2097152: - return a & 4194240; + return a2 & 4194240; case 4194304: case 8388608: case 16777216: case 33554432: case 67108864: - return a & 130023424; + return a2 & 130023424; case 134217728: return 134217728; case 268435456: @@ -1631,32 +1650,32 @@ function tc(a) { case 1073741824: return 1073741824; default: - return a; + return a2; } } -function uc(a, b2) { - var c = a.pendingLanes; - if (0 === c) +function uc(a2, b2) { + var c2 = a2.pendingLanes; + if (0 === c2) return 0; - var d = 0, e2 = a.suspendedLanes, f2 = a.pingedLanes, g = c & 268435455; - if (0 !== g) { - var h2 = g & ~e2; - 0 !== h2 ? d = tc(h2) : (f2 &= g, 0 !== f2 && (d = tc(f2))); + var d2 = 0, e18 = a2.suspendedLanes, f2 = a2.pingedLanes, g2 = c2 & 268435455; + if (0 !== g2) { + var h2 = g2 & ~e18; + 0 !== h2 ? d2 = tc(h2) : (f2 &= g2, 0 !== f2 && (d2 = tc(f2))); } else - g = c & ~e2, 0 !== g ? d = tc(g) : 0 !== f2 && (d = tc(f2)); - if (0 === d) + g2 = c2 & ~e18, 0 !== g2 ? d2 = tc(g2) : 0 !== f2 && (d2 = tc(f2)); + if (0 === d2) return 0; - if (0 !== b2 && b2 !== d && 0 === (b2 & e2) && (e2 = d & -d, f2 = b2 & -b2, e2 >= f2 || 16 === e2 && 0 !== (f2 & 4194240))) + if (0 !== b2 && b2 !== d2 && 0 === (b2 & e18) && (e18 = d2 & -d2, f2 = b2 & -b2, e18 >= f2 || 16 === e18 && 0 !== (f2 & 4194240))) return b2; - 0 !== (d & 4) && (d |= c & 16); - b2 = a.entangledLanes; + 0 !== (d2 & 4) && (d2 |= c2 & 16); + b2 = a2.entangledLanes; if (0 !== b2) - for (a = a.entanglements, b2 &= d; 0 < b2; ) - c = 31 - oc(b2), e2 = 1 << c, d |= a[c], b2 &= ~e2; - return d; + for (a2 = a2.entanglements, b2 &= d2; 0 < b2; ) + c2 = 31 - oc(b2), e18 = 1 << c2, d2 |= a2[c2], b2 &= ~e18; + return d2; } -function vc(a, b2) { - switch (a) { +function vc(a2, b2) { + switch (a2) { case 1: case 2: case 4: @@ -1696,73 +1715,73 @@ function vc(a, b2) { return -1; } } -function wc(a, b2) { - for (var c = a.suspendedLanes, d = a.pingedLanes, e2 = a.expirationTimes, f2 = a.pendingLanes; 0 < f2; ) { - var g = 31 - oc(f2), h2 = 1 << g, k2 = e2[g]; +function wc(a2, b2) { + for (var c2 = a2.suspendedLanes, d2 = a2.pingedLanes, e18 = a2.expirationTimes, f2 = a2.pendingLanes; 0 < f2; ) { + var g2 = 31 - oc(f2), h2 = 1 << g2, k2 = e18[g2]; if (-1 === k2) { - if (0 === (h2 & c) || 0 !== (h2 & d)) - e2[g] = vc(h2, b2); + if (0 === (h2 & c2) || 0 !== (h2 & d2)) + e18[g2] = vc(h2, b2); } else - k2 <= b2 && (a.expiredLanes |= h2); + k2 <= b2 && (a2.expiredLanes |= h2); f2 &= ~h2; } } -function xc(a) { - a = a.pendingLanes & -1073741825; - return 0 !== a ? a : a & 1073741824 ? 1073741824 : 0; +function xc(a2) { + a2 = a2.pendingLanes & -1073741825; + return 0 !== a2 ? a2 : a2 & 1073741824 ? 1073741824 : 0; } function yc() { - var a = rc; - rc <<= 1; - 0 === (rc & 4194240) && (rc = 64); - return a; -} -function zc(a) { - for (var b2 = [], c = 0; 31 > c; c++) - b2.push(a); + var a2 = rc$1; + rc$1 <<= 1; + 0 === (rc$1 & 4194240) && (rc$1 = 64); + return a2; +} +function zc(a2) { + for (var b2 = [], c2 = 0; 31 > c2; c2++) + b2.push(a2); return b2; } -function Ac(a, b2, c) { - a.pendingLanes |= b2; - 536870912 !== b2 && (a.suspendedLanes = 0, a.pingedLanes = 0); - a = a.eventTimes; +function Ac(a2, b2, c2) { + a2.pendingLanes |= b2; + 536870912 !== b2 && (a2.suspendedLanes = 0, a2.pingedLanes = 0); + a2 = a2.eventTimes; b2 = 31 - oc(b2); - a[b2] = c; -} -function Bc(a, b2) { - var c = a.pendingLanes & ~b2; - a.pendingLanes = b2; - a.suspendedLanes = 0; - a.pingedLanes = 0; - a.expiredLanes &= b2; - a.mutableReadLanes &= b2; - a.entangledLanes &= b2; - b2 = a.entanglements; - var d = a.eventTimes; - for (a = a.expirationTimes; 0 < c; ) { - var e2 = 31 - oc(c), f2 = 1 << e2; - b2[e2] = 0; - d[e2] = -1; - a[e2] = -1; - c &= ~f2; - } -} -function Cc(a, b2) { - var c = a.entangledLanes |= b2; - for (a = a.entanglements; c; ) { - var d = 31 - oc(c), e2 = 1 << d; - e2 & b2 | a[d] & b2 && (a[d] |= b2); - c &= ~e2; - } -} -var C = 0; -function Dc(a) { - a &= -a; - return 1 < a ? 4 < a ? 0 !== (a & 268435455) ? 16 : 536870912 : 4 : 1; + a2[b2] = c2; +} +function Bc(a2, b2) { + var c2 = a2.pendingLanes & ~b2; + a2.pendingLanes = b2; + a2.suspendedLanes = 0; + a2.pingedLanes = 0; + a2.expiredLanes &= b2; + a2.mutableReadLanes &= b2; + a2.entangledLanes &= b2; + b2 = a2.entanglements; + var d2 = a2.eventTimes; + for (a2 = a2.expirationTimes; 0 < c2; ) { + var e18 = 31 - oc(c2), f2 = 1 << e18; + b2[e18] = 0; + d2[e18] = -1; + a2[e18] = -1; + c2 &= ~f2; + } +} +function Cc(a2, b2) { + var c2 = a2.entangledLanes |= b2; + for (a2 = a2.entanglements; c2; ) { + var d2 = 31 - oc(c2), e18 = 1 << d2; + e18 & b2 | a2[d2] & b2 && (a2[d2] |= b2); + c2 &= ~e18; + } +} +var C$1 = 0; +function Dc(a2) { + a2 &= -a2; + return 1 < a2 ? 4 < a2 ? 0 !== (a2 & 268435455) ? 16 : 536870912 : 4 : 1; } var Ec, Fc, Gc, Hc, Ic, Jc = false, Kc = [], Lc = null, Mc = null, Nc = null, Oc = /* @__PURE__ */ new Map(), Pc = /* @__PURE__ */ new Map(), Qc = [], Rc = "mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset submit".split(" "); -function Sc(a, b2) { - switch (a) { +function Sc(a2, b2) { + switch (a2) { case "focusin": case "focusout": Lc = null; @@ -1784,71 +1803,71 @@ function Sc(a, b2) { Pc.delete(b2.pointerId); } } -function Tc(a, b2, c, d, e2, f2) { - if (null === a || a.nativeEvent !== f2) - return a = { blockedOn: b2, domEventName: c, eventSystemFlags: d, nativeEvent: f2, targetContainers: [e2] }, null !== b2 && (b2 = Cb(b2), null !== b2 && Fc(b2)), a; - a.eventSystemFlags |= d; - b2 = a.targetContainers; - null !== e2 && -1 === b2.indexOf(e2) && b2.push(e2); - return a; +function Tc(a2, b2, c2, d2, e18, f2) { + if (null === a2 || a2.nativeEvent !== f2) + return a2 = { blockedOn: b2, domEventName: c2, eventSystemFlags: d2, nativeEvent: f2, targetContainers: [e18] }, null !== b2 && (b2 = Cb(b2), null !== b2 && Fc(b2)), a2; + a2.eventSystemFlags |= d2; + b2 = a2.targetContainers; + null !== e18 && -1 === b2.indexOf(e18) && b2.push(e18); + return a2; } -function Uc(a, b2, c, d, e2) { +function Uc(a2, b2, c2, d2, e18) { switch (b2) { case "focusin": - return Lc = Tc(Lc, a, b2, c, d, e2), true; + return Lc = Tc(Lc, a2, b2, c2, d2, e18), true; case "dragenter": - return Mc = Tc(Mc, a, b2, c, d, e2), true; + return Mc = Tc(Mc, a2, b2, c2, d2, e18), true; case "mouseover": - return Nc = Tc(Nc, a, b2, c, d, e2), true; + return Nc = Tc(Nc, a2, b2, c2, d2, e18), true; case "pointerover": - var f2 = e2.pointerId; - Oc.set(f2, Tc(Oc.get(f2) || null, a, b2, c, d, e2)); + var f2 = e18.pointerId; + Oc.set(f2, Tc(Oc.get(f2) || null, a2, b2, c2, d2, e18)); return true; case "gotpointercapture": - return f2 = e2.pointerId, Pc.set(f2, Tc(Pc.get(f2) || null, a, b2, c, d, e2)), true; + return f2 = e18.pointerId, Pc.set(f2, Tc(Pc.get(f2) || null, a2, b2, c2, d2, e18)), true; } return false; } -function Vc(a) { - var b2 = Wc(a.target); +function Vc(a2) { + var b2 = Wc(a2.target); if (null !== b2) { - var c = Vb(b2); - if (null !== c) { - if (b2 = c.tag, 13 === b2) { - if (b2 = Wb(c), null !== b2) { - a.blockedOn = b2; - Ic(a.priority, function() { - Gc(c); + var c2 = Vb(b2); + if (null !== c2) { + if (b2 = c2.tag, 13 === b2) { + if (b2 = Wb(c2), null !== b2) { + a2.blockedOn = b2; + Ic(a2.priority, function() { + Gc(c2); }); return; } - } else if (3 === b2 && c.stateNode.current.memoizedState.isDehydrated) { - a.blockedOn = 3 === c.tag ? c.stateNode.containerInfo : null; + } else if (3 === b2 && c2.stateNode.current.memoizedState.isDehydrated) { + a2.blockedOn = 3 === c2.tag ? c2.stateNode.containerInfo : null; return; } } } - a.blockedOn = null; + a2.blockedOn = null; } -function Xc(a) { - if (null !== a.blockedOn) +function Xc(a2) { + if (null !== a2.blockedOn) return false; - for (var b2 = a.targetContainers; 0 < b2.length; ) { - var c = Yc(a.domEventName, a.eventSystemFlags, b2[0], a.nativeEvent); - if (null === c) { - c = a.nativeEvent; - var d = new c.constructor(c.type, c); - wb = d; - c.target.dispatchEvent(d); + for (var b2 = a2.targetContainers; 0 < b2.length; ) { + var c2 = Yc(a2.domEventName, a2.eventSystemFlags, b2[0], a2.nativeEvent); + if (null === c2) { + c2 = a2.nativeEvent; + var d2 = new c2.constructor(c2.type, c2); + wb = d2; + c2.target.dispatchEvent(d2); wb = null; } else - return b2 = Cb(c), null !== b2 && Fc(b2), a.blockedOn = c, false; + return b2 = Cb(c2), null !== b2 && Fc(b2), a2.blockedOn = c2, false; b2.shift(); } return true; } -function Zc(a, b2, c) { - Xc(a) && c.delete(b2); +function Zc(a2, b2, c2) { + Xc(a2) && c2.delete(b2); } function $c() { Jc = false; @@ -1858,95 +1877,95 @@ function $c() { Oc.forEach(Zc); Pc.forEach(Zc); } -function ad(a, b2) { - a.blockedOn === b2 && (a.blockedOn = null, Jc || (Jc = true, ca.unstable_scheduleCallback(ca.unstable_NormalPriority, $c))); +function ad(a2, b2) { + a2.blockedOn === b2 && (a2.blockedOn = null, Jc || (Jc = true, ca.unstable_scheduleCallback(ca.unstable_NormalPriority, $c))); } -function bd(a) { +function bd(a2) { function b2(b3) { - return ad(b3, a); + return ad(b3, a2); } if (0 < Kc.length) { - ad(Kc[0], a); - for (var c = 1; c < Kc.length; c++) { - var d = Kc[c]; - d.blockedOn === a && (d.blockedOn = null); + ad(Kc[0], a2); + for (var c2 = 1; c2 < Kc.length; c2++) { + var d2 = Kc[c2]; + d2.blockedOn === a2 && (d2.blockedOn = null); } } - null !== Lc && ad(Lc, a); - null !== Mc && ad(Mc, a); - null !== Nc && ad(Nc, a); + null !== Lc && ad(Lc, a2); + null !== Mc && ad(Mc, a2); + null !== Nc && ad(Nc, a2); Oc.forEach(b2); Pc.forEach(b2); - for (c = 0; c < Qc.length; c++) - d = Qc[c], d.blockedOn === a && (d.blockedOn = null); - for (; 0 < Qc.length && (c = Qc[0], null === c.blockedOn); ) - Vc(c), null === c.blockedOn && Qc.shift(); + for (c2 = 0; c2 < Qc.length; c2++) + d2 = Qc[c2], d2.blockedOn === a2 && (d2.blockedOn = null); + for (; 0 < Qc.length && (c2 = Qc[0], null === c2.blockedOn); ) + Vc(c2), null === c2.blockedOn && Qc.shift(); } var cd = ua.ReactCurrentBatchConfig, dd = true; -function ed(a, b2, c, d) { - var e2 = C, f2 = cd.transition; +function ed$1(a2, b2, c2, d2) { + var e18 = C$1, f2 = cd.transition; cd.transition = null; try { - C = 1, fd(a, b2, c, d); + C$1 = 1, fd(a2, b2, c2, d2); } finally { - C = e2, cd.transition = f2; + C$1 = e18, cd.transition = f2; } } -function gd(a, b2, c, d) { - var e2 = C, f2 = cd.transition; +function gd(a2, b2, c2, d2) { + var e18 = C$1, f2 = cd.transition; cd.transition = null; try { - C = 4, fd(a, b2, c, d); + C$1 = 4, fd(a2, b2, c2, d2); } finally { - C = e2, cd.transition = f2; + C$1 = e18, cd.transition = f2; } } -function fd(a, b2, c, d) { +function fd(a2, b2, c2, d2) { if (dd) { - var e2 = Yc(a, b2, c, d); - if (null === e2) - hd(a, b2, d, id$1, c), Sc(a, d); - else if (Uc(e2, a, b2, c, d)) - d.stopPropagation(); - else if (Sc(a, d), b2 & 4 && -1 < Rc.indexOf(a)) { - for (; null !== e2; ) { - var f2 = Cb(e2); + var e18 = Yc(a2, b2, c2, d2); + if (null === e18) + hd(a2, b2, d2, id$1, c2), Sc(a2, d2); + else if (Uc(e18, a2, b2, c2, d2)) + d2.stopPropagation(); + else if (Sc(a2, d2), b2 & 4 && -1 < Rc.indexOf(a2)) { + for (; null !== e18; ) { + var f2 = Cb(e18); null !== f2 && Ec(f2); - f2 = Yc(a, b2, c, d); - null === f2 && hd(a, b2, d, id$1, c); - if (f2 === e2) + f2 = Yc(a2, b2, c2, d2); + null === f2 && hd(a2, b2, d2, id$1, c2); + if (f2 === e18) break; - e2 = f2; + e18 = f2; } - null !== e2 && d.stopPropagation(); + null !== e18 && d2.stopPropagation(); } else - hd(a, b2, d, null, c); + hd(a2, b2, d2, null, c2); } } var id$1 = null; -function Yc(a, b2, c, d) { +function Yc(a2, b2, c2, d2) { id$1 = null; - a = xb(d); - a = Wc(a); - if (null !== a) - if (b2 = Vb(a), null === b2) - a = null; - else if (c = b2.tag, 13 === c) { - a = Wb(b2); - if (null !== a) - return a; - a = null; - } else if (3 === c) { + a2 = xb(d2); + a2 = Wc(a2); + if (null !== a2) + if (b2 = Vb(a2), null === b2) + a2 = null; + else if (c2 = b2.tag, 13 === c2) { + a2 = Wb(b2); + if (null !== a2) + return a2; + a2 = null; + } else if (3 === c2) { if (b2.stateNode.current.memoizedState.isDehydrated) return 3 === b2.tag ? b2.stateNode.containerInfo : null; - a = null; + a2 = null; } else - b2 !== a && (a = null); - id$1 = a; + b2 !== a2 && (a2 = null); + id$1 = a2; return null; } -function jd(a) { - switch (a) { +function jd(a2) { + switch (a2) { case "cancel": case "click": case "close": @@ -2020,7 +2039,7 @@ function jd(a) { case "pointerleave": return 4; case "message": - switch (ec()) { + switch (ec$1()) { case fc: return 1; case gc: @@ -2041,19 +2060,19 @@ var kd = null, ld = null, md = null; function nd() { if (md) return md; - var a, b2 = ld, c = b2.length, d, e2 = "value" in kd ? kd.value : kd.textContent, f2 = e2.length; - for (a = 0; a < c && b2[a] === e2[a]; a++) + var a2, b2 = ld, c2 = b2.length, d2, e18 = "value" in kd ? kd.value : kd.textContent, f2 = e18.length; + for (a2 = 0; a2 < c2 && b2[a2] === e18[a2]; a2++) ; - var g = c - a; - for (d = 1; d <= g && b2[c - d] === e2[f2 - d]; d++) + var g2 = c2 - a2; + for (d2 = 1; d2 <= g2 && b2[c2 - d2] === e18[f2 - d2]; d2++) ; - return md = e2.slice(a, 1 < d ? 1 - d : void 0); + return md = e18.slice(a2, 1 < d2 ? 1 - d2 : void 0); } -function od(a) { - var b2 = a.keyCode; - "charCode" in a ? (a = a.charCode, 0 === a && 13 === b2 && (a = 13)) : a = b2; - 10 === a && (a = 13); - return 32 <= a || 13 === a ? a : 0; +function od(a2) { + var b2 = a2.keyCode; + "charCode" in a2 ? (a2 = a2.charCode, 0 === a2 && 13 === b2 && (a2 = 13)) : a2 = b2; + 10 === a2 && (a2 = 13); + return 32 <= a2 || 13 === a2 ? a2 : 0; } function pd() { return true; @@ -2061,45 +2080,45 @@ function pd() { function qd() { return false; } -function rd(a) { - function b2(b3, d, e2, f2, g) { +function rd$1(a2) { + function b2(b3, d2, e18, f2, g2) { this._reactName = b3; - this._targetInst = e2; - this.type = d; + this._targetInst = e18; + this.type = d2; this.nativeEvent = f2; - this.target = g; + this.target = g2; this.currentTarget = null; - for (var c in a) - a.hasOwnProperty(c) && (b3 = a[c], this[c] = b3 ? b3(f2) : f2[c]); + for (var c2 in a2) + a2.hasOwnProperty(c2) && (b3 = a2[c2], this[c2] = b3 ? b3(f2) : f2[c2]); this.isDefaultPrevented = (null != f2.defaultPrevented ? f2.defaultPrevented : false === f2.returnValue) ? pd : qd; this.isPropagationStopped = qd; return this; } - A(b2.prototype, { preventDefault: function() { + A$1(b2.prototype, { preventDefault: function() { this.defaultPrevented = true; - var a2 = this.nativeEvent; - a2 && (a2.preventDefault ? a2.preventDefault() : "unknown" !== typeof a2.returnValue && (a2.returnValue = false), this.isDefaultPrevented = pd); + var a3 = this.nativeEvent; + a3 && (a3.preventDefault ? a3.preventDefault() : "unknown" !== typeof a3.returnValue && (a3.returnValue = false), this.isDefaultPrevented = pd); }, stopPropagation: function() { - var a2 = this.nativeEvent; - a2 && (a2.stopPropagation ? a2.stopPropagation() : "unknown" !== typeof a2.cancelBubble && (a2.cancelBubble = true), this.isPropagationStopped = pd); + var a3 = this.nativeEvent; + a3 && (a3.stopPropagation ? a3.stopPropagation() : "unknown" !== typeof a3.cancelBubble && (a3.cancelBubble = true), this.isPropagationStopped = pd); }, persist: function() { }, isPersistent: pd }); return b2; } -var sd = { eventPhase: 0, bubbles: 0, cancelable: 0, timeStamp: function(a) { - return a.timeStamp || Date.now(); -}, defaultPrevented: 0, isTrusted: 0 }, td = rd(sd), ud = A({}, sd, { view: 0, detail: 0 }), vd = rd(ud), wd, xd, yd, Ad = A({}, ud, { screenX: 0, screenY: 0, clientX: 0, clientY: 0, pageX: 0, pageY: 0, ctrlKey: 0, shiftKey: 0, altKey: 0, metaKey: 0, getModifierState: zd, button: 0, buttons: 0, relatedTarget: function(a) { - return void 0 === a.relatedTarget ? a.fromElement === a.srcElement ? a.toElement : a.fromElement : a.relatedTarget; -}, movementX: function(a) { - if ("movementX" in a) - return a.movementX; - a !== yd && (yd && "mousemove" === a.type ? (wd = a.screenX - yd.screenX, xd = a.screenY - yd.screenY) : xd = wd = 0, yd = a); +var sd = { eventPhase: 0, bubbles: 0, cancelable: 0, timeStamp: function(a2) { + return a2.timeStamp || Date.now(); +}, defaultPrevented: 0, isTrusted: 0 }, td = rd$1(sd), ud = A$1({}, sd, { view: 0, detail: 0 }), vd = rd$1(ud), wd, xd, yd, Ad = A$1({}, ud, { screenX: 0, screenY: 0, clientX: 0, clientY: 0, pageX: 0, pageY: 0, ctrlKey: 0, shiftKey: 0, altKey: 0, metaKey: 0, getModifierState: zd, button: 0, buttons: 0, relatedTarget: function(a2) { + return void 0 === a2.relatedTarget ? a2.fromElement === a2.srcElement ? a2.toElement : a2.fromElement : a2.relatedTarget; +}, movementX: function(a2) { + if ("movementX" in a2) + return a2.movementX; + a2 !== yd && (yd && "mousemove" === a2.type ? (wd = a2.screenX - yd.screenX, xd = a2.screenY - yd.screenY) : xd = wd = 0, yd = a2); return wd; -}, movementY: function(a) { - return "movementY" in a ? a.movementY : xd; -} }), Bd = rd(Ad), Cd = A({}, Ad, { dataTransfer: 0 }), Dd = rd(Cd), Ed = A({}, ud, { relatedTarget: 0 }), Fd = rd(Ed), Gd = A({}, sd, { animationName: 0, elapsedTime: 0, pseudoElement: 0 }), Hd = rd(Gd), Id$1 = A({}, sd, { clipboardData: function(a) { - return "clipboardData" in a ? a.clipboardData : window.clipboardData; -} }), Jd = rd(Id$1), Kd = A({}, sd, { data: 0 }), Ld = rd(Kd), Md = { +}, movementY: function(a2) { + return "movementY" in a2 ? a2.movementY : xd; +} }), Bd = rd$1(Ad), Cd = A$1({}, Ad, { dataTransfer: 0 }), Dd = rd$1(Cd), Ed = A$1({}, ud, { relatedTarget: 0 }), Fd = rd$1(Ed), Gd = A$1({}, sd, { animationName: 0, elapsedTime: 0, pseudoElement: 0 }), Hd = rd$1(Gd), Id$1 = A$1({}, sd, { clipboardData: function(a2) { + return "clipboardData" in a2 ? a2.clipboardData : window.clipboardData; +} }), Jd = rd$1(Id$1), Kd = A$1({}, sd, { data: 0 }), Ld = rd$1(Kd), Md = { Esc: "Escape", Spacebar: " ", Left: "ArrowLeft", @@ -2150,40 +2169,40 @@ var sd = { eventPhase: 0, bubbles: 0, cancelable: 0, timeStamp: function(a) { 145: "ScrollLock", 224: "Meta" }, Od = { Alt: "altKey", Control: "ctrlKey", Meta: "metaKey", Shift: "shiftKey" }; -function Pd(a) { +function Pd(a2) { var b2 = this.nativeEvent; - return b2.getModifierState ? b2.getModifierState(a) : (a = Od[a]) ? !!b2[a] : false; + return b2.getModifierState ? b2.getModifierState(a2) : (a2 = Od[a2]) ? !!b2[a2] : false; } function zd() { return Pd; } -var Qd = A({}, ud, { key: function(a) { - if (a.key) { - var b2 = Md[a.key] || a.key; +var Qd = A$1({}, ud, { key: function(a2) { + if (a2.key) { + var b2 = Md[a2.key] || a2.key; if ("Unidentified" !== b2) return b2; } - return "keypress" === a.type ? (a = od(a), 13 === a ? "Enter" : String.fromCharCode(a)) : "keydown" === a.type || "keyup" === a.type ? Nd[a.keyCode] || "Unidentified" : ""; -}, code: 0, location: 0, ctrlKey: 0, shiftKey: 0, altKey: 0, metaKey: 0, repeat: 0, locale: 0, getModifierState: zd, charCode: function(a) { - return "keypress" === a.type ? od(a) : 0; -}, keyCode: function(a) { - return "keydown" === a.type || "keyup" === a.type ? a.keyCode : 0; -}, which: function(a) { - return "keypress" === a.type ? od(a) : "keydown" === a.type || "keyup" === a.type ? a.keyCode : 0; -} }), Rd = rd(Qd), Sd = A({}, Ad, { pointerId: 0, width: 0, height: 0, pressure: 0, tangentialPressure: 0, tiltX: 0, tiltY: 0, twist: 0, pointerType: 0, isPrimary: 0 }), Td = rd(Sd), Ud = A({}, ud, { touches: 0, targetTouches: 0, changedTouches: 0, altKey: 0, metaKey: 0, ctrlKey: 0, shiftKey: 0, getModifierState: zd }), Vd = rd(Ud), Wd = A({}, sd, { propertyName: 0, elapsedTime: 0, pseudoElement: 0 }), Xd = rd(Wd), Yd = A({}, Ad, { - deltaX: function(a) { - return "deltaX" in a ? a.deltaX : "wheelDeltaX" in a ? -a.wheelDeltaX : 0; + return "keypress" === a2.type ? (a2 = od(a2), 13 === a2 ? "Enter" : String.fromCharCode(a2)) : "keydown" === a2.type || "keyup" === a2.type ? Nd[a2.keyCode] || "Unidentified" : ""; +}, code: 0, location: 0, ctrlKey: 0, shiftKey: 0, altKey: 0, metaKey: 0, repeat: 0, locale: 0, getModifierState: zd, charCode: function(a2) { + return "keypress" === a2.type ? od(a2) : 0; +}, keyCode: function(a2) { + return "keydown" === a2.type || "keyup" === a2.type ? a2.keyCode : 0; +}, which: function(a2) { + return "keypress" === a2.type ? od(a2) : "keydown" === a2.type || "keyup" === a2.type ? a2.keyCode : 0; +} }), Rd = rd$1(Qd), Sd = A$1({}, Ad, { pointerId: 0, width: 0, height: 0, pressure: 0, tangentialPressure: 0, tiltX: 0, tiltY: 0, twist: 0, pointerType: 0, isPrimary: 0 }), Td = rd$1(Sd), Ud = A$1({}, ud, { touches: 0, targetTouches: 0, changedTouches: 0, altKey: 0, metaKey: 0, ctrlKey: 0, shiftKey: 0, getModifierState: zd }), Vd = rd$1(Ud), Wd = A$1({}, sd, { propertyName: 0, elapsedTime: 0, pseudoElement: 0 }), Xd = rd$1(Wd), Yd = A$1({}, Ad, { + deltaX: function(a2) { + return "deltaX" in a2 ? a2.deltaX : "wheelDeltaX" in a2 ? -a2.wheelDeltaX : 0; }, - deltaY: function(a) { - return "deltaY" in a ? a.deltaY : "wheelDeltaY" in a ? -a.wheelDeltaY : "wheelDelta" in a ? -a.wheelDelta : 0; + deltaY: function(a2) { + return "deltaY" in a2 ? a2.deltaY : "wheelDeltaY" in a2 ? -a2.wheelDeltaY : "wheelDelta" in a2 ? -a2.wheelDelta : 0; }, deltaZ: 0, deltaMode: 0 -}), Zd = rd(Yd), $d = [9, 13, 27, 32], ae = ia && "CompositionEvent" in window, be = null; +}), Zd = rd$1(Yd), $d = [9, 13, 27, 32], ae = ia && "CompositionEvent" in window, be = null; ia && "documentMode" in document && (be = document.documentMode); -var ce = ia && "TextEvent" in window && !be, de = ia && (!ae || be && 8 < be && 11 >= be), ee = String.fromCharCode(32), fe = false; -function ge(a, b2) { - switch (a) { +var ce = ia && "TextEvent" in window && !be, de = ia && (!ae || be && 8 < be && 11 >= be), ee$1 = String.fromCharCode(32), fe = false; +function ge(a2, b2) { + switch (a2) { case "keyup": return -1 !== $d.indexOf(b2.keyCode); case "keydown": @@ -2196,30 +2215,30 @@ function ge(a, b2) { return false; } } -function he(a) { - a = a.detail; - return "object" === typeof a && "data" in a ? a.data : null; +function he(a2) { + a2 = a2.detail; + return "object" === typeof a2 && "data" in a2 ? a2.data : null; } var ie = false; -function je(a, b2) { - switch (a) { +function je(a2, b2) { + switch (a2) { case "compositionend": return he(b2); case "keypress": if (32 !== b2.which) return null; fe = true; - return ee; + return ee$1; case "textInput": - return a = b2.data, a === ee && fe ? null : a; + return a2 = b2.data, a2 === ee$1 && fe ? null : a2; default: return null; } } -function ke(a, b2) { +function ke(a2, b2) { if (ie) - return "compositionend" === a || !ae && ge(a, b2) ? (a = nd(), md = ld = kd = null, ie = false, a) : null; - switch (a) { + return "compositionend" === a2 || !ae && ge(a2, b2) ? (a2 = nd(), md = ld = kd = null, ie = false, a2) : null; + switch (a2) { case "paste": return null; case "keypress": @@ -2237,26 +2256,26 @@ function ke(a, b2) { } } var le = { color: true, date: true, datetime: true, "datetime-local": true, email: true, month: true, number: true, password: true, range: true, search: true, tel: true, text: true, time: true, url: true, week: true }; -function me(a) { - var b2 = a && a.nodeName && a.nodeName.toLowerCase(); - return "input" === b2 ? !!le[a.type] : "textarea" === b2 ? true : false; +function me(a2) { + var b2 = a2 && a2.nodeName && a2.nodeName.toLowerCase(); + return "input" === b2 ? !!le[a2.type] : "textarea" === b2 ? true : false; } -function ne(a, b2, c, d) { - Eb(d); +function ne(a2, b2, c2, d2) { + Eb(d2); b2 = oe(b2, "onChange"); - 0 < b2.length && (c = new td("onChange", "change", null, c, d), a.push({ event: c, listeners: b2 })); + 0 < b2.length && (c2 = new td("onChange", "change", null, c2, d2), a2.push({ event: c2, listeners: b2 })); } var pe = null, qe = null; -function re(a) { - se(a, 0); +function re$1(a2) { + se(a2, 0); } -function te(a) { - var b2 = ue(a); +function te(a2) { + var b2 = ue(a2); if (Wa(b2)) - return a; + return a2; } -function ve(a, b2) { - if ("change" === a) +function ve(a2, b2) { + if ("change" === a2) return b2; } var we = false; @@ -2277,156 +2296,156 @@ if (ia) { function Ae() { pe && (pe.detachEvent("onpropertychange", Be), qe = pe = null); } -function Be(a) { - if ("value" === a.propertyName && te(qe)) { +function Be(a2) { + if ("value" === a2.propertyName && te(qe)) { var b2 = []; - ne(b2, qe, a, xb(a)); - Jb(re, b2); + ne(b2, qe, a2, xb(a2)); + Jb(re$1, b2); } } -function Ce(a, b2, c) { - "focusin" === a ? (Ae(), pe = b2, qe = c, pe.attachEvent("onpropertychange", Be)) : "focusout" === a && Ae(); +function Ce(a2, b2, c2) { + "focusin" === a2 ? (Ae(), pe = b2, qe = c2, pe.attachEvent("onpropertychange", Be)) : "focusout" === a2 && Ae(); } -function De(a) { - if ("selectionchange" === a || "keyup" === a || "keydown" === a) +function De(a2) { + if ("selectionchange" === a2 || "keyup" === a2 || "keydown" === a2) return te(qe); } -function Ee(a, b2) { - if ("click" === a) +function Ee(a2, b2) { + if ("click" === a2) return te(b2); } -function Fe(a, b2) { - if ("input" === a || "change" === a) +function Fe(a2, b2) { + if ("input" === a2 || "change" === a2) return te(b2); } -function Ge(a, b2) { - return a === b2 && (0 !== a || 1 / a === 1 / b2) || a !== a && b2 !== b2; +function Ge(a2, b2) { + return a2 === b2 && (0 !== a2 || 1 / a2 === 1 / b2) || a2 !== a2 && b2 !== b2; } var He = "function" === typeof Object.is ? Object.is : Ge; -function Ie(a, b2) { - if (He(a, b2)) +function Ie(a2, b2) { + if (He(a2, b2)) return true; - if ("object" !== typeof a || null === a || "object" !== typeof b2 || null === b2) + if ("object" !== typeof a2 || null === a2 || "object" !== typeof b2 || null === b2) return false; - var c = Object.keys(a), d = Object.keys(b2); - if (c.length !== d.length) + var c2 = Object.keys(a2), d2 = Object.keys(b2); + if (c2.length !== d2.length) return false; - for (d = 0; d < c.length; d++) { - var e2 = c[d]; - if (!ja.call(b2, e2) || !He(a[e2], b2[e2])) + for (d2 = 0; d2 < c2.length; d2++) { + var e18 = c2[d2]; + if (!ja.call(b2, e18) || !He(a2[e18], b2[e18])) return false; } return true; } -function Je(a) { - for (; a && a.firstChild; ) - a = a.firstChild; - return a; -} -function Ke(a, b2) { - var c = Je(a); - a = 0; - for (var d; c; ) { - if (3 === c.nodeType) { - d = a + c.textContent.length; - if (a <= b2 && d >= b2) - return { node: c, offset: b2 - a }; - a = d; +function Je(a2) { + for (; a2 && a2.firstChild; ) + a2 = a2.firstChild; + return a2; +} +function Ke(a2, b2) { + var c2 = Je(a2); + a2 = 0; + for (var d2; c2; ) { + if (3 === c2.nodeType) { + d2 = a2 + c2.textContent.length; + if (a2 <= b2 && d2 >= b2) + return { node: c2, offset: b2 - a2 }; + a2 = d2; } a: { - for (; c; ) { - if (c.nextSibling) { - c = c.nextSibling; + for (; c2; ) { + if (c2.nextSibling) { + c2 = c2.nextSibling; break a; } - c = c.parentNode; + c2 = c2.parentNode; } - c = void 0; + c2 = void 0; } - c = Je(c); + c2 = Je(c2); } } -function Le(a, b2) { - return a && b2 ? a === b2 ? true : a && 3 === a.nodeType ? false : b2 && 3 === b2.nodeType ? Le(a, b2.parentNode) : "contains" in a ? a.contains(b2) : a.compareDocumentPosition ? !!(a.compareDocumentPosition(b2) & 16) : false : false; +function Le(a2, b2) { + return a2 && b2 ? a2 === b2 ? true : a2 && 3 === a2.nodeType ? false : b2 && 3 === b2.nodeType ? Le(a2, b2.parentNode) : "contains" in a2 ? a2.contains(b2) : a2.compareDocumentPosition ? !!(a2.compareDocumentPosition(b2) & 16) : false : false; } function Me() { - for (var a = window, b2 = Xa(); b2 instanceof a.HTMLIFrameElement; ) { + for (var a2 = window, b2 = Xa(); b2 instanceof a2.HTMLIFrameElement; ) { try { - var c = "string" === typeof b2.contentWindow.location.href; - } catch (d) { - c = false; + var c2 = "string" === typeof b2.contentWindow.location.href; + } catch (d2) { + c2 = false; } - if (c) - a = b2.contentWindow; + if (c2) + a2 = b2.contentWindow; else break; - b2 = Xa(a.document); + b2 = Xa(a2.document); } return b2; } -function Ne(a) { - var b2 = a && a.nodeName && a.nodeName.toLowerCase(); - return b2 && ("input" === b2 && ("text" === a.type || "search" === a.type || "tel" === a.type || "url" === a.type || "password" === a.type) || "textarea" === b2 || "true" === a.contentEditable); -} -function Oe(a) { - var b2 = Me(), c = a.focusedElem, d = a.selectionRange; - if (b2 !== c && c && c.ownerDocument && Le(c.ownerDocument.documentElement, c)) { - if (null !== d && Ne(c)) { - if (b2 = d.start, a = d.end, void 0 === a && (a = b2), "selectionStart" in c) - c.selectionStart = b2, c.selectionEnd = Math.min(a, c.value.length); - else if (a = (b2 = c.ownerDocument || document) && b2.defaultView || window, a.getSelection) { - a = a.getSelection(); - var e2 = c.textContent.length, f2 = Math.min(d.start, e2); - d = void 0 === d.end ? f2 : Math.min(d.end, e2); - !a.extend && f2 > d && (e2 = d, d = f2, f2 = e2); - e2 = Ke(c, f2); - var g = Ke( - c, - d +function Ne(a2) { + var b2 = a2 && a2.nodeName && a2.nodeName.toLowerCase(); + return b2 && ("input" === b2 && ("text" === a2.type || "search" === a2.type || "tel" === a2.type || "url" === a2.type || "password" === a2.type) || "textarea" === b2 || "true" === a2.contentEditable); +} +function Oe(a2) { + var b2 = Me(), c2 = a2.focusedElem, d2 = a2.selectionRange; + if (b2 !== c2 && c2 && c2.ownerDocument && Le(c2.ownerDocument.documentElement, c2)) { + if (null !== d2 && Ne(c2)) { + if (b2 = d2.start, a2 = d2.end, void 0 === a2 && (a2 = b2), "selectionStart" in c2) + c2.selectionStart = b2, c2.selectionEnd = Math.min(a2, c2.value.length); + else if (a2 = (b2 = c2.ownerDocument || document) && b2.defaultView || window, a2.getSelection) { + a2 = a2.getSelection(); + var e18 = c2.textContent.length, f2 = Math.min(d2.start, e18); + d2 = void 0 === d2.end ? f2 : Math.min(d2.end, e18); + !a2.extend && f2 > d2 && (e18 = d2, d2 = f2, f2 = e18); + e18 = Ke(c2, f2); + var g2 = Ke( + c2, + d2 ); - e2 && g && (1 !== a.rangeCount || a.anchorNode !== e2.node || a.anchorOffset !== e2.offset || a.focusNode !== g.node || a.focusOffset !== g.offset) && (b2 = b2.createRange(), b2.setStart(e2.node, e2.offset), a.removeAllRanges(), f2 > d ? (a.addRange(b2), a.extend(g.node, g.offset)) : (b2.setEnd(g.node, g.offset), a.addRange(b2))); + e18 && g2 && (1 !== a2.rangeCount || a2.anchorNode !== e18.node || a2.anchorOffset !== e18.offset || a2.focusNode !== g2.node || a2.focusOffset !== g2.offset) && (b2 = b2.createRange(), b2.setStart(e18.node, e18.offset), a2.removeAllRanges(), f2 > d2 ? (a2.addRange(b2), a2.extend(g2.node, g2.offset)) : (b2.setEnd(g2.node, g2.offset), a2.addRange(b2))); } } b2 = []; - for (a = c; a = a.parentNode; ) - 1 === a.nodeType && b2.push({ element: a, left: a.scrollLeft, top: a.scrollTop }); - "function" === typeof c.focus && c.focus(); - for (c = 0; c < b2.length; c++) - a = b2[c], a.element.scrollLeft = a.left, a.element.scrollTop = a.top; + for (a2 = c2; a2 = a2.parentNode; ) + 1 === a2.nodeType && b2.push({ element: a2, left: a2.scrollLeft, top: a2.scrollTop }); + "function" === typeof c2.focus && c2.focus(); + for (c2 = 0; c2 < b2.length; c2++) + a2 = b2[c2], a2.element.scrollLeft = a2.left, a2.element.scrollTop = a2.top; } } var Pe = ia && "documentMode" in document && 11 >= document.documentMode, Qe = null, Re = null, Se = null, Te = false; -function Ue(a, b2, c) { - var d = c.window === c ? c.document : 9 === c.nodeType ? c : c.ownerDocument; - Te || null == Qe || Qe !== Xa(d) || (d = Qe, "selectionStart" in d && Ne(d) ? d = { start: d.selectionStart, end: d.selectionEnd } : (d = (d.ownerDocument && d.ownerDocument.defaultView || window).getSelection(), d = { anchorNode: d.anchorNode, anchorOffset: d.anchorOffset, focusNode: d.focusNode, focusOffset: d.focusOffset }), Se && Ie(Se, d) || (Se = d, d = oe(Re, "onSelect"), 0 < d.length && (b2 = new td("onSelect", "select", null, b2, c), a.push({ event: b2, listeners: d }), b2.target = Qe))); +function Ue(a2, b2, c2) { + var d2 = c2.window === c2 ? c2.document : 9 === c2.nodeType ? c2 : c2.ownerDocument; + Te || null == Qe || Qe !== Xa(d2) || (d2 = Qe, "selectionStart" in d2 && Ne(d2) ? d2 = { start: d2.selectionStart, end: d2.selectionEnd } : (d2 = (d2.ownerDocument && d2.ownerDocument.defaultView || window).getSelection(), d2 = { anchorNode: d2.anchorNode, anchorOffset: d2.anchorOffset, focusNode: d2.focusNode, focusOffset: d2.focusOffset }), Se && Ie(Se, d2) || (Se = d2, d2 = oe(Re, "onSelect"), 0 < d2.length && (b2 = new td("onSelect", "select", null, b2, c2), a2.push({ event: b2, listeners: d2 }), b2.target = Qe))); } -function Ve(a, b2) { - var c = {}; - c[a.toLowerCase()] = b2.toLowerCase(); - c["Webkit" + a] = "webkit" + b2; - c["Moz" + a] = "moz" + b2; - return c; +function Ve(a2, b2) { + var c2 = {}; + c2[a2.toLowerCase()] = b2.toLowerCase(); + c2["Webkit" + a2] = "webkit" + b2; + c2["Moz" + a2] = "moz" + b2; + return c2; } var We = { animationend: Ve("Animation", "AnimationEnd"), animationiteration: Ve("Animation", "AnimationIteration"), animationstart: Ve("Animation", "AnimationStart"), transitionend: Ve("Transition", "TransitionEnd") }, Xe = {}, Ye = {}; ia && (Ye = document.createElement("div").style, "AnimationEvent" in window || (delete We.animationend.animation, delete We.animationiteration.animation, delete We.animationstart.animation), "TransitionEvent" in window || delete We.transitionend.transition); -function Ze(a) { - if (Xe[a]) - return Xe[a]; - if (!We[a]) - return a; - var b2 = We[a], c; - for (c in b2) - if (b2.hasOwnProperty(c) && c in Ye) - return Xe[a] = b2[c]; - return a; -} -var $e = Ze("animationend"), af = Ze("animationiteration"), bf = Ze("animationstart"), cf = Ze("transitionend"), df = /* @__PURE__ */ new Map(), ef = "abort auxClick cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel".split(" "); -function ff(a, b2) { - df.set(a, b2); - fa(b2, [a]); -} -for (var gf = 0; gf < ef.length; gf++) { - var hf = ef[gf], jf = hf.toLowerCase(), kf = hf[0].toUpperCase() + hf.slice(1); +function Ze(a2) { + if (Xe[a2]) + return Xe[a2]; + if (!We[a2]) + return a2; + var b2 = We[a2], c2; + for (c2 in b2) + if (b2.hasOwnProperty(c2) && c2 in Ye) + return Xe[a2] = b2[c2]; + return a2; +} +var $e = Ze("animationend"), af = Ze("animationiteration"), bf = Ze("animationstart"), cf = Ze("transitionend"), df = /* @__PURE__ */ new Map(), ef$1 = "abort auxClick cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel".split(" "); +function ff(a2, b2) { + df.set(a2, b2); + fa(b2, [a2]); +} +for (var gf = 0; gf < ef$1.length; gf++) { + var hf = ef$1[gf], jf = hf.toLowerCase(), kf = hf[0].toUpperCase() + hf.slice(1); ff(jf, "on" + kf); } ff($e, "onAnimationEnd"); @@ -2447,126 +2466,126 @@ fa("onCompositionEnd", "compositionend focusout keydown keypress keyup mousedown fa("onCompositionStart", "compositionstart focusout keydown keypress keyup mousedown".split(" ")); fa("onCompositionUpdate", "compositionupdate focusout keydown keypress keyup mousedown".split(" ")); var lf = "abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting".split(" "), mf = new Set("cancel close invalid load scroll toggle".split(" ").concat(lf)); -function nf(a, b2, c) { - var d = a.type || "unknown-event"; - a.currentTarget = c; - Ub(d, b2, void 0, a); - a.currentTarget = null; +function nf(a2, b2, c2) { + var d2 = a2.type || "unknown-event"; + a2.currentTarget = c2; + Ub(d2, b2, void 0, a2); + a2.currentTarget = null; } -function se(a, b2) { +function se(a2, b2) { b2 = 0 !== (b2 & 4); - for (var c = 0; c < a.length; c++) { - var d = a[c], e2 = d.event; - d = d.listeners; + for (var c2 = 0; c2 < a2.length; c2++) { + var d2 = a2[c2], e18 = d2.event; + d2 = d2.listeners; a: { var f2 = void 0; if (b2) - for (var g = d.length - 1; 0 <= g; g--) { - var h2 = d[g], k2 = h2.instance, l2 = h2.currentTarget; + for (var g2 = d2.length - 1; 0 <= g2; g2--) { + var h2 = d2[g2], k2 = h2.instance, l2 = h2.currentTarget; h2 = h2.listener; - if (k2 !== f2 && e2.isPropagationStopped()) + if (k2 !== f2 && e18.isPropagationStopped()) break a; - nf(e2, h2, l2); + nf(e18, h2, l2); f2 = k2; } else - for (g = 0; g < d.length; g++) { - h2 = d[g]; + for (g2 = 0; g2 < d2.length; g2++) { + h2 = d2[g2]; k2 = h2.instance; l2 = h2.currentTarget; h2 = h2.listener; - if (k2 !== f2 && e2.isPropagationStopped()) + if (k2 !== f2 && e18.isPropagationStopped()) break a; - nf(e2, h2, l2); + nf(e18, h2, l2); f2 = k2; } } } if (Qb) - throw a = Rb, Qb = false, Rb = null, a; -} -function D(a, b2) { - var c = b2[of]; - void 0 === c && (c = b2[of] = /* @__PURE__ */ new Set()); - var d = a + "__bubble"; - c.has(d) || (pf(b2, a, 2, false), c.add(d)); -} -function qf(a, b2, c) { - var d = 0; - b2 && (d |= 4); - pf(c, a, d, b2); -} -var rf = "_reactListening" + Math.random().toString(36).slice(2); -function sf(a) { - if (!a[rf]) { - a[rf] = true; + throw a2 = Rb, Qb = false, Rb = null, a2; +} +function D$1(a2, b2) { + var c2 = b2[of]; + void 0 === c2 && (c2 = b2[of] = /* @__PURE__ */ new Set()); + var d2 = a2 + "__bubble"; + c2.has(d2) || (pf(b2, a2, 2, false), c2.add(d2)); +} +function qf(a2, b2, c2) { + var d2 = 0; + b2 && (d2 |= 4); + pf(c2, a2, d2, b2); +} +var rf$1 = "_reactListening" + Math.random().toString(36).slice(2); +function sf(a2) { + if (!a2[rf$1]) { + a2[rf$1] = true; da.forEach(function(b3) { - "selectionchange" !== b3 && (mf.has(b3) || qf(b3, false, a), qf(b3, true, a)); + "selectionchange" !== b3 && (mf.has(b3) || qf(b3, false, a2), qf(b3, true, a2)); }); - var b2 = 9 === a.nodeType ? a : a.ownerDocument; - null === b2 || b2[rf] || (b2[rf] = true, qf("selectionchange", false, b2)); + var b2 = 9 === a2.nodeType ? a2 : a2.ownerDocument; + null === b2 || b2[rf$1] || (b2[rf$1] = true, qf("selectionchange", false, b2)); } } -function pf(a, b2, c, d) { +function pf(a2, b2, c2, d2) { switch (jd(b2)) { case 1: - var e2 = ed; + var e18 = ed$1; break; case 4: - e2 = gd; + e18 = gd; break; default: - e2 = fd; + e18 = fd; } - c = e2.bind(null, b2, c, a); - e2 = void 0; - !Lb || "touchstart" !== b2 && "touchmove" !== b2 && "wheel" !== b2 || (e2 = true); - d ? void 0 !== e2 ? a.addEventListener(b2, c, { capture: true, passive: e2 }) : a.addEventListener(b2, c, true) : void 0 !== e2 ? a.addEventListener(b2, c, { passive: e2 }) : a.addEventListener(b2, c, false); + c2 = e18.bind(null, b2, c2, a2); + e18 = void 0; + !Lb || "touchstart" !== b2 && "touchmove" !== b2 && "wheel" !== b2 || (e18 = true); + d2 ? void 0 !== e18 ? a2.addEventListener(b2, c2, { capture: true, passive: e18 }) : a2.addEventListener(b2, c2, true) : void 0 !== e18 ? a2.addEventListener(b2, c2, { passive: e18 }) : a2.addEventListener(b2, c2, false); } -function hd(a, b2, c, d, e2) { - var f2 = d; - if (0 === (b2 & 1) && 0 === (b2 & 2) && null !== d) +function hd(a2, b2, c2, d2, e18) { + var f2 = d2; + if (0 === (b2 & 1) && 0 === (b2 & 2) && null !== d2) a: for (; ; ) { - if (null === d) + if (null === d2) return; - var g = d.tag; - if (3 === g || 4 === g) { - var h2 = d.stateNode.containerInfo; - if (h2 === e2 || 8 === h2.nodeType && h2.parentNode === e2) + var g2 = d2.tag; + if (3 === g2 || 4 === g2) { + var h2 = d2.stateNode.containerInfo; + if (h2 === e18 || 8 === h2.nodeType && h2.parentNode === e18) break; - if (4 === g) - for (g = d.return; null !== g; ) { - var k2 = g.tag; + if (4 === g2) + for (g2 = d2.return; null !== g2; ) { + var k2 = g2.tag; if (3 === k2 || 4 === k2) { - if (k2 = g.stateNode.containerInfo, k2 === e2 || 8 === k2.nodeType && k2.parentNode === e2) + if (k2 = g2.stateNode.containerInfo, k2 === e18 || 8 === k2.nodeType && k2.parentNode === e18) return; } - g = g.return; + g2 = g2.return; } for (; null !== h2; ) { - g = Wc(h2); - if (null === g) + g2 = Wc(h2); + if (null === g2) return; - k2 = g.tag; + k2 = g2.tag; if (5 === k2 || 6 === k2) { - d = f2 = g; + d2 = f2 = g2; continue a; } h2 = h2.parentNode; } } - d = d.return; + d2 = d2.return; } Jb(function() { - var d2 = f2, e3 = xb(c), g2 = []; + var d3 = f2, e19 = xb(c2), g3 = []; a: { - var h3 = df.get(a); + var h3 = df.get(a2); if (void 0 !== h3) { - var k3 = td, n2 = a; - switch (a) { + var k3 = td, n2 = a2; + switch (a2) { case "keypress": - if (0 === od(c)) + if (0 === od(c2)) break a; case "keydown": case "keyup": @@ -2585,7 +2604,7 @@ function hd(a, b2, c, d, e2) { k3 = Fd; break; case "click": - if (2 === c.button) + if (2 === c2.button) break a; case "auxclick": case "dblclick": @@ -2642,9 +2661,9 @@ function hd(a, b2, c, d, e2) { case "pointerup": k3 = Td; } - var t2 = 0 !== (b2 & 4), J2 = !t2 && "scroll" === a, x2 = t2 ? null !== h3 ? h3 + "Capture" : null : h3; + var t2 = 0 !== (b2 & 4), J2 = !t2 && "scroll" === a2, x2 = t2 ? null !== h3 ? h3 + "Capture" : null : h3; t2 = []; - for (var w2 = d2, u2; null !== w2; ) { + for (var w2 = d3, u2; null !== w2; ) { u2 = w2; var F2 = u2.stateNode; 5 === u2.tag && null !== F2 && (u2 = F2, null !== x2 && (F2 = Kb(w2, x2), null != F2 && t2.push(tf(w2, F2, u2)))); @@ -2652,36 +2671,36 @@ function hd(a, b2, c, d, e2) { break; w2 = w2.return; } - 0 < t2.length && (h3 = new k3(h3, n2, null, c, e3), g2.push({ event: h3, listeners: t2 })); + 0 < t2.length && (h3 = new k3(h3, n2, null, c2, e19), g3.push({ event: h3, listeners: t2 })); } } if (0 === (b2 & 7)) { a: { - h3 = "mouseover" === a || "pointerover" === a; - k3 = "mouseout" === a || "pointerout" === a; - if (h3 && c !== wb && (n2 = c.relatedTarget || c.fromElement) && (Wc(n2) || n2[uf])) + h3 = "mouseover" === a2 || "pointerover" === a2; + k3 = "mouseout" === a2 || "pointerout" === a2; + if (h3 && c2 !== wb && (n2 = c2.relatedTarget || c2.fromElement) && (Wc(n2) || n2[uf])) break a; if (k3 || h3) { - h3 = e3.window === e3 ? e3 : (h3 = e3.ownerDocument) ? h3.defaultView || h3.parentWindow : window; + h3 = e19.window === e19 ? e19 : (h3 = e19.ownerDocument) ? h3.defaultView || h3.parentWindow : window; if (k3) { - if (n2 = c.relatedTarget || c.toElement, k3 = d2, n2 = n2 ? Wc(n2) : null, null !== n2 && (J2 = Vb(n2), n2 !== J2 || 5 !== n2.tag && 6 !== n2.tag)) + if (n2 = c2.relatedTarget || c2.toElement, k3 = d3, n2 = n2 ? Wc(n2) : null, null !== n2 && (J2 = Vb(n2), n2 !== J2 || 5 !== n2.tag && 6 !== n2.tag)) n2 = null; } else - k3 = null, n2 = d2; + k3 = null, n2 = d3; if (k3 !== n2) { t2 = Bd; F2 = "onMouseLeave"; x2 = "onMouseEnter"; w2 = "mouse"; - if ("pointerout" === a || "pointerover" === a) + if ("pointerout" === a2 || "pointerover" === a2) t2 = Td, F2 = "onPointerLeave", x2 = "onPointerEnter", w2 = "pointer"; J2 = null == k3 ? h3 : ue(k3); u2 = null == n2 ? h3 : ue(n2); - h3 = new t2(F2, w2 + "leave", k3, c, e3); + h3 = new t2(F2, w2 + "leave", k3, c2, e19); h3.target = J2; h3.relatedTarget = u2; F2 = null; - Wc(e3) === d2 && (t2 = new t2(x2, w2 + "enter", n2, c, e3), t2.target = u2, t2.relatedTarget = J2, F2 = t2); + Wc(e19) === d3 && (t2 = new t2(x2, w2 + "enter", n2, c2, e19), t2.target = u2, t2.relatedTarget = J2, F2 = t2); J2 = F2; if (k3 && n2) b: { @@ -2707,13 +2726,13 @@ function hd(a, b2, c, d, e2) { } else t2 = null; - null !== k3 && wf(g2, h3, k3, t2, false); - null !== n2 && null !== J2 && wf(g2, J2, n2, t2, true); + null !== k3 && wf(g3, h3, k3, t2, false); + null !== n2 && null !== J2 && wf(g3, J2, n2, t2, true); } } } a: { - h3 = d2 ? ue(d2) : window; + h3 = d3 ? ue(d3) : window; k3 = h3.nodeName && h3.nodeName.toLowerCase(); if ("select" === k3 || "input" === k3 && "file" === h3.type) var na = ve; @@ -2726,18 +2745,18 @@ function hd(a, b2, c, d, e2) { } else (k3 = h3.nodeName) && "input" === k3.toLowerCase() && ("checkbox" === h3.type || "radio" === h3.type) && (na = Ee); - if (na && (na = na(a, d2))) { - ne(g2, na, c, e3); + if (na && (na = na(a2, d3))) { + ne(g3, na, c2, e19); break a; } - xa && xa(a, h3, d2); - "focusout" === a && (xa = h3._wrapperState) && xa.controlled && "number" === h3.type && cb(h3, "number", h3.value); + xa && xa(a2, h3, d3); + "focusout" === a2 && (xa = h3._wrapperState) && xa.controlled && "number" === h3.type && cb(h3, "number", h3.value); } - xa = d2 ? ue(d2) : window; - switch (a) { + xa = d3 ? ue(d3) : window; + switch (a2) { case "focusin": if (me(xa) || "true" === xa.contentEditable) - Qe = xa, Re = d2, Se = null; + Qe = xa, Re = d3, Se = null; break; case "focusout": Se = Re = Qe = null; @@ -2749,19 +2768,19 @@ function hd(a, b2, c, d, e2) { case "mouseup": case "dragend": Te = false; - Ue(g2, c, e3); + Ue(g3, c2, e19); break; case "selectionchange": if (Pe) break; case "keydown": case "keyup": - Ue(g2, c, e3); + Ue(g3, c2, e19); } var $a; if (ae) b: { - switch (a) { + switch (a2) { case "compositionstart": var ba = "onCompositionStart"; break b; @@ -2775,692 +2794,692 @@ function hd(a, b2, c, d, e2) { ba = void 0; } else - ie ? ge(a, c) && (ba = "onCompositionEnd") : "keydown" === a && 229 === c.keyCode && (ba = "onCompositionStart"); - ba && (de && "ko" !== c.locale && (ie || "onCompositionStart" !== ba ? "onCompositionEnd" === ba && ie && ($a = nd()) : (kd = e3, ld = "value" in kd ? kd.value : kd.textContent, ie = true)), xa = oe(d2, ba), 0 < xa.length && (ba = new Ld(ba, a, null, c, e3), g2.push({ event: ba, listeners: xa }), $a ? ba.data = $a : ($a = he(c), null !== $a && (ba.data = $a)))); - if ($a = ce ? je(a, c) : ke(a, c)) - d2 = oe(d2, "onBeforeInput"), 0 < d2.length && (e3 = new Ld("onBeforeInput", "beforeinput", null, c, e3), g2.push({ event: e3, listeners: d2 }), e3.data = $a); + ie ? ge(a2, c2) && (ba = "onCompositionEnd") : "keydown" === a2 && 229 === c2.keyCode && (ba = "onCompositionStart"); + ba && (de && "ko" !== c2.locale && (ie || "onCompositionStart" !== ba ? "onCompositionEnd" === ba && ie && ($a = nd()) : (kd = e19, ld = "value" in kd ? kd.value : kd.textContent, ie = true)), xa = oe(d3, ba), 0 < xa.length && (ba = new Ld(ba, a2, null, c2, e19), g3.push({ event: ba, listeners: xa }), $a ? ba.data = $a : ($a = he(c2), null !== $a && (ba.data = $a)))); + if ($a = ce ? je(a2, c2) : ke(a2, c2)) + d3 = oe(d3, "onBeforeInput"), 0 < d3.length && (e19 = new Ld("onBeforeInput", "beforeinput", null, c2, e19), g3.push({ event: e19, listeners: d3 }), e19.data = $a); } - se(g2, b2); + se(g3, b2); }); } -function tf(a, b2, c) { - return { instance: a, listener: b2, currentTarget: c }; +function tf(a2, b2, c2) { + return { instance: a2, listener: b2, currentTarget: c2 }; } -function oe(a, b2) { - for (var c = b2 + "Capture", d = []; null !== a; ) { - var e2 = a, f2 = e2.stateNode; - 5 === e2.tag && null !== f2 && (e2 = f2, f2 = Kb(a, c), null != f2 && d.unshift(tf(a, f2, e2)), f2 = Kb(a, b2), null != f2 && d.push(tf(a, f2, e2))); - a = a.return; +function oe(a2, b2) { + for (var c2 = b2 + "Capture", d2 = []; null !== a2; ) { + var e18 = a2, f2 = e18.stateNode; + 5 === e18.tag && null !== f2 && (e18 = f2, f2 = Kb(a2, c2), null != f2 && d2.unshift(tf(a2, f2, e18)), f2 = Kb(a2, b2), null != f2 && d2.push(tf(a2, f2, e18))); + a2 = a2.return; } - return d; + return d2; } -function vf(a) { - if (null === a) +function vf(a2) { + if (null === a2) return null; do - a = a.return; - while (a && 5 !== a.tag); - return a ? a : null; -} -function wf(a, b2, c, d, e2) { - for (var f2 = b2._reactName, g = []; null !== c && c !== d; ) { - var h2 = c, k2 = h2.alternate, l2 = h2.stateNode; - if (null !== k2 && k2 === d) + a2 = a2.return; + while (a2 && 5 !== a2.tag); + return a2 ? a2 : null; +} +function wf(a2, b2, c2, d2, e18) { + for (var f2 = b2._reactName, g2 = []; null !== c2 && c2 !== d2; ) { + var h2 = c2, k2 = h2.alternate, l2 = h2.stateNode; + if (null !== k2 && k2 === d2) break; - 5 === h2.tag && null !== l2 && (h2 = l2, e2 ? (k2 = Kb(c, f2), null != k2 && g.unshift(tf(c, k2, h2))) : e2 || (k2 = Kb(c, f2), null != k2 && g.push(tf(c, k2, h2)))); - c = c.return; + 5 === h2.tag && null !== l2 && (h2 = l2, e18 ? (k2 = Kb(c2, f2), null != k2 && g2.unshift(tf(c2, k2, h2))) : e18 || (k2 = Kb(c2, f2), null != k2 && g2.push(tf(c2, k2, h2)))); + c2 = c2.return; } - 0 !== g.length && a.push({ event: b2, listeners: g }); + 0 !== g2.length && a2.push({ event: b2, listeners: g2 }); } var xf = /\r\n?/g, yf = /\u0000|\uFFFD/g; -function zf(a) { - return ("string" === typeof a ? a : "" + a).replace(xf, "\n").replace(yf, ""); +function zf(a2) { + return ("string" === typeof a2 ? a2 : "" + a2).replace(xf, "\n").replace(yf, ""); } -function Af(a, b2, c) { +function Af(a2, b2, c2) { b2 = zf(b2); - if (zf(a) !== b2 && c) - throw Error(p$2(425)); + if (zf(a2) !== b2 && c2) + throw Error(p$3(425)); } function Bf() { } var Cf = null, Df = null; -function Ef(a, b2) { - return "textarea" === a || "noscript" === a || "string" === typeof b2.children || "number" === typeof b2.children || "object" === typeof b2.dangerouslySetInnerHTML && null !== b2.dangerouslySetInnerHTML && null != b2.dangerouslySetInnerHTML.__html; +function Ef(a2, b2) { + return "textarea" === a2 || "noscript" === a2 || "string" === typeof b2.children || "number" === typeof b2.children || "object" === typeof b2.dangerouslySetInnerHTML && null !== b2.dangerouslySetInnerHTML && null != b2.dangerouslySetInnerHTML.__html; } -var Ff = "function" === typeof setTimeout ? setTimeout : void 0, Gf = "function" === typeof clearTimeout ? clearTimeout : void 0, Hf = "function" === typeof Promise ? Promise : void 0, Jf = "function" === typeof queueMicrotask ? queueMicrotask : "undefined" !== typeof Hf ? function(a) { - return Hf.resolve(null).then(a).catch(If); +var Ff = "function" === typeof setTimeout ? setTimeout : void 0, Gf = "function" === typeof clearTimeout ? clearTimeout : void 0, Hf = "function" === typeof Promise ? Promise : void 0, Jf = "function" === typeof queueMicrotask ? queueMicrotask : "undefined" !== typeof Hf ? function(a2) { + return Hf.resolve(null).then(a2).catch(If); } : Ff; -function If(a) { +function If(a2) { setTimeout(function() { - throw a; + throw a2; }); } -function Kf(a, b2) { - var c = b2, d = 0; +function Kf(a2, b2) { + var c2 = b2, d2 = 0; do { - var e2 = c.nextSibling; - a.removeChild(c); - if (e2 && 8 === e2.nodeType) - if (c = e2.data, "/$" === c) { - if (0 === d) { - a.removeChild(e2); + var e18 = c2.nextSibling; + a2.removeChild(c2); + if (e18 && 8 === e18.nodeType) + if (c2 = e18.data, "/$" === c2) { + if (0 === d2) { + a2.removeChild(e18); bd(b2); return; } - d--; + d2--; } else - "$" !== c && "$?" !== c && "$!" !== c || d++; - c = e2; - } while (c); + "$" !== c2 && "$?" !== c2 && "$!" !== c2 || d2++; + c2 = e18; + } while (c2); bd(b2); } -function Lf(a) { - for (; null != a; a = a.nextSibling) { - var b2 = a.nodeType; +function Lf(a2) { + for (; null != a2; a2 = a2.nextSibling) { + var b2 = a2.nodeType; if (1 === b2 || 3 === b2) break; if (8 === b2) { - b2 = a.data; + b2 = a2.data; if ("$" === b2 || "$!" === b2 || "$?" === b2) break; if ("/$" === b2) return null; } } - return a; + return a2; } -function Mf(a) { - a = a.previousSibling; - for (var b2 = 0; a; ) { - if (8 === a.nodeType) { - var c = a.data; - if ("$" === c || "$!" === c || "$?" === c) { +function Mf(a2) { + a2 = a2.previousSibling; + for (var b2 = 0; a2; ) { + if (8 === a2.nodeType) { + var c2 = a2.data; + if ("$" === c2 || "$!" === c2 || "$?" === c2) { if (0 === b2) - return a; + return a2; b2--; } else - "/$" === c && b2++; + "/$" === c2 && b2++; } - a = a.previousSibling; + a2 = a2.previousSibling; } return null; } var Nf = Math.random().toString(36).slice(2), Of = "__reactFiber$" + Nf, Pf = "__reactProps$" + Nf, uf = "__reactContainer$" + Nf, of = "__reactEvents$" + Nf, Qf = "__reactListeners$" + Nf, Rf = "__reactHandles$" + Nf; -function Wc(a) { - var b2 = a[Of]; +function Wc(a2) { + var b2 = a2[Of]; if (b2) return b2; - for (var c = a.parentNode; c; ) { - if (b2 = c[uf] || c[Of]) { - c = b2.alternate; - if (null !== b2.child || null !== c && null !== c.child) - for (a = Mf(a); null !== a; ) { - if (c = a[Of]) - return c; - a = Mf(a); + for (var c2 = a2.parentNode; c2; ) { + if (b2 = c2[uf] || c2[Of]) { + c2 = b2.alternate; + if (null !== b2.child || null !== c2 && null !== c2.child) + for (a2 = Mf(a2); null !== a2; ) { + if (c2 = a2[Of]) + return c2; + a2 = Mf(a2); } return b2; } - a = c; - c = a.parentNode; + a2 = c2; + c2 = a2.parentNode; } return null; } -function Cb(a) { - a = a[Of] || a[uf]; - return !a || 5 !== a.tag && 6 !== a.tag && 13 !== a.tag && 3 !== a.tag ? null : a; +function Cb(a2) { + a2 = a2[Of] || a2[uf]; + return !a2 || 5 !== a2.tag && 6 !== a2.tag && 13 !== a2.tag && 3 !== a2.tag ? null : a2; } -function ue(a) { - if (5 === a.tag || 6 === a.tag) - return a.stateNode; - throw Error(p$2(33)); +function ue(a2) { + if (5 === a2.tag || 6 === a2.tag) + return a2.stateNode; + throw Error(p$3(33)); } -function Db(a) { - return a[Pf] || null; +function Db(a2) { + return a2[Pf] || null; } var Sf = [], Tf = -1; -function Uf(a) { - return { current: a }; +function Uf(a2) { + return { current: a2 }; } -function E(a) { - 0 > Tf || (a.current = Sf[Tf], Sf[Tf] = null, Tf--); +function E$1(a2) { + 0 > Tf || (a2.current = Sf[Tf], Sf[Tf] = null, Tf--); } -function G(a, b2) { +function G$1(a2, b2) { Tf++; - Sf[Tf] = a.current; - a.current = b2; + Sf[Tf] = a2.current; + a2.current = b2; } -var Vf = {}, H = Uf(Vf), Wf = Uf(false), Xf = Vf; -function Yf(a, b2) { - var c = a.type.contextTypes; - if (!c) +var Vf = {}, H$1 = Uf(Vf), Wf = Uf(false), Xf = Vf; +function Yf(a2, b2) { + var c2 = a2.type.contextTypes; + if (!c2) return Vf; - var d = a.stateNode; - if (d && d.__reactInternalMemoizedUnmaskedChildContext === b2) - return d.__reactInternalMemoizedMaskedChildContext; - var e2 = {}, f2; - for (f2 in c) - e2[f2] = b2[f2]; - d && (a = a.stateNode, a.__reactInternalMemoizedUnmaskedChildContext = b2, a.__reactInternalMemoizedMaskedChildContext = e2); - return e2; -} -function Zf(a) { - a = a.childContextTypes; - return null !== a && void 0 !== a; + var d2 = a2.stateNode; + if (d2 && d2.__reactInternalMemoizedUnmaskedChildContext === b2) + return d2.__reactInternalMemoizedMaskedChildContext; + var e18 = {}, f2; + for (f2 in c2) + e18[f2] = b2[f2]; + d2 && (a2 = a2.stateNode, a2.__reactInternalMemoizedUnmaskedChildContext = b2, a2.__reactInternalMemoizedMaskedChildContext = e18); + return e18; +} +function Zf(a2) { + a2 = a2.childContextTypes; + return null !== a2 && void 0 !== a2; } function $f() { - E(Wf); - E(H); + E$1(Wf); + E$1(H$1); } -function ag(a, b2, c) { - if (H.current !== Vf) - throw Error(p$2(168)); - G(H, b2); - G(Wf, c); +function ag(a2, b2, c2) { + if (H$1.current !== Vf) + throw Error(p$3(168)); + G$1(H$1, b2); + G$1(Wf, c2); } -function bg(a, b2, c) { - var d = a.stateNode; +function bg(a2, b2, c2) { + var d2 = a2.stateNode; b2 = b2.childContextTypes; - if ("function" !== typeof d.getChildContext) - return c; - d = d.getChildContext(); - for (var e2 in d) - if (!(e2 in b2)) - throw Error(p$2(108, Ra(a) || "Unknown", e2)); - return A({}, c, d); -} -function cg(a) { - a = (a = a.stateNode) && a.__reactInternalMemoizedMergedChildContext || Vf; - Xf = H.current; - G(H, a); - G(Wf, Wf.current); + if ("function" !== typeof d2.getChildContext) + return c2; + d2 = d2.getChildContext(); + for (var e18 in d2) + if (!(e18 in b2)) + throw Error(p$3(108, Ra(a2) || "Unknown", e18)); + return A$1({}, c2, d2); +} +function cg(a2) { + a2 = (a2 = a2.stateNode) && a2.__reactInternalMemoizedMergedChildContext || Vf; + Xf = H$1.current; + G$1(H$1, a2); + G$1(Wf, Wf.current); return true; } -function dg(a, b2, c) { - var d = a.stateNode; - if (!d) - throw Error(p$2(169)); - c ? (a = bg(a, b2, Xf), d.__reactInternalMemoizedMergedChildContext = a, E(Wf), E(H), G(H, a)) : E(Wf); - G(Wf, c); +function dg(a2, b2, c2) { + var d2 = a2.stateNode; + if (!d2) + throw Error(p$3(169)); + c2 ? (a2 = bg(a2, b2, Xf), d2.__reactInternalMemoizedMergedChildContext = a2, E$1(Wf), E$1(H$1), G$1(H$1, a2)) : E$1(Wf); + G$1(Wf, c2); } -var eg = null, fg = false, gg = false; -function hg(a) { - null === eg ? eg = [a] : eg.push(a); +var eg$1 = null, fg = false, gg = false; +function hg(a2) { + null === eg$1 ? eg$1 = [a2] : eg$1.push(a2); } -function ig(a) { +function ig(a2) { fg = true; - hg(a); + hg(a2); } function jg() { - if (!gg && null !== eg) { + if (!gg && null !== eg$1) { gg = true; - var a = 0, b2 = C; + var a2 = 0, b2 = C$1; try { - var c = eg; - for (C = 1; a < c.length; a++) { - var d = c[a]; + var c2 = eg$1; + for (C$1 = 1; a2 < c2.length; a2++) { + var d2 = c2[a2]; do - d = d(true); - while (null !== d); + d2 = d2(true); + while (null !== d2); } - eg = null; + eg$1 = null; fg = false; - } catch (e2) { - throw null !== eg && (eg = eg.slice(a + 1)), ac(fc, jg), e2; + } catch (e18) { + throw null !== eg$1 && (eg$1 = eg$1.slice(a2 + 1)), ac(fc, jg), e18; } finally { - C = b2, gg = false; + C$1 = b2, gg = false; } } return null; } var kg = [], lg = 0, mg = null, ng = 0, og = [], pg = 0, qg = null, rg = 1, sg = ""; -function tg(a, b2) { +function tg(a2, b2) { kg[lg++] = ng; kg[lg++] = mg; - mg = a; + mg = a2; ng = b2; } -function ug(a, b2, c) { +function ug(a2, b2, c2) { og[pg++] = rg; og[pg++] = sg; og[pg++] = qg; - qg = a; - var d = rg; - a = sg; - var e2 = 32 - oc(d) - 1; - d &= ~(1 << e2); - c += 1; - var f2 = 32 - oc(b2) + e2; + qg = a2; + var d2 = rg; + a2 = sg; + var e18 = 32 - oc(d2) - 1; + d2 &= ~(1 << e18); + c2 += 1; + var f2 = 32 - oc(b2) + e18; if (30 < f2) { - var g = e2 - e2 % 5; - f2 = (d & (1 << g) - 1).toString(32); - d >>= g; - e2 -= g; - rg = 1 << 32 - oc(b2) + e2 | c << e2 | d; - sg = f2 + a; + var g2 = e18 - e18 % 5; + f2 = (d2 & (1 << g2) - 1).toString(32); + d2 >>= g2; + e18 -= g2; + rg = 1 << 32 - oc(b2) + e18 | c2 << e18 | d2; + sg = f2 + a2; } else - rg = 1 << f2 | c << e2 | d, sg = a; + rg = 1 << f2 | c2 << e18 | d2, sg = a2; } -function vg(a) { - null !== a.return && (tg(a, 1), ug(a, 1, 0)); +function vg(a2) { + null !== a2.return && (tg(a2, 1), ug(a2, 1, 0)); } -function wg(a) { - for (; a === mg; ) +function wg(a2) { + for (; a2 === mg; ) mg = kg[--lg], kg[lg] = null, ng = kg[--lg], kg[lg] = null; - for (; a === qg; ) + for (; a2 === qg; ) qg = og[--pg], og[pg] = null, sg = og[--pg], og[pg] = null, rg = og[--pg], og[pg] = null; } -var xg = null, yg = null, I = false, zg = null; -function Ag(a, b2) { - var c = Bg(5, null, null, 0); - c.elementType = "DELETED"; - c.stateNode = b2; - c.return = a; - b2 = a.deletions; - null === b2 ? (a.deletions = [c], a.flags |= 16) : b2.push(c); -} -function Cg(a, b2) { - switch (a.tag) { +var xg = null, yg = null, I$1 = false, zg = null; +function Ag(a2, b2) { + var c2 = Bg(5, null, null, 0); + c2.elementType = "DELETED"; + c2.stateNode = b2; + c2.return = a2; + b2 = a2.deletions; + null === b2 ? (a2.deletions = [c2], a2.flags |= 16) : b2.push(c2); +} +function Cg(a2, b2) { + switch (a2.tag) { case 5: - var c = a.type; - b2 = 1 !== b2.nodeType || c.toLowerCase() !== b2.nodeName.toLowerCase() ? null : b2; - return null !== b2 ? (a.stateNode = b2, xg = a, yg = Lf(b2.firstChild), true) : false; + var c2 = a2.type; + b2 = 1 !== b2.nodeType || c2.toLowerCase() !== b2.nodeName.toLowerCase() ? null : b2; + return null !== b2 ? (a2.stateNode = b2, xg = a2, yg = Lf(b2.firstChild), true) : false; case 6: - return b2 = "" === a.pendingProps || 3 !== b2.nodeType ? null : b2, null !== b2 ? (a.stateNode = b2, xg = a, yg = null, true) : false; + return b2 = "" === a2.pendingProps || 3 !== b2.nodeType ? null : b2, null !== b2 ? (a2.stateNode = b2, xg = a2, yg = null, true) : false; case 13: - return b2 = 8 !== b2.nodeType ? null : b2, null !== b2 ? (c = null !== qg ? { id: rg, overflow: sg } : null, a.memoizedState = { dehydrated: b2, treeContext: c, retryLane: 1073741824 }, c = Bg(18, null, null, 0), c.stateNode = b2, c.return = a, a.child = c, xg = a, yg = null, true) : false; + return b2 = 8 !== b2.nodeType ? null : b2, null !== b2 ? (c2 = null !== qg ? { id: rg, overflow: sg } : null, a2.memoizedState = { dehydrated: b2, treeContext: c2, retryLane: 1073741824 }, c2 = Bg(18, null, null, 0), c2.stateNode = b2, c2.return = a2, a2.child = c2, xg = a2, yg = null, true) : false; default: return false; } } -function Dg(a) { - return 0 !== (a.mode & 1) && 0 === (a.flags & 128); +function Dg(a2) { + return 0 !== (a2.mode & 1) && 0 === (a2.flags & 128); } -function Eg(a) { - if (I) { +function Eg(a2) { + if (I$1) { var b2 = yg; if (b2) { - var c = b2; - if (!Cg(a, b2)) { - if (Dg(a)) - throw Error(p$2(418)); - b2 = Lf(c.nextSibling); - var d = xg; - b2 && Cg(a, b2) ? Ag(d, c) : (a.flags = a.flags & -4097 | 2, I = false, xg = a); + var c2 = b2; + if (!Cg(a2, b2)) { + if (Dg(a2)) + throw Error(p$3(418)); + b2 = Lf(c2.nextSibling); + var d2 = xg; + b2 && Cg(a2, b2) ? Ag(d2, c2) : (a2.flags = a2.flags & -4097 | 2, I$1 = false, xg = a2); } } else { - if (Dg(a)) - throw Error(p$2(418)); - a.flags = a.flags & -4097 | 2; - I = false; - xg = a; + if (Dg(a2)) + throw Error(p$3(418)); + a2.flags = a2.flags & -4097 | 2; + I$1 = false; + xg = a2; } } } -function Fg(a) { - for (a = a.return; null !== a && 5 !== a.tag && 3 !== a.tag && 13 !== a.tag; ) - a = a.return; - xg = a; +function Fg(a2) { + for (a2 = a2.return; null !== a2 && 5 !== a2.tag && 3 !== a2.tag && 13 !== a2.tag; ) + a2 = a2.return; + xg = a2; } -function Gg(a) { - if (a !== xg) +function Gg(a2) { + if (a2 !== xg) return false; - if (!I) - return Fg(a), I = true, false; + if (!I$1) + return Fg(a2), I$1 = true, false; var b2; - (b2 = 3 !== a.tag) && !(b2 = 5 !== a.tag) && (b2 = a.type, b2 = "head" !== b2 && "body" !== b2 && !Ef(a.type, a.memoizedProps)); + (b2 = 3 !== a2.tag) && !(b2 = 5 !== a2.tag) && (b2 = a2.type, b2 = "head" !== b2 && "body" !== b2 && !Ef(a2.type, a2.memoizedProps)); if (b2 && (b2 = yg)) { - if (Dg(a)) - throw Hg(), Error(p$2(418)); + if (Dg(a2)) + throw Hg(), Error(p$3(418)); for (; b2; ) - Ag(a, b2), b2 = Lf(b2.nextSibling); - } - Fg(a); - if (13 === a.tag) { - a = a.memoizedState; - a = null !== a ? a.dehydrated : null; - if (!a) - throw Error(p$2(317)); + Ag(a2, b2), b2 = Lf(b2.nextSibling); + } + Fg(a2); + if (13 === a2.tag) { + a2 = a2.memoizedState; + a2 = null !== a2 ? a2.dehydrated : null; + if (!a2) + throw Error(p$3(317)); a: { - a = a.nextSibling; - for (b2 = 0; a; ) { - if (8 === a.nodeType) { - var c = a.data; - if ("/$" === c) { + a2 = a2.nextSibling; + for (b2 = 0; a2; ) { + if (8 === a2.nodeType) { + var c2 = a2.data; + if ("/$" === c2) { if (0 === b2) { - yg = Lf(a.nextSibling); + yg = Lf(a2.nextSibling); break a; } b2--; } else - "$" !== c && "$!" !== c && "$?" !== c || b2++; + "$" !== c2 && "$!" !== c2 && "$?" !== c2 || b2++; } - a = a.nextSibling; + a2 = a2.nextSibling; } yg = null; } } else - yg = xg ? Lf(a.stateNode.nextSibling) : null; + yg = xg ? Lf(a2.stateNode.nextSibling) : null; return true; } function Hg() { - for (var a = yg; a; ) - a = Lf(a.nextSibling); + for (var a2 = yg; a2; ) + a2 = Lf(a2.nextSibling); } function Ig() { yg = xg = null; - I = false; + I$1 = false; } -function Jg(a) { - null === zg ? zg = [a] : zg.push(a); +function Jg(a2) { + null === zg ? zg = [a2] : zg.push(a2); } var Kg = ua.ReactCurrentBatchConfig; -function Lg(a, b2, c) { - a = c.ref; - if (null !== a && "function" !== typeof a && "object" !== typeof a) { - if (c._owner) { - c = c._owner; - if (c) { - if (1 !== c.tag) - throw Error(p$2(309)); - var d = c.stateNode; - } - if (!d) - throw Error(p$2(147, a)); - var e2 = d, f2 = "" + a; +function Lg(a2, b2, c2) { + a2 = c2.ref; + if (null !== a2 && "function" !== typeof a2 && "object" !== typeof a2) { + if (c2._owner) { + c2 = c2._owner; + if (c2) { + if (1 !== c2.tag) + throw Error(p$3(309)); + var d2 = c2.stateNode; + } + if (!d2) + throw Error(p$3(147, a2)); + var e18 = d2, f2 = "" + a2; if (null !== b2 && null !== b2.ref && "function" === typeof b2.ref && b2.ref._stringRef === f2) return b2.ref; - b2 = function(a2) { - var b3 = e2.refs; - null === a2 ? delete b3[f2] : b3[f2] = a2; + b2 = function(a3) { + var b3 = e18.refs; + null === a3 ? delete b3[f2] : b3[f2] = a3; }; b2._stringRef = f2; return b2; } - if ("string" !== typeof a) - throw Error(p$2(284)); - if (!c._owner) - throw Error(p$2(290, a)); + if ("string" !== typeof a2) + throw Error(p$3(284)); + if (!c2._owner) + throw Error(p$3(290, a2)); } - return a; + return a2; } -function Mg(a, b2) { - a = Object.prototype.toString.call(b2); - throw Error(p$2(31, "[object Object]" === a ? "object with keys {" + Object.keys(b2).join(", ") + "}" : a)); +function Mg(a2, b2) { + a2 = Object.prototype.toString.call(b2); + throw Error(p$3(31, "[object Object]" === a2 ? "object with keys {" + Object.keys(b2).join(", ") + "}" : a2)); } -function Ng(a) { - var b2 = a._init; - return b2(a._payload); +function Ng(a2) { + var b2 = a2._init; + return b2(a2._payload); } -function Og(a) { - function b2(b3, c2) { - if (a) { - var d2 = b3.deletions; - null === d2 ? (b3.deletions = [c2], b3.flags |= 16) : d2.push(c2); +function Og(a2) { + function b2(b3, c3) { + if (a2) { + var d3 = b3.deletions; + null === d3 ? (b3.deletions = [c3], b3.flags |= 16) : d3.push(c3); } } - function c(c2, d2) { - if (!a) + function c2(c3, d3) { + if (!a2) return null; - for (; null !== d2; ) - b2(c2, d2), d2 = d2.sibling; + for (; null !== d3; ) + b2(c3, d3), d3 = d3.sibling; return null; } - function d(a2, b3) { - for (a2 = /* @__PURE__ */ new Map(); null !== b3; ) - null !== b3.key ? a2.set(b3.key, b3) : a2.set(b3.index, b3), b3 = b3.sibling; - return a2; - } - function e2(a2, b3) { - a2 = Pg(a2, b3); - a2.index = 0; - a2.sibling = null; - return a2; - } - function f2(b3, c2, d2) { - b3.index = d2; - if (!a) - return b3.flags |= 1048576, c2; - d2 = b3.alternate; - if (null !== d2) - return d2 = d2.index, d2 < c2 ? (b3.flags |= 2, c2) : d2; + function d2(a3, b3) { + for (a3 = /* @__PURE__ */ new Map(); null !== b3; ) + null !== b3.key ? a3.set(b3.key, b3) : a3.set(b3.index, b3), b3 = b3.sibling; + return a3; + } + function e18(a3, b3) { + a3 = Pg(a3, b3); + a3.index = 0; + a3.sibling = null; + return a3; + } + function f2(b3, c3, d3) { + b3.index = d3; + if (!a2) + return b3.flags |= 1048576, c3; + d3 = b3.alternate; + if (null !== d3) + return d3 = d3.index, d3 < c3 ? (b3.flags |= 2, c3) : d3; b3.flags |= 2; - return c2; + return c3; } - function g(b3) { - a && null === b3.alternate && (b3.flags |= 2); + function g2(b3) { + a2 && null === b3.alternate && (b3.flags |= 2); return b3; } - function h2(a2, b3, c2, d2) { + function h2(a3, b3, c3, d3) { if (null === b3 || 6 !== b3.tag) - return b3 = Qg(c2, a2.mode, d2), b3.return = a2, b3; - b3 = e2(b3, c2); - b3.return = a2; + return b3 = Qg(c3, a3.mode, d3), b3.return = a3, b3; + b3 = e18(b3, c3); + b3.return = a3; return b3; } - function k2(a2, b3, c2, d2) { - var f3 = c2.type; + function k2(a3, b3, c3, d3) { + var f3 = c3.type; if (f3 === ya) - return m2(a2, b3, c2.props.children, d2, c2.key); + return m2(a3, b3, c3.props.children, d3, c3.key); if (null !== b3 && (b3.elementType === f3 || "object" === typeof f3 && null !== f3 && f3.$$typeof === Ha && Ng(f3) === b3.type)) - return d2 = e2(b3, c2.props), d2.ref = Lg(a2, b3, c2), d2.return = a2, d2; - d2 = Rg(c2.type, c2.key, c2.props, null, a2.mode, d2); - d2.ref = Lg(a2, b3, c2); - d2.return = a2; - return d2; - } - function l2(a2, b3, c2, d2) { - if (null === b3 || 4 !== b3.tag || b3.stateNode.containerInfo !== c2.containerInfo || b3.stateNode.implementation !== c2.implementation) - return b3 = Sg(c2, a2.mode, d2), b3.return = a2, b3; - b3 = e2(b3, c2.children || []); - b3.return = a2; + return d3 = e18(b3, c3.props), d3.ref = Lg(a3, b3, c3), d3.return = a3, d3; + d3 = Rg(c3.type, c3.key, c3.props, null, a3.mode, d3); + d3.ref = Lg(a3, b3, c3); + d3.return = a3; + return d3; + } + function l2(a3, b3, c3, d3) { + if (null === b3 || 4 !== b3.tag || b3.stateNode.containerInfo !== c3.containerInfo || b3.stateNode.implementation !== c3.implementation) + return b3 = Sg(c3, a3.mode, d3), b3.return = a3, b3; + b3 = e18(b3, c3.children || []); + b3.return = a3; return b3; } - function m2(a2, b3, c2, d2, f3) { + function m2(a3, b3, c3, d3, f3) { if (null === b3 || 7 !== b3.tag) - return b3 = Tg(c2, a2.mode, d2, f3), b3.return = a2, b3; - b3 = e2(b3, c2); - b3.return = a2; + return b3 = Tg(c3, a3.mode, d3, f3), b3.return = a3, b3; + b3 = e18(b3, c3); + b3.return = a3; return b3; } - function q2(a2, b3, c2) { + function q2(a3, b3, c3) { if ("string" === typeof b3 && "" !== b3 || "number" === typeof b3) - return b3 = Qg("" + b3, a2.mode, c2), b3.return = a2, b3; + return b3 = Qg("" + b3, a3.mode, c3), b3.return = a3, b3; if ("object" === typeof b3 && null !== b3) { switch (b3.$$typeof) { case va: - return c2 = Rg(b3.type, b3.key, b3.props, null, a2.mode, c2), c2.ref = Lg(a2, null, b3), c2.return = a2, c2; + return c3 = Rg(b3.type, b3.key, b3.props, null, a3.mode, c3), c3.ref = Lg(a3, null, b3), c3.return = a3, c3; case wa: - return b3 = Sg(b3, a2.mode, c2), b3.return = a2, b3; + return b3 = Sg(b3, a3.mode, c3), b3.return = a3, b3; case Ha: - var d2 = b3._init; - return q2(a2, d2(b3._payload), c2); + var d3 = b3._init; + return q2(a3, d3(b3._payload), c3); } - if (eb(b3) || Ka(b3)) - return b3 = Tg(b3, a2.mode, c2, null), b3.return = a2, b3; - Mg(a2, b3); + if (eb$1(b3) || Ka(b3)) + return b3 = Tg(b3, a3.mode, c3, null), b3.return = a3, b3; + Mg(a3, b3); } return null; } - function r2(a2, b3, c2, d2) { - var e3 = null !== b3 ? b3.key : null; - if ("string" === typeof c2 && "" !== c2 || "number" === typeof c2) - return null !== e3 ? null : h2(a2, b3, "" + c2, d2); - if ("object" === typeof c2 && null !== c2) { - switch (c2.$$typeof) { + function r2(a3, b3, c3, d3) { + var e19 = null !== b3 ? b3.key : null; + if ("string" === typeof c3 && "" !== c3 || "number" === typeof c3) + return null !== e19 ? null : h2(a3, b3, "" + c3, d3); + if ("object" === typeof c3 && null !== c3) { + switch (c3.$$typeof) { case va: - return c2.key === e3 ? k2(a2, b3, c2, d2) : null; + return c3.key === e19 ? k2(a3, b3, c3, d3) : null; case wa: - return c2.key === e3 ? l2(a2, b3, c2, d2) : null; + return c3.key === e19 ? l2(a3, b3, c3, d3) : null; case Ha: - return e3 = c2._init, r2( - a2, + return e19 = c3._init, r2( + a3, b3, - e3(c2._payload), - d2 + e19(c3._payload), + d3 ); } - if (eb(c2) || Ka(c2)) - return null !== e3 ? null : m2(a2, b3, c2, d2, null); - Mg(a2, c2); + if (eb$1(c3) || Ka(c3)) + return null !== e19 ? null : m2(a3, b3, c3, d3, null); + Mg(a3, c3); } return null; } - function y2(a2, b3, c2, d2, e3) { - if ("string" === typeof d2 && "" !== d2 || "number" === typeof d2) - return a2 = a2.get(c2) || null, h2(b3, a2, "" + d2, e3); - if ("object" === typeof d2 && null !== d2) { - switch (d2.$$typeof) { + function y2(a3, b3, c3, d3, e19) { + if ("string" === typeof d3 && "" !== d3 || "number" === typeof d3) + return a3 = a3.get(c3) || null, h2(b3, a3, "" + d3, e19); + if ("object" === typeof d3 && null !== d3) { + switch (d3.$$typeof) { case va: - return a2 = a2.get(null === d2.key ? c2 : d2.key) || null, k2(b3, a2, d2, e3); + return a3 = a3.get(null === d3.key ? c3 : d3.key) || null, k2(b3, a3, d3, e19); case wa: - return a2 = a2.get(null === d2.key ? c2 : d2.key) || null, l2(b3, a2, d2, e3); + return a3 = a3.get(null === d3.key ? c3 : d3.key) || null, l2(b3, a3, d3, e19); case Ha: - var f3 = d2._init; - return y2(a2, b3, c2, f3(d2._payload), e3); + var f3 = d3._init; + return y2(a3, b3, c3, f3(d3._payload), e19); } - if (eb(d2) || Ka(d2)) - return a2 = a2.get(c2) || null, m2(b3, a2, d2, e3, null); - Mg(b3, d2); + if (eb$1(d3) || Ka(d3)) + return a3 = a3.get(c3) || null, m2(b3, a3, d3, e19, null); + Mg(b3, d3); } return null; } - function n2(e3, g2, h3, k3) { - for (var l3 = null, m3 = null, u2 = g2, w2 = g2 = 0, x2 = null; null !== u2 && w2 < h3.length; w2++) { + function n2(e19, g3, h3, k3) { + for (var l3 = null, m3 = null, u2 = g3, w2 = g3 = 0, x2 = null; null !== u2 && w2 < h3.length; w2++) { u2.index > w2 ? (x2 = u2, u2 = null) : x2 = u2.sibling; - var n3 = r2(e3, u2, h3[w2], k3); + var n3 = r2(e19, u2, h3[w2], k3); if (null === n3) { null === u2 && (u2 = x2); break; } - a && u2 && null === n3.alternate && b2(e3, u2); - g2 = f2(n3, g2, w2); + a2 && u2 && null === n3.alternate && b2(e19, u2); + g3 = f2(n3, g3, w2); null === m3 ? l3 = n3 : m3.sibling = n3; m3 = n3; u2 = x2; } if (w2 === h3.length) - return c(e3, u2), I && tg(e3, w2), l3; + return c2(e19, u2), I$1 && tg(e19, w2), l3; if (null === u2) { for (; w2 < h3.length; w2++) - u2 = q2(e3, h3[w2], k3), null !== u2 && (g2 = f2(u2, g2, w2), null === m3 ? l3 = u2 : m3.sibling = u2, m3 = u2); - I && tg(e3, w2); + u2 = q2(e19, h3[w2], k3), null !== u2 && (g3 = f2(u2, g3, w2), null === m3 ? l3 = u2 : m3.sibling = u2, m3 = u2); + I$1 && tg(e19, w2); return l3; } - for (u2 = d(e3, u2); w2 < h3.length; w2++) - x2 = y2(u2, e3, w2, h3[w2], k3), null !== x2 && (a && null !== x2.alternate && u2.delete(null === x2.key ? w2 : x2.key), g2 = f2(x2, g2, w2), null === m3 ? l3 = x2 : m3.sibling = x2, m3 = x2); - a && u2.forEach(function(a2) { - return b2(e3, a2); + for (u2 = d2(e19, u2); w2 < h3.length; w2++) + x2 = y2(u2, e19, w2, h3[w2], k3), null !== x2 && (a2 && null !== x2.alternate && u2.delete(null === x2.key ? w2 : x2.key), g3 = f2(x2, g3, w2), null === m3 ? l3 = x2 : m3.sibling = x2, m3 = x2); + a2 && u2.forEach(function(a3) { + return b2(e19, a3); }); - I && tg(e3, w2); + I$1 && tg(e19, w2); return l3; } - function t2(e3, g2, h3, k3) { + function t2(e19, g3, h3, k3) { var l3 = Ka(h3); if ("function" !== typeof l3) - throw Error(p$2(150)); + throw Error(p$3(150)); h3 = l3.call(h3); if (null == h3) - throw Error(p$2(151)); - for (var u2 = l3 = null, m3 = g2, w2 = g2 = 0, x2 = null, n3 = h3.next(); null !== m3 && !n3.done; w2++, n3 = h3.next()) { + throw Error(p$3(151)); + for (var u2 = l3 = null, m3 = g3, w2 = g3 = 0, x2 = null, n3 = h3.next(); null !== m3 && !n3.done; w2++, n3 = h3.next()) { m3.index > w2 ? (x2 = m3, m3 = null) : x2 = m3.sibling; - var t3 = r2(e3, m3, n3.value, k3); + var t3 = r2(e19, m3, n3.value, k3); if (null === t3) { null === m3 && (m3 = x2); break; } - a && m3 && null === t3.alternate && b2(e3, m3); - g2 = f2(t3, g2, w2); + a2 && m3 && null === t3.alternate && b2(e19, m3); + g3 = f2(t3, g3, w2); null === u2 ? l3 = t3 : u2.sibling = t3; u2 = t3; m3 = x2; } if (n3.done) - return c( - e3, + return c2( + e19, m3 - ), I && tg(e3, w2), l3; + ), I$1 && tg(e19, w2), l3; if (null === m3) { for (; !n3.done; w2++, n3 = h3.next()) - n3 = q2(e3, n3.value, k3), null !== n3 && (g2 = f2(n3, g2, w2), null === u2 ? l3 = n3 : u2.sibling = n3, u2 = n3); - I && tg(e3, w2); + n3 = q2(e19, n3.value, k3), null !== n3 && (g3 = f2(n3, g3, w2), null === u2 ? l3 = n3 : u2.sibling = n3, u2 = n3); + I$1 && tg(e19, w2); return l3; } - for (m3 = d(e3, m3); !n3.done; w2++, n3 = h3.next()) - n3 = y2(m3, e3, w2, n3.value, k3), null !== n3 && (a && null !== n3.alternate && m3.delete(null === n3.key ? w2 : n3.key), g2 = f2(n3, g2, w2), null === u2 ? l3 = n3 : u2.sibling = n3, u2 = n3); - a && m3.forEach(function(a2) { - return b2(e3, a2); + for (m3 = d2(e19, m3); !n3.done; w2++, n3 = h3.next()) + n3 = y2(m3, e19, w2, n3.value, k3), null !== n3 && (a2 && null !== n3.alternate && m3.delete(null === n3.key ? w2 : n3.key), g3 = f2(n3, g3, w2), null === u2 ? l3 = n3 : u2.sibling = n3, u2 = n3); + a2 && m3.forEach(function(a3) { + return b2(e19, a3); }); - I && tg(e3, w2); + I$1 && tg(e19, w2); return l3; } - function J2(a2, d2, f3, h3) { + function J2(a3, d3, f3, h3) { "object" === typeof f3 && null !== f3 && f3.type === ya && null === f3.key && (f3 = f3.props.children); if ("object" === typeof f3 && null !== f3) { switch (f3.$$typeof) { case va: a: { - for (var k3 = f3.key, l3 = d2; null !== l3; ) { + for (var k3 = f3.key, l3 = d3; null !== l3; ) { if (l3.key === k3) { k3 = f3.type; if (k3 === ya) { if (7 === l3.tag) { - c(a2, l3.sibling); - d2 = e2(l3, f3.props.children); - d2.return = a2; - a2 = d2; + c2(a3, l3.sibling); + d3 = e18(l3, f3.props.children); + d3.return = a3; + a3 = d3; break a; } } else if (l3.elementType === k3 || "object" === typeof k3 && null !== k3 && k3.$$typeof === Ha && Ng(k3) === l3.type) { - c(a2, l3.sibling); - d2 = e2(l3, f3.props); - d2.ref = Lg(a2, l3, f3); - d2.return = a2; - a2 = d2; + c2(a3, l3.sibling); + d3 = e18(l3, f3.props); + d3.ref = Lg(a3, l3, f3); + d3.return = a3; + a3 = d3; break a; } - c(a2, l3); + c2(a3, l3); break; } else - b2(a2, l3); + b2(a3, l3); l3 = l3.sibling; } - f3.type === ya ? (d2 = Tg(f3.props.children, a2.mode, h3, f3.key), d2.return = a2, a2 = d2) : (h3 = Rg(f3.type, f3.key, f3.props, null, a2.mode, h3), h3.ref = Lg(a2, d2, f3), h3.return = a2, a2 = h3); + f3.type === ya ? (d3 = Tg(f3.props.children, a3.mode, h3, f3.key), d3.return = a3, a3 = d3) : (h3 = Rg(f3.type, f3.key, f3.props, null, a3.mode, h3), h3.ref = Lg(a3, d3, f3), h3.return = a3, a3 = h3); } - return g(a2); + return g2(a3); case wa: a: { - for (l3 = f3.key; null !== d2; ) { - if (d2.key === l3) - if (4 === d2.tag && d2.stateNode.containerInfo === f3.containerInfo && d2.stateNode.implementation === f3.implementation) { - c(a2, d2.sibling); - d2 = e2(d2, f3.children || []); - d2.return = a2; - a2 = d2; + for (l3 = f3.key; null !== d3; ) { + if (d3.key === l3) + if (4 === d3.tag && d3.stateNode.containerInfo === f3.containerInfo && d3.stateNode.implementation === f3.implementation) { + c2(a3, d3.sibling); + d3 = e18(d3, f3.children || []); + d3.return = a3; + a3 = d3; break a; } else { - c(a2, d2); + c2(a3, d3); break; } else - b2(a2, d2); - d2 = d2.sibling; + b2(a3, d3); + d3 = d3.sibling; } - d2 = Sg(f3, a2.mode, h3); - d2.return = a2; - a2 = d2; + d3 = Sg(f3, a3.mode, h3); + d3.return = a3; + a3 = d3; } - return g(a2); + return g2(a3); case Ha: - return l3 = f3._init, J2(a2, d2, l3(f3._payload), h3); + return l3 = f3._init, J2(a3, d3, l3(f3._payload), h3); } - if (eb(f3)) - return n2(a2, d2, f3, h3); + if (eb$1(f3)) + return n2(a3, d3, f3, h3); if (Ka(f3)) - return t2(a2, d2, f3, h3); - Mg(a2, f3); + return t2(a3, d3, f3, h3); + Mg(a3, f3); } - return "string" === typeof f3 && "" !== f3 || "number" === typeof f3 ? (f3 = "" + f3, null !== d2 && 6 === d2.tag ? (c(a2, d2.sibling), d2 = e2(d2, f3), d2.return = a2, a2 = d2) : (c(a2, d2), d2 = Qg(f3, a2.mode, h3), d2.return = a2, a2 = d2), g(a2)) : c(a2, d2); + return "string" === typeof f3 && "" !== f3 || "number" === typeof f3 ? (f3 = "" + f3, null !== d3 && 6 === d3.tag ? (c2(a3, d3.sibling), d3 = e18(d3, f3), d3.return = a3, a3 = d3) : (c2(a3, d3), d3 = Qg(f3, a3.mode, h3), d3.return = a3, a3 = d3), g2(a3)) : c2(a3, d3); } return J2; } @@ -3468,137 +3487,137 @@ var Ug = Og(true), Vg = Og(false), Wg = Uf(null), Xg = null, Yg = null, Zg = nul function $g() { Zg = Yg = Xg = null; } -function ah(a) { +function ah(a2) { var b2 = Wg.current; - E(Wg); - a._currentValue = b2; -} -function bh(a, b2, c) { - for (; null !== a; ) { - var d = a.alternate; - (a.childLanes & b2) !== b2 ? (a.childLanes |= b2, null !== d && (d.childLanes |= b2)) : null !== d && (d.childLanes & b2) !== b2 && (d.childLanes |= b2); - if (a === c) + E$1(Wg); + a2._currentValue = b2; +} +function bh(a2, b2, c2) { + for (; null !== a2; ) { + var d2 = a2.alternate; + (a2.childLanes & b2) !== b2 ? (a2.childLanes |= b2, null !== d2 && (d2.childLanes |= b2)) : null !== d2 && (d2.childLanes & b2) !== b2 && (d2.childLanes |= b2); + if (a2 === c2) break; - a = a.return; + a2 = a2.return; } } -function ch(a, b2) { - Xg = a; +function ch(a2, b2) { + Xg = a2; Zg = Yg = null; - a = a.dependencies; - null !== a && null !== a.firstContext && (0 !== (a.lanes & b2) && (dh = true), a.firstContext = null); + a2 = a2.dependencies; + null !== a2 && null !== a2.firstContext && (0 !== (a2.lanes & b2) && (dh = true), a2.firstContext = null); } -function eh(a) { - var b2 = a._currentValue; - if (Zg !== a) - if (a = { context: a, memoizedValue: b2, next: null }, null === Yg) { +function eh$1(a2) { + var b2 = a2._currentValue; + if (Zg !== a2) + if (a2 = { context: a2, memoizedValue: b2, next: null }, null === Yg) { if (null === Xg) - throw Error(p$2(308)); - Yg = a; - Xg.dependencies = { lanes: 0, firstContext: a }; + throw Error(p$3(308)); + Yg = a2; + Xg.dependencies = { lanes: 0, firstContext: a2 }; } else - Yg = Yg.next = a; + Yg = Yg.next = a2; return b2; } var fh = null; -function gh(a) { - null === fh ? fh = [a] : fh.push(a); -} -function hh(a, b2, c, d) { - var e2 = b2.interleaved; - null === e2 ? (c.next = c, gh(b2)) : (c.next = e2.next, e2.next = c); - b2.interleaved = c; - return ih(a, d); -} -function ih(a, b2) { - a.lanes |= b2; - var c = a.alternate; - null !== c && (c.lanes |= b2); - c = a; - for (a = a.return; null !== a; ) - a.childLanes |= b2, c = a.alternate, null !== c && (c.childLanes |= b2), c = a, a = a.return; - return 3 === c.tag ? c.stateNode : null; +function gh(a2) { + null === fh ? fh = [a2] : fh.push(a2); +} +function hh(a2, b2, c2, d2) { + var e18 = b2.interleaved; + null === e18 ? (c2.next = c2, gh(b2)) : (c2.next = e18.next, e18.next = c2); + b2.interleaved = c2; + return ih(a2, d2); +} +function ih(a2, b2) { + a2.lanes |= b2; + var c2 = a2.alternate; + null !== c2 && (c2.lanes |= b2); + c2 = a2; + for (a2 = a2.return; null !== a2; ) + a2.childLanes |= b2, c2 = a2.alternate, null !== c2 && (c2.childLanes |= b2), c2 = a2, a2 = a2.return; + return 3 === c2.tag ? c2.stateNode : null; } var jh = false; -function kh(a) { - a.updateQueue = { baseState: a.memoizedState, firstBaseUpdate: null, lastBaseUpdate: null, shared: { pending: null, interleaved: null, lanes: 0 }, effects: null }; +function kh(a2) { + a2.updateQueue = { baseState: a2.memoizedState, firstBaseUpdate: null, lastBaseUpdate: null, shared: { pending: null, interleaved: null, lanes: 0 }, effects: null }; } -function lh(a, b2) { - a = a.updateQueue; - b2.updateQueue === a && (b2.updateQueue = { baseState: a.baseState, firstBaseUpdate: a.firstBaseUpdate, lastBaseUpdate: a.lastBaseUpdate, shared: a.shared, effects: a.effects }); +function lh(a2, b2) { + a2 = a2.updateQueue; + b2.updateQueue === a2 && (b2.updateQueue = { baseState: a2.baseState, firstBaseUpdate: a2.firstBaseUpdate, lastBaseUpdate: a2.lastBaseUpdate, shared: a2.shared, effects: a2.effects }); } -function mh(a, b2) { - return { eventTime: a, lane: b2, tag: 0, payload: null, callback: null, next: null }; +function mh(a2, b2) { + return { eventTime: a2, lane: b2, tag: 0, payload: null, callback: null, next: null }; } -function nh(a, b2, c) { - var d = a.updateQueue; - if (null === d) +function nh(a2, b2, c2) { + var d2 = a2.updateQueue; + if (null === d2) return null; - d = d.shared; - if (0 !== (K & 2)) { - var e2 = d.pending; - null === e2 ? b2.next = b2 : (b2.next = e2.next, e2.next = b2); - d.pending = b2; - return ih(a, c); - } - e2 = d.interleaved; - null === e2 ? (b2.next = b2, gh(d)) : (b2.next = e2.next, e2.next = b2); - d.interleaved = b2; - return ih(a, c); -} -function oh(a, b2, c) { + d2 = d2.shared; + if (0 !== (K$1 & 2)) { + var e18 = d2.pending; + null === e18 ? b2.next = b2 : (b2.next = e18.next, e18.next = b2); + d2.pending = b2; + return ih(a2, c2); + } + e18 = d2.interleaved; + null === e18 ? (b2.next = b2, gh(d2)) : (b2.next = e18.next, e18.next = b2); + d2.interleaved = b2; + return ih(a2, c2); +} +function oh(a2, b2, c2) { b2 = b2.updateQueue; - if (null !== b2 && (b2 = b2.shared, 0 !== (c & 4194240))) { - var d = b2.lanes; - d &= a.pendingLanes; - c |= d; - b2.lanes = c; - Cc(a, c); - } -} -function ph(a, b2) { - var c = a.updateQueue, d = a.alternate; - if (null !== d && (d = d.updateQueue, c === d)) { - var e2 = null, f2 = null; - c = c.firstBaseUpdate; - if (null !== c) { + if (null !== b2 && (b2 = b2.shared, 0 !== (c2 & 4194240))) { + var d2 = b2.lanes; + d2 &= a2.pendingLanes; + c2 |= d2; + b2.lanes = c2; + Cc(a2, c2); + } +} +function ph(a2, b2) { + var c2 = a2.updateQueue, d2 = a2.alternate; + if (null !== d2 && (d2 = d2.updateQueue, c2 === d2)) { + var e18 = null, f2 = null; + c2 = c2.firstBaseUpdate; + if (null !== c2) { do { - var g = { eventTime: c.eventTime, lane: c.lane, tag: c.tag, payload: c.payload, callback: c.callback, next: null }; - null === f2 ? e2 = f2 = g : f2 = f2.next = g; - c = c.next; - } while (null !== c); - null === f2 ? e2 = f2 = b2 : f2 = f2.next = b2; + var g2 = { eventTime: c2.eventTime, lane: c2.lane, tag: c2.tag, payload: c2.payload, callback: c2.callback, next: null }; + null === f2 ? e18 = f2 = g2 : f2 = f2.next = g2; + c2 = c2.next; + } while (null !== c2); + null === f2 ? e18 = f2 = b2 : f2 = f2.next = b2; } else - e2 = f2 = b2; - c = { baseState: d.baseState, firstBaseUpdate: e2, lastBaseUpdate: f2, shared: d.shared, effects: d.effects }; - a.updateQueue = c; + e18 = f2 = b2; + c2 = { baseState: d2.baseState, firstBaseUpdate: e18, lastBaseUpdate: f2, shared: d2.shared, effects: d2.effects }; + a2.updateQueue = c2; return; } - a = c.lastBaseUpdate; - null === a ? c.firstBaseUpdate = b2 : a.next = b2; - c.lastBaseUpdate = b2; + a2 = c2.lastBaseUpdate; + null === a2 ? c2.firstBaseUpdate = b2 : a2.next = b2; + c2.lastBaseUpdate = b2; } -function qh(a, b2, c, d) { - var e2 = a.updateQueue; +function qh(a2, b2, c2, d2) { + var e18 = a2.updateQueue; jh = false; - var f2 = e2.firstBaseUpdate, g = e2.lastBaseUpdate, h2 = e2.shared.pending; + var f2 = e18.firstBaseUpdate, g2 = e18.lastBaseUpdate, h2 = e18.shared.pending; if (null !== h2) { - e2.shared.pending = null; + e18.shared.pending = null; var k2 = h2, l2 = k2.next; k2.next = null; - null === g ? f2 = l2 : g.next = l2; - g = k2; - var m2 = a.alternate; - null !== m2 && (m2 = m2.updateQueue, h2 = m2.lastBaseUpdate, h2 !== g && (null === h2 ? m2.firstBaseUpdate = l2 : h2.next = l2, m2.lastBaseUpdate = k2)); + null === g2 ? f2 = l2 : g2.next = l2; + g2 = k2; + var m2 = a2.alternate; + null !== m2 && (m2 = m2.updateQueue, h2 = m2.lastBaseUpdate, h2 !== g2 && (null === h2 ? m2.firstBaseUpdate = l2 : h2.next = l2, m2.lastBaseUpdate = k2)); } if (null !== f2) { - var q2 = e2.baseState; - g = 0; + var q2 = e18.baseState; + g2 = 0; m2 = l2 = k2 = null; h2 = f2; do { var r2 = h2.lane, y2 = h2.eventTime; - if ((d & r2) === r2) { + if ((d2 & r2) === r2) { null !== m2 && (m2 = m2.next = { eventTime: y2, lane: 0, @@ -3608,9 +3627,9 @@ function qh(a, b2, c, d) { next: null }); a: { - var n2 = a, t2 = h2; + var n2 = a2, t2 = h2; r2 = b2; - y2 = c; + y2 = c2; switch (t2.tag) { case 1: n2 = t2.payload; @@ -3627,96 +3646,96 @@ function qh(a, b2, c, d) { r2 = "function" === typeof n2 ? n2.call(y2, q2, r2) : n2; if (null === r2 || void 0 === r2) break a; - q2 = A({}, q2, r2); + q2 = A$1({}, q2, r2); break a; case 2: jh = true; } } - null !== h2.callback && 0 !== h2.lane && (a.flags |= 64, r2 = e2.effects, null === r2 ? e2.effects = [h2] : r2.push(h2)); + null !== h2.callback && 0 !== h2.lane && (a2.flags |= 64, r2 = e18.effects, null === r2 ? e18.effects = [h2] : r2.push(h2)); } else - y2 = { eventTime: y2, lane: r2, tag: h2.tag, payload: h2.payload, callback: h2.callback, next: null }, null === m2 ? (l2 = m2 = y2, k2 = q2) : m2 = m2.next = y2, g |= r2; + y2 = { eventTime: y2, lane: r2, tag: h2.tag, payload: h2.payload, callback: h2.callback, next: null }, null === m2 ? (l2 = m2 = y2, k2 = q2) : m2 = m2.next = y2, g2 |= r2; h2 = h2.next; if (null === h2) - if (h2 = e2.shared.pending, null === h2) + if (h2 = e18.shared.pending, null === h2) break; else - r2 = h2, h2 = r2.next, r2.next = null, e2.lastBaseUpdate = r2, e2.shared.pending = null; + r2 = h2, h2 = r2.next, r2.next = null, e18.lastBaseUpdate = r2, e18.shared.pending = null; } while (1); null === m2 && (k2 = q2); - e2.baseState = k2; - e2.firstBaseUpdate = l2; - e2.lastBaseUpdate = m2; - b2 = e2.shared.interleaved; + e18.baseState = k2; + e18.firstBaseUpdate = l2; + e18.lastBaseUpdate = m2; + b2 = e18.shared.interleaved; if (null !== b2) { - e2 = b2; + e18 = b2; do - g |= e2.lane, e2 = e2.next; - while (e2 !== b2); + g2 |= e18.lane, e18 = e18.next; + while (e18 !== b2); } else - null === f2 && (e2.shared.lanes = 0); - rh |= g; - a.lanes = g; - a.memoizedState = q2; + null === f2 && (e18.shared.lanes = 0); + rh$2 |= g2; + a2.lanes = g2; + a2.memoizedState = q2; } } -function sh(a, b2, c) { - a = b2.effects; +function sh$1(a2, b2, c2) { + a2 = b2.effects; b2.effects = null; - if (null !== a) - for (b2 = 0; b2 < a.length; b2++) { - var d = a[b2], e2 = d.callback; - if (null !== e2) { - d.callback = null; - d = c; - if ("function" !== typeof e2) - throw Error(p$2(191, e2)); - e2.call(d); + if (null !== a2) + for (b2 = 0; b2 < a2.length; b2++) { + var d2 = a2[b2], e18 = d2.callback; + if (null !== e18) { + d2.callback = null; + d2 = c2; + if ("function" !== typeof e18) + throw Error(p$3(191, e18)); + e18.call(d2); } } } var th = {}, uh = Uf(th), vh = Uf(th), wh = Uf(th); -function xh(a) { - if (a === th) - throw Error(p$2(174)); - return a; -} -function yh(a, b2) { - G(wh, b2); - G(vh, a); - G(uh, th); - a = b2.nodeType; - switch (a) { +function xh(a2) { + if (a2 === th) + throw Error(p$3(174)); + return a2; +} +function yh(a2, b2) { + G$1(wh, b2); + G$1(vh, a2); + G$1(uh, th); + a2 = b2.nodeType; + switch (a2) { case 9: case 11: b2 = (b2 = b2.documentElement) ? b2.namespaceURI : lb(null, ""); break; default: - a = 8 === a ? b2.parentNode : b2, b2 = a.namespaceURI || null, a = a.tagName, b2 = lb(b2, a); + a2 = 8 === a2 ? b2.parentNode : b2, b2 = a2.namespaceURI || null, a2 = a2.tagName, b2 = lb(b2, a2); } - E(uh); - G(uh, b2); + E$1(uh); + G$1(uh, b2); } function zh() { - E(uh); - E(vh); - E(wh); + E$1(uh); + E$1(vh); + E$1(wh); } -function Ah(a) { +function Ah(a2) { xh(wh.current); var b2 = xh(uh.current); - var c = lb(b2, a.type); - b2 !== c && (G(vh, a), G(uh, c)); + var c2 = lb(b2, a2.type); + b2 !== c2 && (G$1(vh, a2), G$1(uh, c2)); } -function Bh(a) { - vh.current === a && (E(uh), E(vh)); +function Bh(a2) { + vh.current === a2 && (E$1(uh), E$1(vh)); } var L = Uf(0); -function Ch(a) { - for (var b2 = a; null !== b2; ) { +function Ch(a2) { + for (var b2 = a2; null !== b2; ) { if (13 === b2.tag) { - var c = b2.memoizedState; - if (null !== c && (c = c.dehydrated, null === c || "$?" === c.data || "$!" === c.data)) + var c2 = b2.memoizedState; + if (null !== c2 && (c2 = c2.dehydrated, null === c2 || "$?" === c2.data || "$!" === c2.data)) return b2; } else if (19 === b2.tag && void 0 !== b2.memoizedProps.revealOrder) { if (0 !== (b2.flags & 128)) @@ -3726,10 +3745,10 @@ function Ch(a) { b2 = b2.child; continue; } - if (b2 === a) + if (b2 === a2) break; for (; null === b2.sibling; ) { - if (null === b2.return || b2.return === a) + if (null === b2.return || b2.return === a2) return null; b2 = b2.return; } @@ -3740,107 +3759,107 @@ function Ch(a) { } var Dh = []; function Eh() { - for (var a = 0; a < Dh.length; a++) - Dh[a]._workInProgressVersionPrimary = null; + for (var a2 = 0; a2 < Dh.length; a2++) + Dh[a2]._workInProgressVersionPrimary = null; Dh.length = 0; } -var Fh = ua.ReactCurrentDispatcher, Gh = ua.ReactCurrentBatchConfig, Hh = 0, M = null, N$1 = null, O = null, Ih = false, Jh = false, Kh = 0, Lh = 0; -function P() { - throw Error(p$2(321)); +var Fh = ua.ReactCurrentDispatcher, Gh = ua.ReactCurrentBatchConfig, Hh = 0, M$1 = null, N$2 = null, O$2 = null, Ih = false, Jh = false, Kh$1 = 0, Lh = 0; +function P$1() { + throw Error(p$3(321)); } -function Mh(a, b2) { +function Mh(a2, b2) { if (null === b2) return false; - for (var c = 0; c < b2.length && c < a.length; c++) - if (!He(a[c], b2[c])) + for (var c2 = 0; c2 < b2.length && c2 < a2.length; c2++) + if (!He(a2[c2], b2[c2])) return false; return true; } -function Nh(a, b2, c, d, e2, f2) { +function Nh(a2, b2, c2, d2, e18, f2) { Hh = f2; - M = b2; + M$1 = b2; b2.memoizedState = null; b2.updateQueue = null; b2.lanes = 0; - Fh.current = null === a || null === a.memoizedState ? Oh : Ph; - a = c(d, e2); + Fh.current = null === a2 || null === a2.memoizedState ? Oh : Ph; + a2 = c2(d2, e18); if (Jh) { f2 = 0; do { Jh = false; - Kh = 0; + Kh$1 = 0; if (25 <= f2) - throw Error(p$2(301)); + throw Error(p$3(301)); f2 += 1; - O = N$1 = null; + O$2 = N$2 = null; b2.updateQueue = null; Fh.current = Qh; - a = c(d, e2); + a2 = c2(d2, e18); } while (Jh); } Fh.current = Rh; - b2 = null !== N$1 && null !== N$1.next; + b2 = null !== N$2 && null !== N$2.next; Hh = 0; - O = N$1 = M = null; + O$2 = N$2 = M$1 = null; Ih = false; if (b2) - throw Error(p$2(300)); - return a; + throw Error(p$3(300)); + return a2; } function Sh() { - var a = 0 !== Kh; - Kh = 0; - return a; + var a2 = 0 !== Kh$1; + Kh$1 = 0; + return a2; } function Th() { - var a = { memoizedState: null, baseState: null, baseQueue: null, queue: null, next: null }; - null === O ? M.memoizedState = O = a : O = O.next = a; - return O; + var a2 = { memoizedState: null, baseState: null, baseQueue: null, queue: null, next: null }; + null === O$2 ? M$1.memoizedState = O$2 = a2 : O$2 = O$2.next = a2; + return O$2; } function Uh() { - if (null === N$1) { - var a = M.alternate; - a = null !== a ? a.memoizedState : null; + if (null === N$2) { + var a2 = M$1.alternate; + a2 = null !== a2 ? a2.memoizedState : null; } else - a = N$1.next; - var b2 = null === O ? M.memoizedState : O.next; + a2 = N$2.next; + var b2 = null === O$2 ? M$1.memoizedState : O$2.next; if (null !== b2) - O = b2, N$1 = a; + O$2 = b2, N$2 = a2; else { - if (null === a) - throw Error(p$2(310)); - N$1 = a; - a = { memoizedState: N$1.memoizedState, baseState: N$1.baseState, baseQueue: N$1.baseQueue, queue: N$1.queue, next: null }; - null === O ? M.memoizedState = O = a : O = O.next = a; - } - return O; -} -function Vh(a, b2) { - return "function" === typeof b2 ? b2(a) : b2; -} -function Wh(a) { - var b2 = Uh(), c = b2.queue; - if (null === c) - throw Error(p$2(311)); - c.lastRenderedReducer = a; - var d = N$1, e2 = d.baseQueue, f2 = c.pending; + if (null === a2) + throw Error(p$3(310)); + N$2 = a2; + a2 = { memoizedState: N$2.memoizedState, baseState: N$2.baseState, baseQueue: N$2.baseQueue, queue: N$2.queue, next: null }; + null === O$2 ? M$1.memoizedState = O$2 = a2 : O$2 = O$2.next = a2; + } + return O$2; +} +function Vh(a2, b2) { + return "function" === typeof b2 ? b2(a2) : b2; +} +function Wh(a2) { + var b2 = Uh(), c2 = b2.queue; + if (null === c2) + throw Error(p$3(311)); + c2.lastRenderedReducer = a2; + var d2 = N$2, e18 = d2.baseQueue, f2 = c2.pending; if (null !== f2) { - if (null !== e2) { - var g = e2.next; - e2.next = f2.next; - f2.next = g; - } - d.baseQueue = e2 = f2; - c.pending = null; - } - if (null !== e2) { - f2 = e2.next; - d = d.baseState; - var h2 = g = null, k2 = null, l2 = f2; + if (null !== e18) { + var g2 = e18.next; + e18.next = f2.next; + f2.next = g2; + } + d2.baseQueue = e18 = f2; + c2.pending = null; + } + if (null !== e18) { + f2 = e18.next; + d2 = d2.baseState; + var h2 = g2 = null, k2 = null, l2 = f2; do { var m2 = l2.lane; if ((Hh & m2) === m2) - null !== k2 && (k2 = k2.next = { lane: 0, action: l2.action, hasEagerState: l2.hasEagerState, eagerState: l2.eagerState, next: null }), d = l2.hasEagerState ? l2.eagerState : a(d, l2.action); + null !== k2 && (k2 = k2.next = { lane: 0, action: l2.action, hasEagerState: l2.hasEagerState, eagerState: l2.eagerState, next: null }), d2 = l2.hasEagerState ? l2.eagerState : a2(d2, l2.action); else { var q2 = { lane: m2, @@ -3849,336 +3868,336 @@ function Wh(a) { eagerState: l2.eagerState, next: null }; - null === k2 ? (h2 = k2 = q2, g = d) : k2 = k2.next = q2; - M.lanes |= m2; - rh |= m2; + null === k2 ? (h2 = k2 = q2, g2 = d2) : k2 = k2.next = q2; + M$1.lanes |= m2; + rh$2 |= m2; } l2 = l2.next; } while (null !== l2 && l2 !== f2); - null === k2 ? g = d : k2.next = h2; - He(d, b2.memoizedState) || (dh = true); - b2.memoizedState = d; - b2.baseState = g; + null === k2 ? g2 = d2 : k2.next = h2; + He(d2, b2.memoizedState) || (dh = true); + b2.memoizedState = d2; + b2.baseState = g2; b2.baseQueue = k2; - c.lastRenderedState = d; + c2.lastRenderedState = d2; } - a = c.interleaved; - if (null !== a) { - e2 = a; + a2 = c2.interleaved; + if (null !== a2) { + e18 = a2; do - f2 = e2.lane, M.lanes |= f2, rh |= f2, e2 = e2.next; - while (e2 !== a); + f2 = e18.lane, M$1.lanes |= f2, rh$2 |= f2, e18 = e18.next; + while (e18 !== a2); } else - null === e2 && (c.lanes = 0); - return [b2.memoizedState, c.dispatch]; -} -function Xh(a) { - var b2 = Uh(), c = b2.queue; - if (null === c) - throw Error(p$2(311)); - c.lastRenderedReducer = a; - var d = c.dispatch, e2 = c.pending, f2 = b2.memoizedState; - if (null !== e2) { - c.pending = null; - var g = e2 = e2.next; + null === e18 && (c2.lanes = 0); + return [b2.memoizedState, c2.dispatch]; +} +function Xh(a2) { + var b2 = Uh(), c2 = b2.queue; + if (null === c2) + throw Error(p$3(311)); + c2.lastRenderedReducer = a2; + var d2 = c2.dispatch, e18 = c2.pending, f2 = b2.memoizedState; + if (null !== e18) { + c2.pending = null; + var g2 = e18 = e18.next; do - f2 = a(f2, g.action), g = g.next; - while (g !== e2); + f2 = a2(f2, g2.action), g2 = g2.next; + while (g2 !== e18); He(f2, b2.memoizedState) || (dh = true); b2.memoizedState = f2; null === b2.baseQueue && (b2.baseState = f2); - c.lastRenderedState = f2; + c2.lastRenderedState = f2; } - return [f2, d]; + return [f2, d2]; } function Yh() { } -function Zh(a, b2) { - var c = M, d = Uh(), e2 = b2(), f2 = !He(d.memoizedState, e2); - f2 && (d.memoizedState = e2, dh = true); - d = d.queue; - $h(ai.bind(null, c, d, a), [a]); - if (d.getSnapshot !== b2 || f2 || null !== O && O.memoizedState.tag & 1) { - c.flags |= 2048; - bi(9, ci.bind(null, c, d, e2, b2), void 0, null); - if (null === Q) - throw Error(p$2(349)); - 0 !== (Hh & 30) || di(c, b2, e2); - } - return e2; -} -function di(a, b2, c) { - a.flags |= 16384; - a = { getSnapshot: b2, value: c }; - b2 = M.updateQueue; - null === b2 ? (b2 = { lastEffect: null, stores: null }, M.updateQueue = b2, b2.stores = [a]) : (c = b2.stores, null === c ? b2.stores = [a] : c.push(a)); -} -function ci(a, b2, c, d) { - b2.value = c; - b2.getSnapshot = d; - ei(b2) && fi(a); -} -function ai(a, b2, c) { - return c(function() { - ei(b2) && fi(a); +function Zh(a2, b2) { + var c2 = M$1, d2 = Uh(), e18 = b2(), f2 = !He(d2.memoizedState, e18); + f2 && (d2.memoizedState = e18, dh = true); + d2 = d2.queue; + $h(ai.bind(null, c2, d2, a2), [a2]); + if (d2.getSnapshot !== b2 || f2 || null !== O$2 && O$2.memoizedState.tag & 1) { + c2.flags |= 2048; + bi(9, ci.bind(null, c2, d2, e18, b2), void 0, null); + if (null === Q$1) + throw Error(p$3(349)); + 0 !== (Hh & 30) || di(c2, b2, e18); + } + return e18; +} +function di(a2, b2, c2) { + a2.flags |= 16384; + a2 = { getSnapshot: b2, value: c2 }; + b2 = M$1.updateQueue; + null === b2 ? (b2 = { lastEffect: null, stores: null }, M$1.updateQueue = b2, b2.stores = [a2]) : (c2 = b2.stores, null === c2 ? b2.stores = [a2] : c2.push(a2)); +} +function ci(a2, b2, c2, d2) { + b2.value = c2; + b2.getSnapshot = d2; + ei$1(b2) && fi(a2); +} +function ai(a2, b2, c2) { + return c2(function() { + ei$1(b2) && fi(a2); }); } -function ei(a) { - var b2 = a.getSnapshot; - a = a.value; +function ei$1(a2) { + var b2 = a2.getSnapshot; + a2 = a2.value; try { - var c = b2(); - return !He(a, c); - } catch (d) { + var c2 = b2(); + return !He(a2, c2); + } catch (d2) { return true; } } -function fi(a) { - var b2 = ih(a, 1); - null !== b2 && gi(b2, a, 1, -1); +function fi(a2) { + var b2 = ih(a2, 1); + null !== b2 && gi(b2, a2, 1, -1); } -function hi(a) { +function hi(a2) { var b2 = Th(); - "function" === typeof a && (a = a()); - b2.memoizedState = b2.baseState = a; - a = { pending: null, interleaved: null, lanes: 0, dispatch: null, lastRenderedReducer: Vh, lastRenderedState: a }; - b2.queue = a; - a = a.dispatch = ii.bind(null, M, a); - return [b2.memoizedState, a]; -} -function bi(a, b2, c, d) { - a = { tag: a, create: b2, destroy: c, deps: d, next: null }; - b2 = M.updateQueue; - null === b2 ? (b2 = { lastEffect: null, stores: null }, M.updateQueue = b2, b2.lastEffect = a.next = a) : (c = b2.lastEffect, null === c ? b2.lastEffect = a.next = a : (d = c.next, c.next = a, a.next = d, b2.lastEffect = a)); - return a; + "function" === typeof a2 && (a2 = a2()); + b2.memoizedState = b2.baseState = a2; + a2 = { pending: null, interleaved: null, lanes: 0, dispatch: null, lastRenderedReducer: Vh, lastRenderedState: a2 }; + b2.queue = a2; + a2 = a2.dispatch = ii.bind(null, M$1, a2); + return [b2.memoizedState, a2]; +} +function bi(a2, b2, c2, d2) { + a2 = { tag: a2, create: b2, destroy: c2, deps: d2, next: null }; + b2 = M$1.updateQueue; + null === b2 ? (b2 = { lastEffect: null, stores: null }, M$1.updateQueue = b2, b2.lastEffect = a2.next = a2) : (c2 = b2.lastEffect, null === c2 ? b2.lastEffect = a2.next = a2 : (d2 = c2.next, c2.next = a2, a2.next = d2, b2.lastEffect = a2)); + return a2; } function ji() { return Uh().memoizedState; } -function ki(a, b2, c, d) { - var e2 = Th(); - M.flags |= a; - e2.memoizedState = bi(1 | b2, c, void 0, void 0 === d ? null : d); +function ki(a2, b2, c2, d2) { + var e18 = Th(); + M$1.flags |= a2; + e18.memoizedState = bi(1 | b2, c2, void 0, void 0 === d2 ? null : d2); } -function li(a, b2, c, d) { - var e2 = Uh(); - d = void 0 === d ? null : d; +function li(a2, b2, c2, d2) { + var e18 = Uh(); + d2 = void 0 === d2 ? null : d2; var f2 = void 0; - if (null !== N$1) { - var g = N$1.memoizedState; - f2 = g.destroy; - if (null !== d && Mh(d, g.deps)) { - e2.memoizedState = bi(b2, c, f2, d); + if (null !== N$2) { + var g2 = N$2.memoizedState; + f2 = g2.destroy; + if (null !== d2 && Mh(d2, g2.deps)) { + e18.memoizedState = bi(b2, c2, f2, d2); return; } } - M.flags |= a; - e2.memoizedState = bi(1 | b2, c, f2, d); + M$1.flags |= a2; + e18.memoizedState = bi(1 | b2, c2, f2, d2); } -function mi(a, b2) { - return ki(8390656, 8, a, b2); +function mi(a2, b2) { + return ki(8390656, 8, a2, b2); } -function $h(a, b2) { - return li(2048, 8, a, b2); +function $h(a2, b2) { + return li(2048, 8, a2, b2); } -function ni(a, b2) { - return li(4, 2, a, b2); +function ni(a2, b2) { + return li(4, 2, a2, b2); } -function oi(a, b2) { - return li(4, 4, a, b2); +function oi(a2, b2) { + return li(4, 4, a2, b2); } -function pi(a, b2) { +function pi(a2, b2) { if ("function" === typeof b2) - return a = a(), b2(a), function() { + return a2 = a2(), b2(a2), function() { b2(null); }; if (null !== b2 && void 0 !== b2) - return a = a(), b2.current = a, function() { + return a2 = a2(), b2.current = a2, function() { b2.current = null; }; } -function qi(a, b2, c) { - c = null !== c && void 0 !== c ? c.concat([a]) : null; - return li(4, 4, pi.bind(null, b2, a), c); +function qi(a2, b2, c2) { + c2 = null !== c2 && void 0 !== c2 ? c2.concat([a2]) : null; + return li(4, 4, pi.bind(null, b2, a2), c2); } -function ri() { +function ri$1() { } -function si(a, b2) { - var c = Uh(); +function si(a2, b2) { + var c2 = Uh(); b2 = void 0 === b2 ? null : b2; - var d = c.memoizedState; - if (null !== d && null !== b2 && Mh(b2, d[1])) - return d[0]; - c.memoizedState = [a, b2]; - return a; -} -function ti(a, b2) { - var c = Uh(); + var d2 = c2.memoizedState; + if (null !== d2 && null !== b2 && Mh(b2, d2[1])) + return d2[0]; + c2.memoizedState = [a2, b2]; + return a2; +} +function ti(a2, b2) { + var c2 = Uh(); b2 = void 0 === b2 ? null : b2; - var d = c.memoizedState; - if (null !== d && null !== b2 && Mh(b2, d[1])) - return d[0]; - a = a(); - c.memoizedState = [a, b2]; - return a; -} -function ui(a, b2, c) { + var d2 = c2.memoizedState; + if (null !== d2 && null !== b2 && Mh(b2, d2[1])) + return d2[0]; + a2 = a2(); + c2.memoizedState = [a2, b2]; + return a2; +} +function ui(a2, b2, c2) { if (0 === (Hh & 21)) - return a.baseState && (a.baseState = false, dh = true), a.memoizedState = c; - He(c, b2) || (c = yc(), M.lanes |= c, rh |= c, a.baseState = true); + return a2.baseState && (a2.baseState = false, dh = true), a2.memoizedState = c2; + He(c2, b2) || (c2 = yc(), M$1.lanes |= c2, rh$2 |= c2, a2.baseState = true); return b2; } -function vi(a, b2) { - var c = C; - C = 0 !== c && 4 > c ? c : 4; - a(true); - var d = Gh.transition; +function vi(a2, b2) { + var c2 = C$1; + C$1 = 0 !== c2 && 4 > c2 ? c2 : 4; + a2(true); + var d2 = Gh.transition; Gh.transition = {}; try { - a(false), b2(); + a2(false), b2(); } finally { - C = c, Gh.transition = d; + C$1 = c2, Gh.transition = d2; } } function wi() { return Uh().memoizedState; } -function xi(a, b2, c) { - var d = yi(a); - c = { lane: d, action: c, hasEagerState: false, eagerState: null, next: null }; - if (zi(a)) - Ai(b2, c); - else if (c = hh(a, b2, c, d), null !== c) { - var e2 = R(); - gi(c, a, d, e2); - Bi(c, b2, d); - } -} -function ii(a, b2, c) { - var d = yi(a), e2 = { lane: d, action: c, hasEagerState: false, eagerState: null, next: null }; - if (zi(a)) - Ai(b2, e2); +function xi(a2, b2, c2) { + var d2 = yi(a2); + c2 = { lane: d2, action: c2, hasEagerState: false, eagerState: null, next: null }; + if (zi(a2)) + Ai(b2, c2); + else if (c2 = hh(a2, b2, c2, d2), null !== c2) { + var e18 = R$1(); + gi(c2, a2, d2, e18); + Bi(c2, b2, d2); + } +} +function ii(a2, b2, c2) { + var d2 = yi(a2), e18 = { lane: d2, action: c2, hasEagerState: false, eagerState: null, next: null }; + if (zi(a2)) + Ai(b2, e18); else { - var f2 = a.alternate; - if (0 === a.lanes && (null === f2 || 0 === f2.lanes) && (f2 = b2.lastRenderedReducer, null !== f2)) + var f2 = a2.alternate; + if (0 === a2.lanes && (null === f2 || 0 === f2.lanes) && (f2 = b2.lastRenderedReducer, null !== f2)) try { - var g = b2.lastRenderedState, h2 = f2(g, c); - e2.hasEagerState = true; - e2.eagerState = h2; - if (He(h2, g)) { + var g2 = b2.lastRenderedState, h2 = f2(g2, c2); + e18.hasEagerState = true; + e18.eagerState = h2; + if (He(h2, g2)) { var k2 = b2.interleaved; - null === k2 ? (e2.next = e2, gh(b2)) : (e2.next = k2.next, k2.next = e2); - b2.interleaved = e2; + null === k2 ? (e18.next = e18, gh(b2)) : (e18.next = k2.next, k2.next = e18); + b2.interleaved = e18; return; } } catch (l2) { } finally { } - c = hh(a, b2, e2, d); - null !== c && (e2 = R(), gi(c, a, d, e2), Bi(c, b2, d)); + c2 = hh(a2, b2, e18, d2); + null !== c2 && (e18 = R$1(), gi(c2, a2, d2, e18), Bi(c2, b2, d2)); } } -function zi(a) { - var b2 = a.alternate; - return a === M || null !== b2 && b2 === M; +function zi(a2) { + var b2 = a2.alternate; + return a2 === M$1 || null !== b2 && b2 === M$1; } -function Ai(a, b2) { +function Ai(a2, b2) { Jh = Ih = true; - var c = a.pending; - null === c ? b2.next = b2 : (b2.next = c.next, c.next = b2); - a.pending = b2; -} -function Bi(a, b2, c) { - if (0 !== (c & 4194240)) { - var d = b2.lanes; - d &= a.pendingLanes; - c |= d; - b2.lanes = c; - Cc(a, c); - } -} -var Rh = { readContext: eh, useCallback: P, useContext: P, useEffect: P, useImperativeHandle: P, useInsertionEffect: P, useLayoutEffect: P, useMemo: P, useReducer: P, useRef: P, useState: P, useDebugValue: P, useDeferredValue: P, useTransition: P, useMutableSource: P, useSyncExternalStore: P, useId: P, unstable_isNewReconciler: false }, Oh = { readContext: eh, useCallback: function(a, b2) { - Th().memoizedState = [a, void 0 === b2 ? null : b2]; - return a; -}, useContext: eh, useEffect: mi, useImperativeHandle: function(a, b2, c) { - c = null !== c && void 0 !== c ? c.concat([a]) : null; + var c2 = a2.pending; + null === c2 ? b2.next = b2 : (b2.next = c2.next, c2.next = b2); + a2.pending = b2; +} +function Bi(a2, b2, c2) { + if (0 !== (c2 & 4194240)) { + var d2 = b2.lanes; + d2 &= a2.pendingLanes; + c2 |= d2; + b2.lanes = c2; + Cc(a2, c2); + } +} +var Rh = { readContext: eh$1, useCallback: P$1, useContext: P$1, useEffect: P$1, useImperativeHandle: P$1, useInsertionEffect: P$1, useLayoutEffect: P$1, useMemo: P$1, useReducer: P$1, useRef: P$1, useState: P$1, useDebugValue: P$1, useDeferredValue: P$1, useTransition: P$1, useMutableSource: P$1, useSyncExternalStore: P$1, useId: P$1, unstable_isNewReconciler: false }, Oh = { readContext: eh$1, useCallback: function(a2, b2) { + Th().memoizedState = [a2, void 0 === b2 ? null : b2]; + return a2; +}, useContext: eh$1, useEffect: mi, useImperativeHandle: function(a2, b2, c2) { + c2 = null !== c2 && void 0 !== c2 ? c2.concat([a2]) : null; return ki( 4194308, 4, - pi.bind(null, b2, a), - c + pi.bind(null, b2, a2), + c2 ); -}, useLayoutEffect: function(a, b2) { - return ki(4194308, 4, a, b2); -}, useInsertionEffect: function(a, b2) { - return ki(4, 2, a, b2); -}, useMemo: function(a, b2) { - var c = Th(); +}, useLayoutEffect: function(a2, b2) { + return ki(4194308, 4, a2, b2); +}, useInsertionEffect: function(a2, b2) { + return ki(4, 2, a2, b2); +}, useMemo: function(a2, b2) { + var c2 = Th(); b2 = void 0 === b2 ? null : b2; - a = a(); - c.memoizedState = [a, b2]; - return a; -}, useReducer: function(a, b2, c) { - var d = Th(); - b2 = void 0 !== c ? c(b2) : b2; - d.memoizedState = d.baseState = b2; - a = { pending: null, interleaved: null, lanes: 0, dispatch: null, lastRenderedReducer: a, lastRenderedState: b2 }; - d.queue = a; - a = a.dispatch = xi.bind(null, M, a); - return [d.memoizedState, a]; -}, useRef: function(a) { + a2 = a2(); + c2.memoizedState = [a2, b2]; + return a2; +}, useReducer: function(a2, b2, c2) { + var d2 = Th(); + b2 = void 0 !== c2 ? c2(b2) : b2; + d2.memoizedState = d2.baseState = b2; + a2 = { pending: null, interleaved: null, lanes: 0, dispatch: null, lastRenderedReducer: a2, lastRenderedState: b2 }; + d2.queue = a2; + a2 = a2.dispatch = xi.bind(null, M$1, a2); + return [d2.memoizedState, a2]; +}, useRef: function(a2) { var b2 = Th(); - a = { current: a }; - return b2.memoizedState = a; -}, useState: hi, useDebugValue: ri, useDeferredValue: function(a) { - return Th().memoizedState = a; + a2 = { current: a2 }; + return b2.memoizedState = a2; +}, useState: hi, useDebugValue: ri$1, useDeferredValue: function(a2) { + return Th().memoizedState = a2; }, useTransition: function() { - var a = hi(false), b2 = a[0]; - a = vi.bind(null, a[1]); - Th().memoizedState = a; - return [b2, a]; + var a2 = hi(false), b2 = a2[0]; + a2 = vi.bind(null, a2[1]); + Th().memoizedState = a2; + return [b2, a2]; }, useMutableSource: function() { -}, useSyncExternalStore: function(a, b2, c) { - var d = M, e2 = Th(); - if (I) { - if (void 0 === c) - throw Error(p$2(407)); - c = c(); +}, useSyncExternalStore: function(a2, b2, c2) { + var d2 = M$1, e18 = Th(); + if (I$1) { + if (void 0 === c2) + throw Error(p$3(407)); + c2 = c2(); } else { - c = b2(); - if (null === Q) - throw Error(p$2(349)); - 0 !== (Hh & 30) || di(d, b2, c); - } - e2.memoizedState = c; - var f2 = { value: c, getSnapshot: b2 }; - e2.queue = f2; + c2 = b2(); + if (null === Q$1) + throw Error(p$3(349)); + 0 !== (Hh & 30) || di(d2, b2, c2); + } + e18.memoizedState = c2; + var f2 = { value: c2, getSnapshot: b2 }; + e18.queue = f2; mi(ai.bind( null, - d, + d2, f2, - a - ), [a]); - d.flags |= 2048; - bi(9, ci.bind(null, d, f2, c, b2), void 0, null); - return c; + a2 + ), [a2]); + d2.flags |= 2048; + bi(9, ci.bind(null, d2, f2, c2, b2), void 0, null); + return c2; }, useId: function() { - var a = Th(), b2 = Q.identifierPrefix; - if (I) { - var c = sg; - var d = rg; - c = (d & ~(1 << 32 - oc(d) - 1)).toString(32) + c; - b2 = ":" + b2 + "R" + c; - c = Kh++; - 0 < c && (b2 += "H" + c.toString(32)); + var a2 = Th(), b2 = Q$1.identifierPrefix; + if (I$1) { + var c2 = sg; + var d2 = rg; + c2 = (d2 & ~(1 << 32 - oc(d2) - 1)).toString(32) + c2; + b2 = ":" + b2 + "R" + c2; + c2 = Kh$1++; + 0 < c2 && (b2 += "H" + c2.toString(32)); b2 += ":"; } else - c = Lh++, b2 = ":" + b2 + "r" + c.toString(32) + ":"; - return a.memoizedState = b2; + c2 = Lh++, b2 = ":" + b2 + "r" + c2.toString(32) + ":"; + return a2.memoizedState = b2; }, unstable_isNewReconciler: false }, Ph = { - readContext: eh, + readContext: eh$1, useCallback: si, - useContext: eh, + useContext: eh$1, useEffect: $h, useImperativeHandle: qi, useInsertionEffect: ni, @@ -4189,459 +4208,459 @@ var Rh = { readContext: eh, useCallback: P, useContext: P, useEffect: P, useImpe useState: function() { return Wh(Vh); }, - useDebugValue: ri, - useDeferredValue: function(a) { + useDebugValue: ri$1, + useDeferredValue: function(a2) { var b2 = Uh(); - return ui(b2, N$1.memoizedState, a); + return ui(b2, N$2.memoizedState, a2); }, useTransition: function() { - var a = Wh(Vh)[0], b2 = Uh().memoizedState; - return [a, b2]; + var a2 = Wh(Vh)[0], b2 = Uh().memoizedState; + return [a2, b2]; }, useMutableSource: Yh, useSyncExternalStore: Zh, useId: wi, unstable_isNewReconciler: false -}, Qh = { readContext: eh, useCallback: si, useContext: eh, useEffect: $h, useImperativeHandle: qi, useInsertionEffect: ni, useLayoutEffect: oi, useMemo: ti, useReducer: Xh, useRef: ji, useState: function() { +}, Qh = { readContext: eh$1, useCallback: si, useContext: eh$1, useEffect: $h, useImperativeHandle: qi, useInsertionEffect: ni, useLayoutEffect: oi, useMemo: ti, useReducer: Xh, useRef: ji, useState: function() { return Xh(Vh); -}, useDebugValue: ri, useDeferredValue: function(a) { +}, useDebugValue: ri$1, useDeferredValue: function(a2) { var b2 = Uh(); - return null === N$1 ? b2.memoizedState = a : ui(b2, N$1.memoizedState, a); + return null === N$2 ? b2.memoizedState = a2 : ui(b2, N$2.memoizedState, a2); }, useTransition: function() { - var a = Xh(Vh)[0], b2 = Uh().memoizedState; - return [a, b2]; + var a2 = Xh(Vh)[0], b2 = Uh().memoizedState; + return [a2, b2]; }, useMutableSource: Yh, useSyncExternalStore: Zh, useId: wi, unstable_isNewReconciler: false }; -function Ci(a, b2) { - if (a && a.defaultProps) { - b2 = A({}, b2); - a = a.defaultProps; - for (var c in a) - void 0 === b2[c] && (b2[c] = a[c]); +function Ci(a2, b2) { + if (a2 && a2.defaultProps) { + b2 = A$1({}, b2); + a2 = a2.defaultProps; + for (var c2 in a2) + void 0 === b2[c2] && (b2[c2] = a2[c2]); return b2; } return b2; } -function Di(a, b2, c, d) { - b2 = a.memoizedState; - c = c(d, b2); - c = null === c || void 0 === c ? b2 : A({}, b2, c); - a.memoizedState = c; - 0 === a.lanes && (a.updateQueue.baseState = c); -} -var Ei = { isMounted: function(a) { - return (a = a._reactInternals) ? Vb(a) === a : false; -}, enqueueSetState: function(a, b2, c) { - a = a._reactInternals; - var d = R(), e2 = yi(a), f2 = mh(d, e2); +function Di(a2, b2, c2, d2) { + b2 = a2.memoizedState; + c2 = c2(d2, b2); + c2 = null === c2 || void 0 === c2 ? b2 : A$1({}, b2, c2); + a2.memoizedState = c2; + 0 === a2.lanes && (a2.updateQueue.baseState = c2); +} +var Ei = { isMounted: function(a2) { + return (a2 = a2._reactInternals) ? Vb(a2) === a2 : false; +}, enqueueSetState: function(a2, b2, c2) { + a2 = a2._reactInternals; + var d2 = R$1(), e18 = yi(a2), f2 = mh(d2, e18); f2.payload = b2; - void 0 !== c && null !== c && (f2.callback = c); - b2 = nh(a, f2, e2); - null !== b2 && (gi(b2, a, e2, d), oh(b2, a, e2)); -}, enqueueReplaceState: function(a, b2, c) { - a = a._reactInternals; - var d = R(), e2 = yi(a), f2 = mh(d, e2); + void 0 !== c2 && null !== c2 && (f2.callback = c2); + b2 = nh(a2, f2, e18); + null !== b2 && (gi(b2, a2, e18, d2), oh(b2, a2, e18)); +}, enqueueReplaceState: function(a2, b2, c2) { + a2 = a2._reactInternals; + var d2 = R$1(), e18 = yi(a2), f2 = mh(d2, e18); f2.tag = 1; f2.payload = b2; - void 0 !== c && null !== c && (f2.callback = c); - b2 = nh(a, f2, e2); - null !== b2 && (gi(b2, a, e2, d), oh(b2, a, e2)); -}, enqueueForceUpdate: function(a, b2) { - a = a._reactInternals; - var c = R(), d = yi(a), e2 = mh(c, d); - e2.tag = 2; - void 0 !== b2 && null !== b2 && (e2.callback = b2); - b2 = nh(a, e2, d); - null !== b2 && (gi(b2, a, d, c), oh(b2, a, d)); + void 0 !== c2 && null !== c2 && (f2.callback = c2); + b2 = nh(a2, f2, e18); + null !== b2 && (gi(b2, a2, e18, d2), oh(b2, a2, e18)); +}, enqueueForceUpdate: function(a2, b2) { + a2 = a2._reactInternals; + var c2 = R$1(), d2 = yi(a2), e18 = mh(c2, d2); + e18.tag = 2; + void 0 !== b2 && null !== b2 && (e18.callback = b2); + b2 = nh(a2, e18, d2); + null !== b2 && (gi(b2, a2, d2, c2), oh(b2, a2, d2)); } }; -function Fi(a, b2, c, d, e2, f2, g) { - a = a.stateNode; - return "function" === typeof a.shouldComponentUpdate ? a.shouldComponentUpdate(d, f2, g) : b2.prototype && b2.prototype.isPureReactComponent ? !Ie(c, d) || !Ie(e2, f2) : true; +function Fi(a2, b2, c2, d2, e18, f2, g2) { + a2 = a2.stateNode; + return "function" === typeof a2.shouldComponentUpdate ? a2.shouldComponentUpdate(d2, f2, g2) : b2.prototype && b2.prototype.isPureReactComponent ? !Ie(c2, d2) || !Ie(e18, f2) : true; } -function Gi(a, b2, c) { - var d = false, e2 = Vf; +function Gi(a2, b2, c2) { + var d2 = false, e18 = Vf; var f2 = b2.contextType; - "object" === typeof f2 && null !== f2 ? f2 = eh(f2) : (e2 = Zf(b2) ? Xf : H.current, d = b2.contextTypes, f2 = (d = null !== d && void 0 !== d) ? Yf(a, e2) : Vf); - b2 = new b2(c, f2); - a.memoizedState = null !== b2.state && void 0 !== b2.state ? b2.state : null; + "object" === typeof f2 && null !== f2 ? f2 = eh$1(f2) : (e18 = Zf(b2) ? Xf : H$1.current, d2 = b2.contextTypes, f2 = (d2 = null !== d2 && void 0 !== d2) ? Yf(a2, e18) : Vf); + b2 = new b2(c2, f2); + a2.memoizedState = null !== b2.state && void 0 !== b2.state ? b2.state : null; b2.updater = Ei; - a.stateNode = b2; - b2._reactInternals = a; - d && (a = a.stateNode, a.__reactInternalMemoizedUnmaskedChildContext = e2, a.__reactInternalMemoizedMaskedChildContext = f2); + a2.stateNode = b2; + b2._reactInternals = a2; + d2 && (a2 = a2.stateNode, a2.__reactInternalMemoizedUnmaskedChildContext = e18, a2.__reactInternalMemoizedMaskedChildContext = f2); return b2; } -function Hi(a, b2, c, d) { - a = b2.state; - "function" === typeof b2.componentWillReceiveProps && b2.componentWillReceiveProps(c, d); - "function" === typeof b2.UNSAFE_componentWillReceiveProps && b2.UNSAFE_componentWillReceiveProps(c, d); - b2.state !== a && Ei.enqueueReplaceState(b2, b2.state, null); -} -function Ii(a, b2, c, d) { - var e2 = a.stateNode; - e2.props = c; - e2.state = a.memoizedState; - e2.refs = {}; - kh(a); +function Hi(a2, b2, c2, d2) { + a2 = b2.state; + "function" === typeof b2.componentWillReceiveProps && b2.componentWillReceiveProps(c2, d2); + "function" === typeof b2.UNSAFE_componentWillReceiveProps && b2.UNSAFE_componentWillReceiveProps(c2, d2); + b2.state !== a2 && Ei.enqueueReplaceState(b2, b2.state, null); +} +function Ii(a2, b2, c2, d2) { + var e18 = a2.stateNode; + e18.props = c2; + e18.state = a2.memoizedState; + e18.refs = {}; + kh(a2); var f2 = b2.contextType; - "object" === typeof f2 && null !== f2 ? e2.context = eh(f2) : (f2 = Zf(b2) ? Xf : H.current, e2.context = Yf(a, f2)); - e2.state = a.memoizedState; + "object" === typeof f2 && null !== f2 ? e18.context = eh$1(f2) : (f2 = Zf(b2) ? Xf : H$1.current, e18.context = Yf(a2, f2)); + e18.state = a2.memoizedState; f2 = b2.getDerivedStateFromProps; - "function" === typeof f2 && (Di(a, b2, f2, c), e2.state = a.memoizedState); - "function" === typeof b2.getDerivedStateFromProps || "function" === typeof e2.getSnapshotBeforeUpdate || "function" !== typeof e2.UNSAFE_componentWillMount && "function" !== typeof e2.componentWillMount || (b2 = e2.state, "function" === typeof e2.componentWillMount && e2.componentWillMount(), "function" === typeof e2.UNSAFE_componentWillMount && e2.UNSAFE_componentWillMount(), b2 !== e2.state && Ei.enqueueReplaceState(e2, e2.state, null), qh(a, c, e2, d), e2.state = a.memoizedState); - "function" === typeof e2.componentDidMount && (a.flags |= 4194308); + "function" === typeof f2 && (Di(a2, b2, f2, c2), e18.state = a2.memoizedState); + "function" === typeof b2.getDerivedStateFromProps || "function" === typeof e18.getSnapshotBeforeUpdate || "function" !== typeof e18.UNSAFE_componentWillMount && "function" !== typeof e18.componentWillMount || (b2 = e18.state, "function" === typeof e18.componentWillMount && e18.componentWillMount(), "function" === typeof e18.UNSAFE_componentWillMount && e18.UNSAFE_componentWillMount(), b2 !== e18.state && Ei.enqueueReplaceState(e18, e18.state, null), qh(a2, c2, e18, d2), e18.state = a2.memoizedState); + "function" === typeof e18.componentDidMount && (a2.flags |= 4194308); } -function Ji(a, b2) { +function Ji(a2, b2) { try { - var c = "", d = b2; + var c2 = "", d2 = b2; do - c += Pa(d), d = d.return; - while (d); - var e2 = c; + c2 += Pa(d2), d2 = d2.return; + while (d2); + var e18 = c2; } catch (f2) { - e2 = "\nError generating stack: " + f2.message + "\n" + f2.stack; + e18 = "\nError generating stack: " + f2.message + "\n" + f2.stack; } - return { value: a, source: b2, stack: e2, digest: null }; + return { value: a2, source: b2, stack: e18, digest: null }; } -function Ki(a, b2, c) { - return { value: a, source: null, stack: null != c ? c : null, digest: null != b2 ? b2 : null }; +function Ki(a2, b2, c2) { + return { value: a2, source: null, stack: null != c2 ? c2 : null, digest: null != b2 ? b2 : null }; } -function Li(a, b2) { +function Li(a2, b2) { try { console.error(b2.value); - } catch (c) { + } catch (c2) { setTimeout(function() { - throw c; + throw c2; }); } } var Mi = "function" === typeof WeakMap ? WeakMap : Map; -function Ni(a, b2, c) { - c = mh(-1, c); - c.tag = 3; - c.payload = { element: null }; - var d = b2.value; - c.callback = function() { - Oi || (Oi = true, Pi$1 = d); - Li(a, b2); - }; - return c; -} -function Qi(a, b2, c) { - c = mh(-1, c); - c.tag = 3; - var d = a.type.getDerivedStateFromError; - if ("function" === typeof d) { - var e2 = b2.value; - c.payload = function() { - return d(e2); - }; - c.callback = function() { - Li(a, b2); - }; - } - var f2 = a.stateNode; - null !== f2 && "function" === typeof f2.componentDidCatch && (c.callback = function() { - Li(a, b2); - "function" !== typeof d && (null === Ri ? Ri = /* @__PURE__ */ new Set([this]) : Ri.add(this)); - var c2 = b2.stack; - this.componentDidCatch(b2.value, { componentStack: null !== c2 ? c2 : "" }); +function Ni(a2, b2, c2) { + c2 = mh(-1, c2); + c2.tag = 3; + c2.payload = { element: null }; + var d2 = b2.value; + c2.callback = function() { + Oi || (Oi = true, Pi$1 = d2); + Li(a2, b2); + }; + return c2; +} +function Qi(a2, b2, c2) { + c2 = mh(-1, c2); + c2.tag = 3; + var d2 = a2.type.getDerivedStateFromError; + if ("function" === typeof d2) { + var e18 = b2.value; + c2.payload = function() { + return d2(e18); + }; + c2.callback = function() { + Li(a2, b2); + }; + } + var f2 = a2.stateNode; + null !== f2 && "function" === typeof f2.componentDidCatch && (c2.callback = function() { + Li(a2, b2); + "function" !== typeof d2 && (null === Ri ? Ri = /* @__PURE__ */ new Set([this]) : Ri.add(this)); + var c3 = b2.stack; + this.componentDidCatch(b2.value, { componentStack: null !== c3 ? c3 : "" }); }); - return c; -} -function Si$1(a, b2, c) { - var d = a.pingCache; - if (null === d) { - d = a.pingCache = new Mi(); - var e2 = /* @__PURE__ */ new Set(); - d.set(b2, e2); + return c2; +} +function Si$1(a2, b2, c2) { + var d2 = a2.pingCache; + if (null === d2) { + d2 = a2.pingCache = new Mi(); + var e18 = /* @__PURE__ */ new Set(); + d2.set(b2, e18); } else - e2 = d.get(b2), void 0 === e2 && (e2 = /* @__PURE__ */ new Set(), d.set(b2, e2)); - e2.has(c) || (e2.add(c), a = Ti.bind(null, a, b2, c), b2.then(a, a)); + e18 = d2.get(b2), void 0 === e18 && (e18 = /* @__PURE__ */ new Set(), d2.set(b2, e18)); + e18.has(c2) || (e18.add(c2), a2 = Ti.bind(null, a2, b2, c2), b2.then(a2, a2)); } -function Ui(a) { +function Ui(a2) { do { var b2; - if (b2 = 13 === a.tag) - b2 = a.memoizedState, b2 = null !== b2 ? null !== b2.dehydrated ? true : false : true; + if (b2 = 13 === a2.tag) + b2 = a2.memoizedState, b2 = null !== b2 ? null !== b2.dehydrated ? true : false : true; if (b2) - return a; - a = a.return; - } while (null !== a); + return a2; + a2 = a2.return; + } while (null !== a2); return null; } -function Vi(a, b2, c, d, e2) { - if (0 === (a.mode & 1)) - return a === b2 ? a.flags |= 65536 : (a.flags |= 128, c.flags |= 131072, c.flags &= -52805, 1 === c.tag && (null === c.alternate ? c.tag = 17 : (b2 = mh(-1, 1), b2.tag = 2, nh(c, b2, 1))), c.lanes |= 1), a; - a.flags |= 65536; - a.lanes = e2; - return a; +function Vi(a2, b2, c2, d2, e18) { + if (0 === (a2.mode & 1)) + return a2 === b2 ? a2.flags |= 65536 : (a2.flags |= 128, c2.flags |= 131072, c2.flags &= -52805, 1 === c2.tag && (null === c2.alternate ? c2.tag = 17 : (b2 = mh(-1, 1), b2.tag = 2, nh(c2, b2, 1))), c2.lanes |= 1), a2; + a2.flags |= 65536; + a2.lanes = e18; + return a2; } var Wi = ua.ReactCurrentOwner, dh = false; -function Xi(a, b2, c, d) { - b2.child = null === a ? Vg(b2, null, c, d) : Ug(b2, a.child, c, d); +function Xi(a2, b2, c2, d2) { + b2.child = null === a2 ? Vg(b2, null, c2, d2) : Ug(b2, a2.child, c2, d2); } -function Yi(a, b2, c, d, e2) { - c = c.render; +function Yi(a2, b2, c2, d2, e18) { + c2 = c2.render; var f2 = b2.ref; - ch(b2, e2); - d = Nh(a, b2, c, d, f2, e2); - c = Sh(); - if (null !== a && !dh) - return b2.updateQueue = a.updateQueue, b2.flags &= -2053, a.lanes &= ~e2, Zi(a, b2, e2); - I && c && vg(b2); + ch(b2, e18); + d2 = Nh(a2, b2, c2, d2, f2, e18); + c2 = Sh(); + if (null !== a2 && !dh) + return b2.updateQueue = a2.updateQueue, b2.flags &= -2053, a2.lanes &= ~e18, Zi(a2, b2, e18); + I$1 && c2 && vg(b2); b2.flags |= 1; - Xi(a, b2, d, e2); + Xi(a2, b2, d2, e18); return b2.child; } -function $i(a, b2, c, d, e2) { - if (null === a) { - var f2 = c.type; - if ("function" === typeof f2 && !aj(f2) && void 0 === f2.defaultProps && null === c.compare && void 0 === c.defaultProps) - return b2.tag = 15, b2.type = f2, bj(a, b2, f2, d, e2); - a = Rg(c.type, null, d, b2, b2.mode, e2); - a.ref = b2.ref; - a.return = b2; - return b2.child = a; - } - f2 = a.child; - if (0 === (a.lanes & e2)) { - var g = f2.memoizedProps; - c = c.compare; - c = null !== c ? c : Ie; - if (c(g, d) && a.ref === b2.ref) - return Zi(a, b2, e2); +function $i(a2, b2, c2, d2, e18) { + if (null === a2) { + var f2 = c2.type; + if ("function" === typeof f2 && !aj(f2) && void 0 === f2.defaultProps && null === c2.compare && void 0 === c2.defaultProps) + return b2.tag = 15, b2.type = f2, bj(a2, b2, f2, d2, e18); + a2 = Rg(c2.type, null, d2, b2, b2.mode, e18); + a2.ref = b2.ref; + a2.return = b2; + return b2.child = a2; + } + f2 = a2.child; + if (0 === (a2.lanes & e18)) { + var g2 = f2.memoizedProps; + c2 = c2.compare; + c2 = null !== c2 ? c2 : Ie; + if (c2(g2, d2) && a2.ref === b2.ref) + return Zi(a2, b2, e18); } b2.flags |= 1; - a = Pg(f2, d); - a.ref = b2.ref; - a.return = b2; - return b2.child = a; -} -function bj(a, b2, c, d, e2) { - if (null !== a) { - var f2 = a.memoizedProps; - if (Ie(f2, d) && a.ref === b2.ref) - if (dh = false, b2.pendingProps = d = f2, 0 !== (a.lanes & e2)) - 0 !== (a.flags & 131072) && (dh = true); + a2 = Pg(f2, d2); + a2.ref = b2.ref; + a2.return = b2; + return b2.child = a2; +} +function bj(a2, b2, c2, d2, e18) { + if (null !== a2) { + var f2 = a2.memoizedProps; + if (Ie(f2, d2) && a2.ref === b2.ref) + if (dh = false, b2.pendingProps = d2 = f2, 0 !== (a2.lanes & e18)) + 0 !== (a2.flags & 131072) && (dh = true); else - return b2.lanes = a.lanes, Zi(a, b2, e2); + return b2.lanes = a2.lanes, Zi(a2, b2, e18); } - return cj(a, b2, c, d, e2); + return cj(a2, b2, c2, d2, e18); } -function dj(a, b2, c) { - var d = b2.pendingProps, e2 = d.children, f2 = null !== a ? a.memoizedState : null; - if ("hidden" === d.mode) +function dj(a2, b2, c2) { + var d2 = b2.pendingProps, e18 = d2.children, f2 = null !== a2 ? a2.memoizedState : null; + if ("hidden" === d2.mode) if (0 === (b2.mode & 1)) - b2.memoizedState = { baseLanes: 0, cachePool: null, transitions: null }, G(ej, fj), fj |= c; + b2.memoizedState = { baseLanes: 0, cachePool: null, transitions: null }, G$1(ej$1, fj), fj |= c2; else { - if (0 === (c & 1073741824)) - return a = null !== f2 ? f2.baseLanes | c : c, b2.lanes = b2.childLanes = 1073741824, b2.memoizedState = { baseLanes: a, cachePool: null, transitions: null }, b2.updateQueue = null, G(ej, fj), fj |= a, null; + if (0 === (c2 & 1073741824)) + return a2 = null !== f2 ? f2.baseLanes | c2 : c2, b2.lanes = b2.childLanes = 1073741824, b2.memoizedState = { baseLanes: a2, cachePool: null, transitions: null }, b2.updateQueue = null, G$1(ej$1, fj), fj |= a2, null; b2.memoizedState = { baseLanes: 0, cachePool: null, transitions: null }; - d = null !== f2 ? f2.baseLanes : c; - G(ej, fj); - fj |= d; + d2 = null !== f2 ? f2.baseLanes : c2; + G$1(ej$1, fj); + fj |= d2; } else - null !== f2 ? (d = f2.baseLanes | c, b2.memoizedState = null) : d = c, G(ej, fj), fj |= d; - Xi(a, b2, e2, c); + null !== f2 ? (d2 = f2.baseLanes | c2, b2.memoizedState = null) : d2 = c2, G$1(ej$1, fj), fj |= d2; + Xi(a2, b2, e18, c2); return b2.child; } -function gj(a, b2) { - var c = b2.ref; - if (null === a && null !== c || null !== a && a.ref !== c) +function gj(a2, b2) { + var c2 = b2.ref; + if (null === a2 && null !== c2 || null !== a2 && a2.ref !== c2) b2.flags |= 512, b2.flags |= 2097152; } -function cj(a, b2, c, d, e2) { - var f2 = Zf(c) ? Xf : H.current; +function cj(a2, b2, c2, d2, e18) { + var f2 = Zf(c2) ? Xf : H$1.current; f2 = Yf(b2, f2); - ch(b2, e2); - c = Nh(a, b2, c, d, f2, e2); - d = Sh(); - if (null !== a && !dh) - return b2.updateQueue = a.updateQueue, b2.flags &= -2053, a.lanes &= ~e2, Zi(a, b2, e2); - I && d && vg(b2); + ch(b2, e18); + c2 = Nh(a2, b2, c2, d2, f2, e18); + d2 = Sh(); + if (null !== a2 && !dh) + return b2.updateQueue = a2.updateQueue, b2.flags &= -2053, a2.lanes &= ~e18, Zi(a2, b2, e18); + I$1 && d2 && vg(b2); b2.flags |= 1; - Xi(a, b2, c, e2); + Xi(a2, b2, c2, e18); return b2.child; } -function hj(a, b2, c, d, e2) { - if (Zf(c)) { +function hj(a2, b2, c2, d2, e18) { + if (Zf(c2)) { var f2 = true; cg(b2); } else f2 = false; - ch(b2, e2); + ch(b2, e18); if (null === b2.stateNode) - ij(a, b2), Gi(b2, c, d), Ii(b2, c, d, e2), d = true; - else if (null === a) { - var g = b2.stateNode, h2 = b2.memoizedProps; - g.props = h2; - var k2 = g.context, l2 = c.contextType; - "object" === typeof l2 && null !== l2 ? l2 = eh(l2) : (l2 = Zf(c) ? Xf : H.current, l2 = Yf(b2, l2)); - var m2 = c.getDerivedStateFromProps, q2 = "function" === typeof m2 || "function" === typeof g.getSnapshotBeforeUpdate; - q2 || "function" !== typeof g.UNSAFE_componentWillReceiveProps && "function" !== typeof g.componentWillReceiveProps || (h2 !== d || k2 !== l2) && Hi(b2, g, d, l2); + ij(a2, b2), Gi(b2, c2, d2), Ii(b2, c2, d2, e18), d2 = true; + else if (null === a2) { + var g2 = b2.stateNode, h2 = b2.memoizedProps; + g2.props = h2; + var k2 = g2.context, l2 = c2.contextType; + "object" === typeof l2 && null !== l2 ? l2 = eh$1(l2) : (l2 = Zf(c2) ? Xf : H$1.current, l2 = Yf(b2, l2)); + var m2 = c2.getDerivedStateFromProps, q2 = "function" === typeof m2 || "function" === typeof g2.getSnapshotBeforeUpdate; + q2 || "function" !== typeof g2.UNSAFE_componentWillReceiveProps && "function" !== typeof g2.componentWillReceiveProps || (h2 !== d2 || k2 !== l2) && Hi(b2, g2, d2, l2); jh = false; var r2 = b2.memoizedState; - g.state = r2; - qh(b2, d, g, e2); + g2.state = r2; + qh(b2, d2, g2, e18); k2 = b2.memoizedState; - h2 !== d || r2 !== k2 || Wf.current || jh ? ("function" === typeof m2 && (Di(b2, c, m2, d), k2 = b2.memoizedState), (h2 = jh || Fi(b2, c, h2, d, r2, k2, l2)) ? (q2 || "function" !== typeof g.UNSAFE_componentWillMount && "function" !== typeof g.componentWillMount || ("function" === typeof g.componentWillMount && g.componentWillMount(), "function" === typeof g.UNSAFE_componentWillMount && g.UNSAFE_componentWillMount()), "function" === typeof g.componentDidMount && (b2.flags |= 4194308)) : ("function" === typeof g.componentDidMount && (b2.flags |= 4194308), b2.memoizedProps = d, b2.memoizedState = k2), g.props = d, g.state = k2, g.context = l2, d = h2) : ("function" === typeof g.componentDidMount && (b2.flags |= 4194308), d = false); + h2 !== d2 || r2 !== k2 || Wf.current || jh ? ("function" === typeof m2 && (Di(b2, c2, m2, d2), k2 = b2.memoizedState), (h2 = jh || Fi(b2, c2, h2, d2, r2, k2, l2)) ? (q2 || "function" !== typeof g2.UNSAFE_componentWillMount && "function" !== typeof g2.componentWillMount || ("function" === typeof g2.componentWillMount && g2.componentWillMount(), "function" === typeof g2.UNSAFE_componentWillMount && g2.UNSAFE_componentWillMount()), "function" === typeof g2.componentDidMount && (b2.flags |= 4194308)) : ("function" === typeof g2.componentDidMount && (b2.flags |= 4194308), b2.memoizedProps = d2, b2.memoizedState = k2), g2.props = d2, g2.state = k2, g2.context = l2, d2 = h2) : ("function" === typeof g2.componentDidMount && (b2.flags |= 4194308), d2 = false); } else { - g = b2.stateNode; - lh(a, b2); + g2 = b2.stateNode; + lh(a2, b2); h2 = b2.memoizedProps; l2 = b2.type === b2.elementType ? h2 : Ci(b2.type, h2); - g.props = l2; + g2.props = l2; q2 = b2.pendingProps; - r2 = g.context; - k2 = c.contextType; - "object" === typeof k2 && null !== k2 ? k2 = eh(k2) : (k2 = Zf(c) ? Xf : H.current, k2 = Yf(b2, k2)); - var y2 = c.getDerivedStateFromProps; - (m2 = "function" === typeof y2 || "function" === typeof g.getSnapshotBeforeUpdate) || "function" !== typeof g.UNSAFE_componentWillReceiveProps && "function" !== typeof g.componentWillReceiveProps || (h2 !== q2 || r2 !== k2) && Hi(b2, g, d, k2); + r2 = g2.context; + k2 = c2.contextType; + "object" === typeof k2 && null !== k2 ? k2 = eh$1(k2) : (k2 = Zf(c2) ? Xf : H$1.current, k2 = Yf(b2, k2)); + var y2 = c2.getDerivedStateFromProps; + (m2 = "function" === typeof y2 || "function" === typeof g2.getSnapshotBeforeUpdate) || "function" !== typeof g2.UNSAFE_componentWillReceiveProps && "function" !== typeof g2.componentWillReceiveProps || (h2 !== q2 || r2 !== k2) && Hi(b2, g2, d2, k2); jh = false; r2 = b2.memoizedState; - g.state = r2; - qh(b2, d, g, e2); + g2.state = r2; + qh(b2, d2, g2, e18); var n2 = b2.memoizedState; - h2 !== q2 || r2 !== n2 || Wf.current || jh ? ("function" === typeof y2 && (Di(b2, c, y2, d), n2 = b2.memoizedState), (l2 = jh || Fi(b2, c, l2, d, r2, n2, k2) || false) ? (m2 || "function" !== typeof g.UNSAFE_componentWillUpdate && "function" !== typeof g.componentWillUpdate || ("function" === typeof g.componentWillUpdate && g.componentWillUpdate(d, n2, k2), "function" === typeof g.UNSAFE_componentWillUpdate && g.UNSAFE_componentWillUpdate(d, n2, k2)), "function" === typeof g.componentDidUpdate && (b2.flags |= 4), "function" === typeof g.getSnapshotBeforeUpdate && (b2.flags |= 1024)) : ("function" !== typeof g.componentDidUpdate || h2 === a.memoizedProps && r2 === a.memoizedState || (b2.flags |= 4), "function" !== typeof g.getSnapshotBeforeUpdate || h2 === a.memoizedProps && r2 === a.memoizedState || (b2.flags |= 1024), b2.memoizedProps = d, b2.memoizedState = n2), g.props = d, g.state = n2, g.context = k2, d = l2) : ("function" !== typeof g.componentDidUpdate || h2 === a.memoizedProps && r2 === a.memoizedState || (b2.flags |= 4), "function" !== typeof g.getSnapshotBeforeUpdate || h2 === a.memoizedProps && r2 === a.memoizedState || (b2.flags |= 1024), d = false); + h2 !== q2 || r2 !== n2 || Wf.current || jh ? ("function" === typeof y2 && (Di(b2, c2, y2, d2), n2 = b2.memoizedState), (l2 = jh || Fi(b2, c2, l2, d2, r2, n2, k2) || false) ? (m2 || "function" !== typeof g2.UNSAFE_componentWillUpdate && "function" !== typeof g2.componentWillUpdate || ("function" === typeof g2.componentWillUpdate && g2.componentWillUpdate(d2, n2, k2), "function" === typeof g2.UNSAFE_componentWillUpdate && g2.UNSAFE_componentWillUpdate(d2, n2, k2)), "function" === typeof g2.componentDidUpdate && (b2.flags |= 4), "function" === typeof g2.getSnapshotBeforeUpdate && (b2.flags |= 1024)) : ("function" !== typeof g2.componentDidUpdate || h2 === a2.memoizedProps && r2 === a2.memoizedState || (b2.flags |= 4), "function" !== typeof g2.getSnapshotBeforeUpdate || h2 === a2.memoizedProps && r2 === a2.memoizedState || (b2.flags |= 1024), b2.memoizedProps = d2, b2.memoizedState = n2), g2.props = d2, g2.state = n2, g2.context = k2, d2 = l2) : ("function" !== typeof g2.componentDidUpdate || h2 === a2.memoizedProps && r2 === a2.memoizedState || (b2.flags |= 4), "function" !== typeof g2.getSnapshotBeforeUpdate || h2 === a2.memoizedProps && r2 === a2.memoizedState || (b2.flags |= 1024), d2 = false); } - return jj(a, b2, c, d, f2, e2); + return jj(a2, b2, c2, d2, f2, e18); } -function jj(a, b2, c, d, e2, f2) { - gj(a, b2); - var g = 0 !== (b2.flags & 128); - if (!d && !g) - return e2 && dg(b2, c, false), Zi(a, b2, f2); - d = b2.stateNode; +function jj(a2, b2, c2, d2, e18, f2) { + gj(a2, b2); + var g2 = 0 !== (b2.flags & 128); + if (!d2 && !g2) + return e18 && dg(b2, c2, false), Zi(a2, b2, f2); + d2 = b2.stateNode; Wi.current = b2; - var h2 = g && "function" !== typeof c.getDerivedStateFromError ? null : d.render(); + var h2 = g2 && "function" !== typeof c2.getDerivedStateFromError ? null : d2.render(); b2.flags |= 1; - null !== a && g ? (b2.child = Ug(b2, a.child, null, f2), b2.child = Ug(b2, null, h2, f2)) : Xi(a, b2, h2, f2); - b2.memoizedState = d.state; - e2 && dg(b2, c, true); + null !== a2 && g2 ? (b2.child = Ug(b2, a2.child, null, f2), b2.child = Ug(b2, null, h2, f2)) : Xi(a2, b2, h2, f2); + b2.memoizedState = d2.state; + e18 && dg(b2, c2, true); return b2.child; } -function kj(a) { - var b2 = a.stateNode; - b2.pendingContext ? ag(a, b2.pendingContext, b2.pendingContext !== b2.context) : b2.context && ag(a, b2.context, false); - yh(a, b2.containerInfo); +function kj(a2) { + var b2 = a2.stateNode; + b2.pendingContext ? ag(a2, b2.pendingContext, b2.pendingContext !== b2.context) : b2.context && ag(a2, b2.context, false); + yh(a2, b2.containerInfo); } -function lj(a, b2, c, d, e2) { +function lj(a2, b2, c2, d2, e18) { Ig(); - Jg(e2); + Jg(e18); b2.flags |= 256; - Xi(a, b2, c, d); + Xi(a2, b2, c2, d2); return b2.child; } var mj = { dehydrated: null, treeContext: null, retryLane: 0 }; -function nj(a) { - return { baseLanes: a, cachePool: null, transitions: null }; +function nj(a2) { + return { baseLanes: a2, cachePool: null, transitions: null }; } -function oj(a, b2, c) { - var d = b2.pendingProps, e2 = L.current, f2 = false, g = 0 !== (b2.flags & 128), h2; - (h2 = g) || (h2 = null !== a && null === a.memoizedState ? false : 0 !== (e2 & 2)); +function oj(a2, b2, c2) { + var d2 = b2.pendingProps, e18 = L.current, f2 = false, g2 = 0 !== (b2.flags & 128), h2; + (h2 = g2) || (h2 = null !== a2 && null === a2.memoizedState ? false : 0 !== (e18 & 2)); if (h2) f2 = true, b2.flags &= -129; - else if (null === a || null !== a.memoizedState) - e2 |= 1; - G(L, e2 & 1); - if (null === a) { + else if (null === a2 || null !== a2.memoizedState) + e18 |= 1; + G$1(L, e18 & 1); + if (null === a2) { Eg(b2); - a = b2.memoizedState; - if (null !== a && (a = a.dehydrated, null !== a)) - return 0 === (b2.mode & 1) ? b2.lanes = 1 : "$!" === a.data ? b2.lanes = 8 : b2.lanes = 1073741824, null; - g = d.children; - a = d.fallback; - return f2 ? (d = b2.mode, f2 = b2.child, g = { mode: "hidden", children: g }, 0 === (d & 1) && null !== f2 ? (f2.childLanes = 0, f2.pendingProps = g) : f2 = pj(g, d, 0, null), a = Tg(a, d, c, null), f2.return = b2, a.return = b2, f2.sibling = a, b2.child = f2, b2.child.memoizedState = nj(c), b2.memoizedState = mj, a) : qj(b2, g); - } - e2 = a.memoizedState; - if (null !== e2 && (h2 = e2.dehydrated, null !== h2)) - return rj(a, b2, g, d, h2, e2, c); + a2 = b2.memoizedState; + if (null !== a2 && (a2 = a2.dehydrated, null !== a2)) + return 0 === (b2.mode & 1) ? b2.lanes = 1 : "$!" === a2.data ? b2.lanes = 8 : b2.lanes = 1073741824, null; + g2 = d2.children; + a2 = d2.fallback; + return f2 ? (d2 = b2.mode, f2 = b2.child, g2 = { mode: "hidden", children: g2 }, 0 === (d2 & 1) && null !== f2 ? (f2.childLanes = 0, f2.pendingProps = g2) : f2 = pj(g2, d2, 0, null), a2 = Tg(a2, d2, c2, null), f2.return = b2, a2.return = b2, f2.sibling = a2, b2.child = f2, b2.child.memoizedState = nj(c2), b2.memoizedState = mj, a2) : qj(b2, g2); + } + e18 = a2.memoizedState; + if (null !== e18 && (h2 = e18.dehydrated, null !== h2)) + return rj$1(a2, b2, g2, d2, h2, e18, c2); if (f2) { - f2 = d.fallback; - g = b2.mode; - e2 = a.child; - h2 = e2.sibling; - var k2 = { mode: "hidden", children: d.children }; - 0 === (g & 1) && b2.child !== e2 ? (d = b2.child, d.childLanes = 0, d.pendingProps = k2, b2.deletions = null) : (d = Pg(e2, k2), d.subtreeFlags = e2.subtreeFlags & 14680064); - null !== h2 ? f2 = Pg(h2, f2) : (f2 = Tg(f2, g, c, null), f2.flags |= 2); + f2 = d2.fallback; + g2 = b2.mode; + e18 = a2.child; + h2 = e18.sibling; + var k2 = { mode: "hidden", children: d2.children }; + 0 === (g2 & 1) && b2.child !== e18 ? (d2 = b2.child, d2.childLanes = 0, d2.pendingProps = k2, b2.deletions = null) : (d2 = Pg(e18, k2), d2.subtreeFlags = e18.subtreeFlags & 14680064); + null !== h2 ? f2 = Pg(h2, f2) : (f2 = Tg(f2, g2, c2, null), f2.flags |= 2); f2.return = b2; - d.return = b2; - d.sibling = f2; - b2.child = d; - d = f2; + d2.return = b2; + d2.sibling = f2; + b2.child = d2; + d2 = f2; f2 = b2.child; - g = a.child.memoizedState; - g = null === g ? nj(c) : { baseLanes: g.baseLanes | c, cachePool: null, transitions: g.transitions }; - f2.memoizedState = g; - f2.childLanes = a.childLanes & ~c; + g2 = a2.child.memoizedState; + g2 = null === g2 ? nj(c2) : { baseLanes: g2.baseLanes | c2, cachePool: null, transitions: g2.transitions }; + f2.memoizedState = g2; + f2.childLanes = a2.childLanes & ~c2; b2.memoizedState = mj; - return d; - } - f2 = a.child; - a = f2.sibling; - d = Pg(f2, { mode: "visible", children: d.children }); - 0 === (b2.mode & 1) && (d.lanes = c); - d.return = b2; - d.sibling = null; - null !== a && (c = b2.deletions, null === c ? (b2.deletions = [a], b2.flags |= 16) : c.push(a)); - b2.child = d; + return d2; + } + f2 = a2.child; + a2 = f2.sibling; + d2 = Pg(f2, { mode: "visible", children: d2.children }); + 0 === (b2.mode & 1) && (d2.lanes = c2); + d2.return = b2; + d2.sibling = null; + null !== a2 && (c2 = b2.deletions, null === c2 ? (b2.deletions = [a2], b2.flags |= 16) : c2.push(a2)); + b2.child = d2; b2.memoizedState = null; - return d; -} -function qj(a, b2) { - b2 = pj({ mode: "visible", children: b2 }, a.mode, 0, null); - b2.return = a; - return a.child = b2; -} -function sj(a, b2, c, d) { - null !== d && Jg(d); - Ug(b2, a.child, null, c); - a = qj(b2, b2.pendingProps.children); - a.flags |= 2; + return d2; +} +function qj(a2, b2) { + b2 = pj({ mode: "visible", children: b2 }, a2.mode, 0, null); + b2.return = a2; + return a2.child = b2; +} +function sj(a2, b2, c2, d2) { + null !== d2 && Jg(d2); + Ug(b2, a2.child, null, c2); + a2 = qj(b2, b2.pendingProps.children); + a2.flags |= 2; b2.memoizedState = null; - return a; + return a2; } -function rj(a, b2, c, d, e2, f2, g) { - if (c) { +function rj$1(a2, b2, c2, d2, e18, f2, g2) { + if (c2) { if (b2.flags & 256) - return b2.flags &= -257, d = Ki(Error(p$2(422))), sj(a, b2, g, d); + return b2.flags &= -257, d2 = Ki(Error(p$3(422))), sj(a2, b2, g2, d2); if (null !== b2.memoizedState) - return b2.child = a.child, b2.flags |= 128, null; - f2 = d.fallback; - e2 = b2.mode; - d = pj({ mode: "visible", children: d.children }, e2, 0, null); - f2 = Tg(f2, e2, g, null); + return b2.child = a2.child, b2.flags |= 128, null; + f2 = d2.fallback; + e18 = b2.mode; + d2 = pj({ mode: "visible", children: d2.children }, e18, 0, null); + f2 = Tg(f2, e18, g2, null); f2.flags |= 2; - d.return = b2; + d2.return = b2; f2.return = b2; - d.sibling = f2; - b2.child = d; - 0 !== (b2.mode & 1) && Ug(b2, a.child, null, g); - b2.child.memoizedState = nj(g); + d2.sibling = f2; + b2.child = d2; + 0 !== (b2.mode & 1) && Ug(b2, a2.child, null, g2); + b2.child.memoizedState = nj(g2); b2.memoizedState = mj; return f2; } if (0 === (b2.mode & 1)) - return sj(a, b2, g, null); - if ("$!" === e2.data) { - d = e2.nextSibling && e2.nextSibling.dataset; - if (d) - var h2 = d.dgst; - d = h2; - f2 = Error(p$2(419)); - d = Ki(f2, d, void 0); - return sj(a, b2, g, d); - } - h2 = 0 !== (g & a.childLanes); + return sj(a2, b2, g2, null); + if ("$!" === e18.data) { + d2 = e18.nextSibling && e18.nextSibling.dataset; + if (d2) + var h2 = d2.dgst; + d2 = h2; + f2 = Error(p$3(419)); + d2 = Ki(f2, d2, void 0); + return sj(a2, b2, g2, d2); + } + h2 = 0 !== (g2 & a2.childLanes); if (dh || h2) { - d = Q; - if (null !== d) { - switch (g & -g) { + d2 = Q$1; + if (null !== d2) { + switch (g2 & -g2) { case 4: - e2 = 2; + e18 = 2; break; case 16: - e2 = 8; + e18 = 8; break; case 64: case 128: @@ -4664,102 +4683,102 @@ function rj(a, b2, c, d, e2, f2, g) { case 16777216: case 33554432: case 67108864: - e2 = 32; + e18 = 32; break; case 536870912: - e2 = 268435456; + e18 = 268435456; break; default: - e2 = 0; + e18 = 0; } - e2 = 0 !== (e2 & (d.suspendedLanes | g)) ? 0 : e2; - 0 !== e2 && e2 !== f2.retryLane && (f2.retryLane = e2, ih(a, e2), gi(d, a, e2, -1)); + e18 = 0 !== (e18 & (d2.suspendedLanes | g2)) ? 0 : e18; + 0 !== e18 && e18 !== f2.retryLane && (f2.retryLane = e18, ih(a2, e18), gi(d2, a2, e18, -1)); } tj(); - d = Ki(Error(p$2(421))); - return sj(a, b2, g, d); + d2 = Ki(Error(p$3(421))); + return sj(a2, b2, g2, d2); } - if ("$?" === e2.data) - return b2.flags |= 128, b2.child = a.child, b2 = uj.bind(null, a), e2._reactRetry = b2, null; - a = f2.treeContext; - yg = Lf(e2.nextSibling); + if ("$?" === e18.data) + return b2.flags |= 128, b2.child = a2.child, b2 = uj.bind(null, a2), e18._reactRetry = b2, null; + a2 = f2.treeContext; + yg = Lf(e18.nextSibling); xg = b2; - I = true; + I$1 = true; zg = null; - null !== a && (og[pg++] = rg, og[pg++] = sg, og[pg++] = qg, rg = a.id, sg = a.overflow, qg = b2); - b2 = qj(b2, d.children); + null !== a2 && (og[pg++] = rg, og[pg++] = sg, og[pg++] = qg, rg = a2.id, sg = a2.overflow, qg = b2); + b2 = qj(b2, d2.children); b2.flags |= 4096; return b2; } -function vj(a, b2, c) { - a.lanes |= b2; - var d = a.alternate; - null !== d && (d.lanes |= b2); - bh(a.return, b2, c); -} -function wj(a, b2, c, d, e2) { - var f2 = a.memoizedState; - null === f2 ? a.memoizedState = { isBackwards: b2, rendering: null, renderingStartTime: 0, last: d, tail: c, tailMode: e2 } : (f2.isBackwards = b2, f2.rendering = null, f2.renderingStartTime = 0, f2.last = d, f2.tail = c, f2.tailMode = e2); -} -function xj(a, b2, c) { - var d = b2.pendingProps, e2 = d.revealOrder, f2 = d.tail; - Xi(a, b2, d.children, c); - d = L.current; - if (0 !== (d & 2)) - d = d & 1 | 2, b2.flags |= 128; +function vj(a2, b2, c2) { + a2.lanes |= b2; + var d2 = a2.alternate; + null !== d2 && (d2.lanes |= b2); + bh(a2.return, b2, c2); +} +function wj(a2, b2, c2, d2, e18) { + var f2 = a2.memoizedState; + null === f2 ? a2.memoizedState = { isBackwards: b2, rendering: null, renderingStartTime: 0, last: d2, tail: c2, tailMode: e18 } : (f2.isBackwards = b2, f2.rendering = null, f2.renderingStartTime = 0, f2.last = d2, f2.tail = c2, f2.tailMode = e18); +} +function xj(a2, b2, c2) { + var d2 = b2.pendingProps, e18 = d2.revealOrder, f2 = d2.tail; + Xi(a2, b2, d2.children, c2); + d2 = L.current; + if (0 !== (d2 & 2)) + d2 = d2 & 1 | 2, b2.flags |= 128; else { - if (null !== a && 0 !== (a.flags & 128)) + if (null !== a2 && 0 !== (a2.flags & 128)) a: - for (a = b2.child; null !== a; ) { - if (13 === a.tag) - null !== a.memoizedState && vj(a, c, b2); - else if (19 === a.tag) - vj(a, c, b2); - else if (null !== a.child) { - a.child.return = a; - a = a.child; + for (a2 = b2.child; null !== a2; ) { + if (13 === a2.tag) + null !== a2.memoizedState && vj(a2, c2, b2); + else if (19 === a2.tag) + vj(a2, c2, b2); + else if (null !== a2.child) { + a2.child.return = a2; + a2 = a2.child; continue; } - if (a === b2) + if (a2 === b2) break a; - for (; null === a.sibling; ) { - if (null === a.return || a.return === b2) + for (; null === a2.sibling; ) { + if (null === a2.return || a2.return === b2) break a; - a = a.return; + a2 = a2.return; } - a.sibling.return = a.return; - a = a.sibling; + a2.sibling.return = a2.return; + a2 = a2.sibling; } - d &= 1; + d2 &= 1; } - G(L, d); + G$1(L, d2); if (0 === (b2.mode & 1)) b2.memoizedState = null; else - switch (e2) { + switch (e18) { case "forwards": - c = b2.child; - for (e2 = null; null !== c; ) - a = c.alternate, null !== a && null === Ch(a) && (e2 = c), c = c.sibling; - c = e2; - null === c ? (e2 = b2.child, b2.child = null) : (e2 = c.sibling, c.sibling = null); - wj(b2, false, e2, c, f2); + c2 = b2.child; + for (e18 = null; null !== c2; ) + a2 = c2.alternate, null !== a2 && null === Ch(a2) && (e18 = c2), c2 = c2.sibling; + c2 = e18; + null === c2 ? (e18 = b2.child, b2.child = null) : (e18 = c2.sibling, c2.sibling = null); + wj(b2, false, e18, c2, f2); break; case "backwards": - c = null; - e2 = b2.child; - for (b2.child = null; null !== e2; ) { - a = e2.alternate; - if (null !== a && null === Ch(a)) { - b2.child = e2; + c2 = null; + e18 = b2.child; + for (b2.child = null; null !== e18; ) { + a2 = e18.alternate; + if (null !== a2 && null === Ch(a2)) { + b2.child = e18; break; } - a = e2.sibling; - e2.sibling = c; - c = e2; - e2 = a; + a2 = e18.sibling; + e18.sibling = c2; + c2 = e18; + e18 = a2; } - wj(b2, true, c, null, f2); + wj(b2, true, c2, null, f2); break; case "together": wj(b2, false, null, null, void 0); @@ -4769,27 +4788,27 @@ function xj(a, b2, c) { } return b2.child; } -function ij(a, b2) { - 0 === (b2.mode & 1) && null !== a && (a.alternate = null, b2.alternate = null, b2.flags |= 2); +function ij(a2, b2) { + 0 === (b2.mode & 1) && null !== a2 && (a2.alternate = null, b2.alternate = null, b2.flags |= 2); } -function Zi(a, b2, c) { - null !== a && (b2.dependencies = a.dependencies); - rh |= b2.lanes; - if (0 === (c & b2.childLanes)) +function Zi(a2, b2, c2) { + null !== a2 && (b2.dependencies = a2.dependencies); + rh$2 |= b2.lanes; + if (0 === (c2 & b2.childLanes)) return null; - if (null !== a && b2.child !== a.child) - throw Error(p$2(153)); + if (null !== a2 && b2.child !== a2.child) + throw Error(p$3(153)); if (null !== b2.child) { - a = b2.child; - c = Pg(a, a.pendingProps); - b2.child = c; - for (c.return = b2; null !== a.sibling; ) - a = a.sibling, c = c.sibling = Pg(a, a.pendingProps), c.return = b2; - c.sibling = null; + a2 = b2.child; + c2 = Pg(a2, a2.pendingProps); + b2.child = c2; + for (c2.return = b2; null !== a2.sibling; ) + a2 = a2.sibling, c2 = c2.sibling = Pg(a2, a2.pendingProps), c2.return = b2; + c2.sibling = null; } return b2.child; } -function yj(a, b2, c) { +function yj(a2, b2, c2) { switch (b2.tag) { case 3: kj(b2); @@ -4805,159 +4824,159 @@ function yj(a, b2, c) { yh(b2, b2.stateNode.containerInfo); break; case 10: - var d = b2.type._context, e2 = b2.memoizedProps.value; - G(Wg, d._currentValue); - d._currentValue = e2; + var d2 = b2.type._context, e18 = b2.memoizedProps.value; + G$1(Wg, d2._currentValue); + d2._currentValue = e18; break; case 13: - d = b2.memoizedState; - if (null !== d) { - if (null !== d.dehydrated) - return G(L, L.current & 1), b2.flags |= 128, null; - if (0 !== (c & b2.child.childLanes)) - return oj(a, b2, c); - G(L, L.current & 1); - a = Zi(a, b2, c); - return null !== a ? a.sibling : null; - } - G(L, L.current & 1); + d2 = b2.memoizedState; + if (null !== d2) { + if (null !== d2.dehydrated) + return G$1(L, L.current & 1), b2.flags |= 128, null; + if (0 !== (c2 & b2.child.childLanes)) + return oj(a2, b2, c2); + G$1(L, L.current & 1); + a2 = Zi(a2, b2, c2); + return null !== a2 ? a2.sibling : null; + } + G$1(L, L.current & 1); break; case 19: - d = 0 !== (c & b2.childLanes); - if (0 !== (a.flags & 128)) { - if (d) - return xj(a, b2, c); + d2 = 0 !== (c2 & b2.childLanes); + if (0 !== (a2.flags & 128)) { + if (d2) + return xj(a2, b2, c2); b2.flags |= 128; } - e2 = b2.memoizedState; - null !== e2 && (e2.rendering = null, e2.tail = null, e2.lastEffect = null); - G(L, L.current); - if (d) + e18 = b2.memoizedState; + null !== e18 && (e18.rendering = null, e18.tail = null, e18.lastEffect = null); + G$1(L, L.current); + if (d2) break; else return null; case 22: case 23: - return b2.lanes = 0, dj(a, b2, c); + return b2.lanes = 0, dj(a2, b2, c2); } - return Zi(a, b2, c); + return Zi(a2, b2, c2); } var zj, Aj, Bj, Cj; -zj = function(a, b2) { - for (var c = b2.child; null !== c; ) { - if (5 === c.tag || 6 === c.tag) - a.appendChild(c.stateNode); - else if (4 !== c.tag && null !== c.child) { - c.child.return = c; - c = c.child; +zj = function(a2, b2) { + for (var c2 = b2.child; null !== c2; ) { + if (5 === c2.tag || 6 === c2.tag) + a2.appendChild(c2.stateNode); + else if (4 !== c2.tag && null !== c2.child) { + c2.child.return = c2; + c2 = c2.child; continue; } - if (c === b2) + if (c2 === b2) break; - for (; null === c.sibling; ) { - if (null === c.return || c.return === b2) + for (; null === c2.sibling; ) { + if (null === c2.return || c2.return === b2) return; - c = c.return; + c2 = c2.return; } - c.sibling.return = c.return; - c = c.sibling; + c2.sibling.return = c2.return; + c2 = c2.sibling; } }; Aj = function() { }; -Bj = function(a, b2, c, d) { - var e2 = a.memoizedProps; - if (e2 !== d) { - a = b2.stateNode; +Bj = function(a2, b2, c2, d2) { + var e18 = a2.memoizedProps; + if (e18 !== d2) { + a2 = b2.stateNode; xh(uh.current); var f2 = null; - switch (c) { + switch (c2) { case "input": - e2 = Ya(a, e2); - d = Ya(a, d); + e18 = Ya(a2, e18); + d2 = Ya(a2, d2); f2 = []; break; case "select": - e2 = A({}, e2, { value: void 0 }); - d = A({}, d, { value: void 0 }); + e18 = A$1({}, e18, { value: void 0 }); + d2 = A$1({}, d2, { value: void 0 }); f2 = []; break; case "textarea": - e2 = gb(a, e2); - d = gb(a, d); + e18 = gb(a2, e18); + d2 = gb(a2, d2); f2 = []; break; default: - "function" !== typeof e2.onClick && "function" === typeof d.onClick && (a.onclick = Bf); + "function" !== typeof e18.onClick && "function" === typeof d2.onClick && (a2.onclick = Bf); } - ub(c, d); - var g; - c = null; - for (l2 in e2) - if (!d.hasOwnProperty(l2) && e2.hasOwnProperty(l2) && null != e2[l2]) + ub(c2, d2); + var g2; + c2 = null; + for (l2 in e18) + if (!d2.hasOwnProperty(l2) && e18.hasOwnProperty(l2) && null != e18[l2]) if ("style" === l2) { - var h2 = e2[l2]; - for (g in h2) - h2.hasOwnProperty(g) && (c || (c = {}), c[g] = ""); + var h2 = e18[l2]; + for (g2 in h2) + h2.hasOwnProperty(g2) && (c2 || (c2 = {}), c2[g2] = ""); } else - "dangerouslySetInnerHTML" !== l2 && "children" !== l2 && "suppressContentEditableWarning" !== l2 && "suppressHydrationWarning" !== l2 && "autoFocus" !== l2 && (ea.hasOwnProperty(l2) ? f2 || (f2 = []) : (f2 = f2 || []).push(l2, null)); - for (l2 in d) { - var k2 = d[l2]; - h2 = null != e2 ? e2[l2] : void 0; - if (d.hasOwnProperty(l2) && k2 !== h2 && (null != k2 || null != h2)) + "dangerouslySetInnerHTML" !== l2 && "children" !== l2 && "suppressContentEditableWarning" !== l2 && "suppressHydrationWarning" !== l2 && "autoFocus" !== l2 && (ea$1.hasOwnProperty(l2) ? f2 || (f2 = []) : (f2 = f2 || []).push(l2, null)); + for (l2 in d2) { + var k2 = d2[l2]; + h2 = null != e18 ? e18[l2] : void 0; + if (d2.hasOwnProperty(l2) && k2 !== h2 && (null != k2 || null != h2)) if ("style" === l2) if (h2) { - for (g in h2) - !h2.hasOwnProperty(g) || k2 && k2.hasOwnProperty(g) || (c || (c = {}), c[g] = ""); - for (g in k2) - k2.hasOwnProperty(g) && h2[g] !== k2[g] && (c || (c = {}), c[g] = k2[g]); + for (g2 in h2) + !h2.hasOwnProperty(g2) || k2 && k2.hasOwnProperty(g2) || (c2 || (c2 = {}), c2[g2] = ""); + for (g2 in k2) + k2.hasOwnProperty(g2) && h2[g2] !== k2[g2] && (c2 || (c2 = {}), c2[g2] = k2[g2]); } else - c || (f2 || (f2 = []), f2.push( + c2 || (f2 || (f2 = []), f2.push( l2, - c - )), c = k2; + c2 + )), c2 = k2; else - "dangerouslySetInnerHTML" === l2 ? (k2 = k2 ? k2.__html : void 0, h2 = h2 ? h2.__html : void 0, null != k2 && h2 !== k2 && (f2 = f2 || []).push(l2, k2)) : "children" === l2 ? "string" !== typeof k2 && "number" !== typeof k2 || (f2 = f2 || []).push(l2, "" + k2) : "suppressContentEditableWarning" !== l2 && "suppressHydrationWarning" !== l2 && (ea.hasOwnProperty(l2) ? (null != k2 && "onScroll" === l2 && D("scroll", a), f2 || h2 === k2 || (f2 = [])) : (f2 = f2 || []).push(l2, k2)); + "dangerouslySetInnerHTML" === l2 ? (k2 = k2 ? k2.__html : void 0, h2 = h2 ? h2.__html : void 0, null != k2 && h2 !== k2 && (f2 = f2 || []).push(l2, k2)) : "children" === l2 ? "string" !== typeof k2 && "number" !== typeof k2 || (f2 = f2 || []).push(l2, "" + k2) : "suppressContentEditableWarning" !== l2 && "suppressHydrationWarning" !== l2 && (ea$1.hasOwnProperty(l2) ? (null != k2 && "onScroll" === l2 && D$1("scroll", a2), f2 || h2 === k2 || (f2 = [])) : (f2 = f2 || []).push(l2, k2)); } - c && (f2 = f2 || []).push("style", c); + c2 && (f2 = f2 || []).push("style", c2); var l2 = f2; if (b2.updateQueue = l2) b2.flags |= 4; } }; -Cj = function(a, b2, c, d) { - c !== d && (b2.flags |= 4); +Cj = function(a2, b2, c2, d2) { + c2 !== d2 && (b2.flags |= 4); }; -function Dj(a, b2) { - if (!I) - switch (a.tailMode) { +function Dj(a2, b2) { + if (!I$1) + switch (a2.tailMode) { case "hidden": - b2 = a.tail; - for (var c = null; null !== b2; ) - null !== b2.alternate && (c = b2), b2 = b2.sibling; - null === c ? a.tail = null : c.sibling = null; + b2 = a2.tail; + for (var c2 = null; null !== b2; ) + null !== b2.alternate && (c2 = b2), b2 = b2.sibling; + null === c2 ? a2.tail = null : c2.sibling = null; break; case "collapsed": - c = a.tail; - for (var d = null; null !== c; ) - null !== c.alternate && (d = c), c = c.sibling; - null === d ? b2 || null === a.tail ? a.tail = null : a.tail.sibling = null : d.sibling = null; + c2 = a2.tail; + for (var d2 = null; null !== c2; ) + null !== c2.alternate && (d2 = c2), c2 = c2.sibling; + null === d2 ? b2 || null === a2.tail ? a2.tail = null : a2.tail.sibling = null : d2.sibling = null; } } -function S$1(a) { - var b2 = null !== a.alternate && a.alternate.child === a.child, c = 0, d = 0; +function S$2(a2) { + var b2 = null !== a2.alternate && a2.alternate.child === a2.child, c2 = 0, d2 = 0; if (b2) - for (var e2 = a.child; null !== e2; ) - c |= e2.lanes | e2.childLanes, d |= e2.subtreeFlags & 14680064, d |= e2.flags & 14680064, e2.return = a, e2 = e2.sibling; + for (var e18 = a2.child; null !== e18; ) + c2 |= e18.lanes | e18.childLanes, d2 |= e18.subtreeFlags & 14680064, d2 |= e18.flags & 14680064, e18.return = a2, e18 = e18.sibling; else - for (e2 = a.child; null !== e2; ) - c |= e2.lanes | e2.childLanes, d |= e2.subtreeFlags, d |= e2.flags, e2.return = a, e2 = e2.sibling; - a.subtreeFlags |= d; - a.childLanes = c; + for (e18 = a2.child; null !== e18; ) + c2 |= e18.lanes | e18.childLanes, d2 |= e18.subtreeFlags, d2 |= e18.flags, e18.return = a2, e18 = e18.sibling; + a2.subtreeFlags |= d2; + a2.childLanes = c2; return b2; } -function Ej(a, b2, c) { - var d = b2.pendingProps; +function Ej(a2, b2, c2) { + var d2 = b2.pendingProps; wg(b2); switch (b2.tag) { case 2: @@ -4970,277 +4989,277 @@ function Ej(a, b2, c) { case 12: case 9: case 14: - return S$1(b2), null; + return S$2(b2), null; case 1: - return Zf(b2.type) && $f(), S$1(b2), null; + return Zf(b2.type) && $f(), S$2(b2), null; case 3: - d = b2.stateNode; + d2 = b2.stateNode; zh(); - E(Wf); - E(H); + E$1(Wf); + E$1(H$1); Eh(); - d.pendingContext && (d.context = d.pendingContext, d.pendingContext = null); - if (null === a || null === a.child) - Gg(b2) ? b2.flags |= 4 : null === a || a.memoizedState.isDehydrated && 0 === (b2.flags & 256) || (b2.flags |= 1024, null !== zg && (Fj(zg), zg = null)); - Aj(a, b2); - S$1(b2); + d2.pendingContext && (d2.context = d2.pendingContext, d2.pendingContext = null); + if (null === a2 || null === a2.child) + Gg(b2) ? b2.flags |= 4 : null === a2 || a2.memoizedState.isDehydrated && 0 === (b2.flags & 256) || (b2.flags |= 1024, null !== zg && (Fj(zg), zg = null)); + Aj(a2, b2); + S$2(b2); return null; case 5: Bh(b2); - var e2 = xh(wh.current); - c = b2.type; - if (null !== a && null != b2.stateNode) - Bj(a, b2, c, d, e2), a.ref !== b2.ref && (b2.flags |= 512, b2.flags |= 2097152); + var e18 = xh(wh.current); + c2 = b2.type; + if (null !== a2 && null != b2.stateNode) + Bj(a2, b2, c2, d2, e18), a2.ref !== b2.ref && (b2.flags |= 512, b2.flags |= 2097152); else { - if (!d) { + if (!d2) { if (null === b2.stateNode) - throw Error(p$2(166)); - S$1(b2); + throw Error(p$3(166)); + S$2(b2); return null; } - a = xh(uh.current); + a2 = xh(uh.current); if (Gg(b2)) { - d = b2.stateNode; - c = b2.type; + d2 = b2.stateNode; + c2 = b2.type; var f2 = b2.memoizedProps; - d[Of] = b2; - d[Pf] = f2; - a = 0 !== (b2.mode & 1); - switch (c) { + d2[Of] = b2; + d2[Pf] = f2; + a2 = 0 !== (b2.mode & 1); + switch (c2) { case "dialog": - D("cancel", d); - D("close", d); + D$1("cancel", d2); + D$1("close", d2); break; case "iframe": case "object": case "embed": - D("load", d); + D$1("load", d2); break; case "video": case "audio": - for (e2 = 0; e2 < lf.length; e2++) - D(lf[e2], d); + for (e18 = 0; e18 < lf.length; e18++) + D$1(lf[e18], d2); break; case "source": - D("error", d); + D$1("error", d2); break; case "img": case "image": case "link": - D( + D$1( "error", - d + d2 ); - D("load", d); + D$1("load", d2); break; case "details": - D("toggle", d); + D$1("toggle", d2); break; case "input": - Za(d, f2); - D("invalid", d); + Za(d2, f2); + D$1("invalid", d2); break; case "select": - d._wrapperState = { wasMultiple: !!f2.multiple }; - D("invalid", d); + d2._wrapperState = { wasMultiple: !!f2.multiple }; + D$1("invalid", d2); break; case "textarea": - hb(d, f2), D("invalid", d); + hb(d2, f2), D$1("invalid", d2); } - ub(c, f2); - e2 = null; - for (var g in f2) - if (f2.hasOwnProperty(g)) { - var h2 = f2[g]; - "children" === g ? "string" === typeof h2 ? d.textContent !== h2 && (true !== f2.suppressHydrationWarning && Af(d.textContent, h2, a), e2 = ["children", h2]) : "number" === typeof h2 && d.textContent !== "" + h2 && (true !== f2.suppressHydrationWarning && Af( - d.textContent, + ub(c2, f2); + e18 = null; + for (var g2 in f2) + if (f2.hasOwnProperty(g2)) { + var h2 = f2[g2]; + "children" === g2 ? "string" === typeof h2 ? d2.textContent !== h2 && (true !== f2.suppressHydrationWarning && Af(d2.textContent, h2, a2), e18 = ["children", h2]) : "number" === typeof h2 && d2.textContent !== "" + h2 && (true !== f2.suppressHydrationWarning && Af( + d2.textContent, h2, - a - ), e2 = ["children", "" + h2]) : ea.hasOwnProperty(g) && null != h2 && "onScroll" === g && D("scroll", d); + a2 + ), e18 = ["children", "" + h2]) : ea$1.hasOwnProperty(g2) && null != h2 && "onScroll" === g2 && D$1("scroll", d2); } - switch (c) { + switch (c2) { case "input": - Va(d); - db(d, f2, true); + Va(d2); + db(d2, f2, true); break; case "textarea": - Va(d); - jb(d); + Va(d2); + jb(d2); break; case "select": case "option": break; default: - "function" === typeof f2.onClick && (d.onclick = Bf); + "function" === typeof f2.onClick && (d2.onclick = Bf); } - d = e2; - b2.updateQueue = d; - null !== d && (b2.flags |= 4); + d2 = e18; + b2.updateQueue = d2; + null !== d2 && (b2.flags |= 4); } else { - g = 9 === e2.nodeType ? e2 : e2.ownerDocument; - "http://www.w3.org/1999/xhtml" === a && (a = kb(c)); - "http://www.w3.org/1999/xhtml" === a ? "script" === c ? (a = g.createElement("div"), a.innerHTML = " - + +