cppay-sdk 0.0.2-beta.24 → 0.0.2-beta.26

package/dist/polygon-1pLQCNfb.js

@@ -0,0 +1,3952 @@
+var __create = Object.create, __defProp = Object.defineProperty, __getOwnPropDesc = Object.getOwnPropertyDescriptor, __getOwnPropNames = Object.getOwnPropertyNames, __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty, __commonJSMin = (e, C) => () => (C || e((C = { exports: {} }).exports, C), C.exports), __copyProps = (e, E, O, k) => {
+	if (E && typeof E == "object" || typeof E == "function") for (var A = __getOwnPropNames(E), j = 0, M = A.length, N; j < M; j++) N = A[j], !__hasOwnProp.call(e, N) && N !== O && __defProp(e, N, {
+		get: ((e) => E[e]).bind(null, N),
+		enumerable: !(k = __getOwnPropDesc(E, N)) || k.enumerable
+	});
+	return e;
+}, __toESM = (w, T, D) => (D = w == null ? {} : __create(__getProtoOf(w)), __copyProps(T || !w || !w.__esModule ? __defProp(D, "default", {
+	value: w,
+	enumerable: !0
+}) : D, w)), __require = /* @__PURE__ */ ((e) => typeof require < "u" ? require : typeof Proxy < "u" ? new Proxy(e, { get: (e, C) => (typeof require < "u" ? require : e)[C] }) : e)(function(e) {
+	if (typeof require < "u") return require.apply(this, arguments);
+	throw Error("Calling `require` for \"" + e + "\" in an environment that doesn't expose the `require` function.");
+}), payment_dialog_default = "._cppay-overlay{z-index:999;background-color:#00000080;justify-content:center;align-items:center;padding:1rem;display:flex;position:fixed;inset:0}._cppay-dialog{background-color:#fff;border-radius:1.5rem;flex-direction:column;width:100%;max-width:28rem;max-height:90vh;display:flex;overflow:hidden;box-shadow:0 20px 25px -5px #0000001a,0 10px 10px -5px #0000000a}._cppay-header{border-bottom:1px solid #e5e7eb;justify-content:space-between;align-items:center;padding:1rem 1.25rem;display:flex}._cppay-title{color:#111827;margin:0;font-size:1.25rem;font-weight:600}._cppay-close-btn{color:#9ca3af;cursor:pointer;background:0 0;border:none;padding:.25rem;transition:color .2s}._cppay-close-btn:hover:not(:disabled){color:#4b5563}._cppay-close-btn:disabled{opacity:.5;cursor:not-allowed}._cppay-close-btn svg{width:1.5rem;height:1.5rem}._cppay-content{flex:1;padding:1.25rem;overflow-y:auto}._cppay-section{margin-bottom:1rem}._cppay-section:last-child{margin-bottom:0}._cppay-label{color:#374151;margin-bottom:.5rem;font-size:.875rem;font-weight:500;display:block}._cppay-grid{grid-template-columns:repeat(2,1fr);gap:.75rem;display:grid}._cppay-select-btn{cursor:pointer;background:#fff;border:2px solid #e5e7eb;border-radius:.75rem;align-items:center;gap:.5rem;padding:.75rem;font-family:inherit;font-size:.875rem;transition:all .2s;display:flex}._cppay-select-btn:hover{border-color:#d1d5db}._cppay-select-btn._cppay-selected{background-color:#eff6ff;border-color:#2563eb}._cppay-select-btn img{border-radius:9999px;width:1.5rem;height:1.5rem}._cppay-select-btn span{font-weight:500}._cppay-price-box{background-color:#f9fafb;border-radius:1rem;padding:1rem}._cppay-price-row{justify-content:space-between;align-items:center;display:flex}._cppay-price-label{color:#4b5563;font-size:.875rem}._cppay-price-amount{text-align:right}._cppay-price-main{color:#111827;margin:0;font-size:1.25rem;font-weight:700}._cppay-price-sub{color:#6b7280;margin-top:.25rem;font-size:.875rem}._cppay-btn{cursor:pointer;border:none;border-radius:.75rem;width:100%;padding:.75rem;font-family:inherit;font-size:1rem;font-weight:500;transition:all .2s}._cppay-btn-primary{color:#fff;background-color:#2563eb}._cppay-btn-primary:hover:not(:disabled){background-color:#1d4ed8}._cppay-btn-primary:disabled{opacity:.5;cursor:not-allowed}._cppay-btn-secondary{color:#374151;background-color:#fff;border:1px solid #d1d5db}._cppay-btn-secondary:hover:not(:disabled){background-color:#f9fafb}._cppay-btn-secondary:disabled{opacity:.5;cursor:not-allowed}._cppay-btn-text{color:#6b7280;text-align:center;background:0 0;border:none;padding:.5rem;font-size:.875rem}._cppay-btn-text:hover:not(:disabled){color:#2563eb;background:0 0}._cppay-btn-text:disabled{opacity:.5;cursor:not-allowed}._cppay-btn-container{align-items:center;gap:.5rem;display:flex}._cppay-qr-container{justify-content:center;margin-bottom:1rem;display:flex}._cppay-qr-code{background:linear-gradient(135deg,#667eea 0%,#764ba2 100%);border-radius:1rem;padding:.75rem;box-shadow:0 4px 12px #667eea26}._cppay-qr-placeholder{background-color:#f3f4f6;border-radius:.75rem;justify-content:center;align-items:center;width:10rem;height:10rem;display:flex}._cppay-qr-placeholder span{color:#9ca3af;font-size:.875rem}._cppay-info-box{background-color:#f9fafb;border-radius:.75rem;margin-bottom:.625rem;padding:.875rem}._cppay-info-box:last-child{margin-bottom:0}._cppay-info-label{color:#4b5563;margin-bottom:.25rem;font-size:.875rem}._cppay-info-value{color:#111827;font-size:1.25rem;font-weight:700}._cppay-address-row{align-items:center;gap:.5rem;display:flex}._cppay-address-row code{text-overflow:ellipsis;white-space:nowrap;color:#111827;background:0 0;flex:1;font-family:monospace;font-size:.75rem;overflow:hidden}._cppay-copy-btn{color:#2563eb;cursor:pointer;background:0 0;border:none;justify-content:center;align-items:center;padding:.25rem;transition:color .2s;display:flex}._cppay-copy-btn:hover{color:#1d4ed8}._cppay-copy-btn svg{width:1.25rem;height:1.25rem}@keyframes _cppay-fadeIn{0%{opacity:0}to{opacity:1}}@keyframes _cppay-slideUp{0%{opacity:0;transform:translateY(1.25rem)}to{opacity:1;transform:translateY(0)}}._cppay-overlay{animation:.3s _cppay-fadeIn}._cppay-dialog{animation:.3s _cppay-slideUp}@media (max-width:640px){._cppay-dialog{margin:.5rem}._cppay-header,._cppay-content{padding:1rem}}";
+function injectStyle(e) {
+	if (typeof document > "u" || document.getElementById("_cppay-payment-dialog-style")) return;
+	let C = document.createElement("style");
+	C.id = "_cppay-payment-dialog-style", C.textContent = e, document.head.appendChild(C);
+}
+var require_can_promise = /* @__PURE__ */ __commonJSMin(((e, C) => {
+	C.exports = function() {
+		return typeof Promise == "function" && Promise.prototype && Promise.prototype.then;
+	};
+})), require_utils$1 = /* @__PURE__ */ __commonJSMin(((e) => {
+	var C, w = [
+		0,
+		26,
+		44,
+		70,
+		100,
+		134,
+		172,
+		196,
+		242,
+		292,
+		346,
+		404,
+		466,
+		532,
+		581,
+		655,
+		733,
+		815,
+		901,
+		991,
+		1085,
+		1156,
+		1258,
+		1364,
+		1474,
+		1588,
+		1706,
+		1828,
+		1921,
+		2051,
+		2185,
+		2323,
+		2465,
+		2611,
+		2761,
+		2876,
+		3034,
+		3196,
+		3362,
+		3532,
+		3706
+	];
+	e.getSymbolSize = function(e) {
+		if (!e) throw Error("\"version\" cannot be null or undefined");
+		if (e < 1 || e > 40) throw Error("\"version\" should be in range from 1 to 40");
+		return e * 4 + 17;
+	}, e.getSymbolTotalCodewords = function(e) {
+		return w[e];
+	}, e.getBCHDigit = function(e) {
+		let C = 0;
+		for (; e !== 0;) C++, e >>>= 1;
+		return C;
+	}, e.setToSJISFunction = function(e) {
+		if (typeof e != "function") throw Error("\"toSJISFunc\" is not a valid function.");
+		C = e;
+	}, e.isKanjiModeEnabled = function() {
+		return C !== void 0;
+	}, e.toSJIS = function(e) {
+		return C(e);
+	};
+})), require_error_correction_level = /* @__PURE__ */ __commonJSMin(((e) => {
+	e.L = { bit: 1 }, e.M = { bit: 0 }, e.Q = { bit: 3 }, e.H = { bit: 2 };
+	function C(C) {
+		if (typeof C != "string") throw Error("Param is not a string");
+		switch (C.toLowerCase()) {
+			case "l":
+			case "low": return e.L;
+			case "m":
+			case "medium": return e.M;
+			case "q":
+			case "quartile": return e.Q;
+			case "h":
+			case "high": return e.H;
+			default: throw Error("Unknown EC Level: " + C);
+		}
+	}
+	e.isValid = function(e) {
+		return e && e.bit !== void 0 && e.bit >= 0 && e.bit < 4;
+	}, e.from = function(w, T) {
+		if (e.isValid(w)) return w;
+		try {
+			return C(w);
+		} catch {
+			return T;
+		}
+	};
+})), require_bit_buffer = /* @__PURE__ */ __commonJSMin(((e, C) => {
+	function w() {
+		this.buffer = [], this.length = 0;
+	}
+	w.prototype = {
+		get: function(e) {
+			let C = Math.floor(e / 8);
+			return (this.buffer[C] >>> 7 - e % 8 & 1) == 1;
+		},
+		put: function(e, C) {
+			for (let w = 0; w < C; w++) this.putBit((e >>> C - w - 1 & 1) == 1);
+		},
+		getLengthInBits: function() {
+			return this.length;
+		},
+		putBit: function(e) {
+			let C = Math.floor(this.length / 8);
+			this.buffer.length <= C && this.buffer.push(0), e && (this.buffer[C] |= 128 >>> this.length % 8), this.length++;
+		}
+	}, C.exports = w;
+})), require_bit_matrix = /* @__PURE__ */ __commonJSMin(((e, C) => {
+	function w(e) {
+		if (!e || e < 1) throw Error("BitMatrix size must be defined and greater than 0");
+		this.size = e, this.data = new Uint8Array(e * e), this.reservedBit = new Uint8Array(e * e);
+	}
+	w.prototype.set = function(e, C, w, T) {
+		let E = e * this.size + C;
+		this.data[E] = w, T && (this.reservedBit[E] = !0);
+	}, w.prototype.get = function(e, C) {
+		return this.data[e * this.size + C];
+	}, w.prototype.xor = function(e, C, w) {
+		this.data[e * this.size + C] ^= w;
+	}, w.prototype.isReserved = function(e, C) {
+		return this.reservedBit[e * this.size + C];
+	}, C.exports = w;
+})), require_alignment_pattern = /* @__PURE__ */ __commonJSMin(((e) => {
+	var C = require_utils$1().getSymbolSize;
+	e.getRowColCoords = function(e) {
+		if (e === 1) return [];
+		let w = Math.floor(e / 7) + 2, T = C(e), E = T === 145 ? 26 : Math.ceil((T - 13) / (2 * w - 2)) * 2, D = [T - 7];
+		for (let e = 1; e < w - 1; e++) D[e] = D[e - 1] - E;
+		return D.push(6), D.reverse();
+	}, e.getPositions = function(C) {
+		let w = [], T = e.getRowColCoords(C), E = T.length;
+		for (let e = 0; e < E; e++) for (let C = 0; C < E; C++) e === 0 && C === 0 || e === 0 && C === E - 1 || e === E - 1 && C === 0 || w.push([T[e], T[C]]);
+		return w;
+	};
+})), require_finder_pattern = /* @__PURE__ */ __commonJSMin(((e) => {
+	var C = require_utils$1().getSymbolSize, w = 7;
+	e.getPositions = function(e) {
+		let T = C(e);
+		return [
+			[0, 0],
+			[T - w, 0],
+			[0, T - w]
+		];
+	};
+})), require_mask_pattern = /* @__PURE__ */ __commonJSMin(((e) => {
+	e.Patterns = {
+		PATTERN000: 0,
+		PATTERN001: 1,
+		PATTERN010: 2,
+		PATTERN011: 3,
+		PATTERN100: 4,
+		PATTERN101: 5,
+		PATTERN110: 6,
+		PATTERN111: 7
+	};
+	var C = {
+		N1: 3,
+		N2: 3,
+		N3: 40,
+		N4: 10
+	};
+	e.isValid = function(e) {
+		return e != null && e !== "" && !isNaN(e) && e >= 0 && e <= 7;
+	}, e.from = function(C) {
+		return e.isValid(C) ? parseInt(C, 10) : void 0;
+	}, e.getPenaltyN1 = function(e) {
+		let w = e.size, T = 0, E = 0, D = 0, O = null, k = null;
+		for (let A = 0; A < w; A++) {
+			E = D = 0, O = k = null;
+			for (let j = 0; j < w; j++) {
+				let w = e.get(A, j);
+				w === O ? E++ : (E >= 5 && (T += C.N1 + (E - 5)), O = w, E = 1), w = e.get(j, A), w === k ? D++ : (D >= 5 && (T += C.N1 + (D - 5)), k = w, D = 1);
+			}
+			E >= 5 && (T += C.N1 + (E - 5)), D >= 5 && (T += C.N1 + (D - 5));
+		}
+		return T;
+	}, e.getPenaltyN2 = function(e) {
+		let w = e.size, T = 0;
+		for (let C = 0; C < w - 1; C++) for (let E = 0; E < w - 1; E++) {
+			let w = e.get(C, E) + e.get(C, E + 1) + e.get(C + 1, E) + e.get(C + 1, E + 1);
+			(w === 4 || w === 0) && T++;
+		}
+		return T * C.N2;
+	}, e.getPenaltyN3 = function(e) {
+		let w = e.size, T = 0, E = 0, D = 0;
+		for (let C = 0; C < w; C++) {
+			E = D = 0;
+			for (let O = 0; O < w; O++) E = E << 1 & 2047 | e.get(C, O), O >= 10 && (E === 1488 || E === 93) && T++, D = D << 1 & 2047 | e.get(O, C), O >= 10 && (D === 1488 || D === 93) && T++;
+		}
+		return T * C.N3;
+	}, e.getPenaltyN4 = function(e) {
+		let w = 0, T = e.data.length;
+		for (let C = 0; C < T; C++) w += e.data[C];
+		return Math.abs(Math.ceil(w * 100 / T / 5) - 10) * C.N4;
+	};
+	function w(C, w, T) {
+		switch (C) {
+			case e.Patterns.PATTERN000: return (w + T) % 2 == 0;
+			case e.Patterns.PATTERN001: return w % 2 == 0;
+			case e.Patterns.PATTERN010: return T % 3 == 0;
+			case e.Patterns.PATTERN011: return (w + T) % 3 == 0;
+			case e.Patterns.PATTERN100: return (Math.floor(w / 2) + Math.floor(T / 3)) % 2 == 0;
+			case e.Patterns.PATTERN101: return w * T % 2 + w * T % 3 == 0;
+			case e.Patterns.PATTERN110: return (w * T % 2 + w * T % 3) % 2 == 0;
+			case e.Patterns.PATTERN111: return (w * T % 3 + (w + T) % 2) % 2 == 0;
+			default: throw Error("bad maskPattern:" + C);
+		}
+	}
+	e.applyMask = function(e, C) {
+		let T = C.size;
+		for (let E = 0; E < T; E++) for (let D = 0; D < T; D++) C.isReserved(D, E) || C.xor(D, E, w(e, D, E));
+	}, e.getBestMask = function(C, w) {
+		let T = Object.keys(e.Patterns).length, E = 0, D = Infinity;
+		for (let O = 0; O < T; O++) {
+			w(O), e.applyMask(O, C);
+			let T = e.getPenaltyN1(C) + e.getPenaltyN2(C) + e.getPenaltyN3(C) + e.getPenaltyN4(C);
+			e.applyMask(O, C), T < D && (D = T, E = O);
+		}
+		return E;
+	};
+})), require_error_correction_code = /* @__PURE__ */ __commonJSMin(((e) => {
+	var C = require_error_correction_level(), w = [
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		2,
+		2,
+		1,
+		2,
+		2,
+		4,
+		1,
+		2,
+		4,
+		4,
+		2,
+		4,
+		4,
+		4,
+		2,
+		4,
+		6,
+		5,
+		2,
+		4,
+		6,
+		6,
+		2,
+		5,
+		8,
+		8,
+		4,
+		5,
+		8,
+		8,
+		4,
+		5,
+		8,
+		11,
+		4,
+		8,
+		10,
+		11,
+		4,
+		9,
+		12,
+		16,
+		4,
+		9,
+		16,
+		16,
+		6,
+		10,
+		12,
+		18,
+		6,
+		10,
+		17,
+		16,
+		6,
+		11,
+		16,
+		19,
+		6,
+		13,
+		18,
+		21,
+		7,
+		14,
+		21,
+		25,
+		8,
+		16,
+		20,
+		25,
+		8,
+		17,
+		23,
+		25,
+		9,
+		17,
+		23,
+		34,
+		9,
+		18,
+		25,
+		30,
+		10,
+		20,
+		27,
+		32,
+		12,
+		21,
+		29,
+		35,
+		12,
+		23,
+		34,
+		37,
+		12,
+		25,
+		34,
+		40,
+		13,
+		26,
+		35,
+		42,
+		14,
+		28,
+		38,
+		45,
+		15,
+		29,
+		40,
+		48,
+		16,
+		31,
+		43,
+		51,
+		17,
+		33,
+		45,
+		54,
+		18,
+		35,
+		48,
+		57,
+		19,
+		37,
+		51,
+		60,
+		19,
+		38,
+		53,
+		63,
+		20,
+		40,
+		56,
+		66,
+		21,
+		43,
+		59,
+		70,
+		22,
+		45,
+		62,
+		74,
+		24,
+		47,
+		65,
+		77,
+		25,
+		49,
+		68,
+		81
+	], T = [
+		7,
+		10,
+		13,
+		17,
+		10,
+		16,
+		22,
+		28,
+		15,
+		26,
+		36,
+		44,
+		20,
+		36,
+		52,
+		64,
+		26,
+		48,
+		72,
+		88,
+		36,
+		64,
+		96,
+		112,
+		40,
+		72,
+		108,
+		130,
+		48,
+		88,
+		132,
+		156,
+		60,
+		110,
+		160,
+		192,
+		72,
+		130,
+		192,
+		224,
+		80,
+		150,
+		224,
+		264,
+		96,
+		176,
+		260,
+		308,
+		104,
+		198,
+		288,
+		352,
+		120,
+		216,
+		320,
+		384,
+		132,
+		240,
+		360,
+		432,
+		144,
+		280,
+		408,
+		480,
+		168,
+		308,
+		448,
+		532,
+		180,
+		338,
+		504,
+		588,
+		196,
+		364,
+		546,
+		650,
+		224,
+		416,
+		600,
+		700,
+		224,
+		442,
+		644,
+		750,
+		252,
+		476,
+		690,
+		816,
+		270,
+		504,
+		750,
+		900,
+		300,
+		560,
+		810,
+		960,
+		312,
+		588,
+		870,
+		1050,
+		336,
+		644,
+		952,
+		1110,
+		360,
+		700,
+		1020,
+		1200,
+		390,
+		728,
+		1050,
+		1260,
+		420,
+		784,
+		1140,
+		1350,
+		450,
+		812,
+		1200,
+		1440,
+		480,
+		868,
+		1290,
+		1530,
+		510,
+		924,
+		1350,
+		1620,
+		540,
+		980,
+		1440,
+		1710,
+		570,
+		1036,
+		1530,
+		1800,
+		570,
+		1064,
+		1590,
+		1890,
+		600,
+		1120,
+		1680,
+		1980,
+		630,
+		1204,
+		1770,
+		2100,
+		660,
+		1260,
+		1860,
+		2220,
+		720,
+		1316,
+		1950,
+		2310,
+		750,
+		1372,
+		2040,
+		2430
+	];
+	e.getBlocksCount = function(e, T) {
+		switch (T) {
+			case C.L: return w[(e - 1) * 4 + 0];
+			case C.M: return w[(e - 1) * 4 + 1];
+			case C.Q: return w[(e - 1) * 4 + 2];
+			case C.H: return w[(e - 1) * 4 + 3];
+			default: return;
+		}
+	}, e.getTotalCodewordsCount = function(e, w) {
+		switch (w) {
+			case C.L: return T[(e - 1) * 4 + 0];
+			case C.M: return T[(e - 1) * 4 + 1];
+			case C.Q: return T[(e - 1) * 4 + 2];
+			case C.H: return T[(e - 1) * 4 + 3];
+			default: return;
+		}
+	};
+})), require_galois_field = /* @__PURE__ */ __commonJSMin(((e) => {
+	var C = new Uint8Array(512), w = new Uint8Array(256);
+	(function() {
+		let e = 1;
+		for (let T = 0; T < 255; T++) C[T] = e, w[e] = T, e <<= 1, e & 256 && (e ^= 285);
+		for (let e = 255; e < 512; e++) C[e] = C[e - 255];
+	})(), e.log = function(e) {
+		if (e < 1) throw Error("log(" + e + ")");
+		return w[e];
+	}, e.exp = function(e) {
+		return C[e];
+	}, e.mul = function(e, T) {
+		return e === 0 || T === 0 ? 0 : C[w[e] + w[T]];
+	};
+})), require_polynomial = /* @__PURE__ */ __commonJSMin(((e) => {
+	var C = require_galois_field();
+	e.mul = function(e, w) {
+		let T = new Uint8Array(e.length + w.length - 1);
+		for (let E = 0; E < e.length; E++) for (let D = 0; D < w.length; D++) T[E + D] ^= C.mul(e[E], w[D]);
+		return T;
+	}, e.mod = function(e, w) {
+		let T = new Uint8Array(e);
+		for (; T.length - w.length >= 0;) {
+			let e = T[0];
+			for (let E = 0; E < w.length; E++) T[E] ^= C.mul(w[E], e);
+			let E = 0;
+			for (; E < T.length && T[E] === 0;) E++;
+			T = T.slice(E);
+		}
+		return T;
+	}, e.generateECPolynomial = function(w) {
+		let T = new Uint8Array([1]);
+		for (let E = 0; E < w; E++) T = e.mul(T, new Uint8Array([1, C.exp(E)]));
+		return T;
+	};
+})), require_reed_solomon_encoder = /* @__PURE__ */ __commonJSMin(((e, C) => {
+	var w = require_polynomial();
+	function T(e) {
+		this.genPoly = void 0, this.degree = e, this.degree && this.initialize(this.degree);
+	}
+	T.prototype.initialize = function(e) {
+		this.degree = e, this.genPoly = w.generateECPolynomial(this.degree);
+	}, T.prototype.encode = function(e) {
+		if (!this.genPoly) throw Error("Encoder not initialized");
+		let C = new Uint8Array(e.length + this.degree);
+		C.set(e);
+		let T = w.mod(C, this.genPoly), E = this.degree - T.length;
+		if (E > 0) {
+			let e = new Uint8Array(this.degree);
+			return e.set(T, E), e;
+		}
+		return T;
+	}, C.exports = T;
+})), require_version_check = /* @__PURE__ */ __commonJSMin(((e) => {
+	e.isValid = function(e) {
+		return !isNaN(e) && e >= 1 && e <= 40;
+	};
+})), require_regex = /* @__PURE__ */ __commonJSMin(((e) => {
+	var C = "[0-9]+", w = "[A-Z $%*+\\-./:]+", T = "(?:[u3000-u303F]|[u3040-u309F]|[u30A0-u30FF]|[uFF00-uFFEF]|[u4E00-u9FAF]|[u2605-u2606]|[u2190-u2195]|u203B|[u2010u2015u2018u2019u2025u2026u201Cu201Du2225u2260]|[u0391-u0451]|[u00A7u00A8u00B1u00B4u00D7u00F7])+";
+	T = T.replace(/u/g, "\\u");
+	var E = "(?:(?![A-Z0-9 $%*+\\-./:]|" + T + ")(?:.|[\r\n]))+";
+	e.KANJI = new RegExp(T, "g"), e.BYTE_KANJI = RegExp("[^A-Z0-9 $%*+\\-./:]+", "g"), e.BYTE = new RegExp(E, "g"), e.NUMERIC = new RegExp(C, "g"), e.ALPHANUMERIC = new RegExp(w, "g");
+	var D = /* @__PURE__ */ RegExp("^" + T + "$"), O = /* @__PURE__ */ RegExp("^" + C + "$"), k = /* @__PURE__ */ RegExp("^[A-Z0-9 $%*+\\-./:]+$");
+	e.testKanji = function(e) {
+		return D.test(e);
+	}, e.testNumeric = function(e) {
+		return O.test(e);
+	}, e.testAlphanumeric = function(e) {
+		return k.test(e);
+	};
+})), require_mode = /* @__PURE__ */ __commonJSMin(((e) => {
+	var C = require_version_check(), w = require_regex();
+	e.NUMERIC = {
+		id: "Numeric",
+		bit: 1,
+		ccBits: [
+			10,
+			12,
+			14
+		]
+	}, e.ALPHANUMERIC = {
+		id: "Alphanumeric",
+		bit: 2,
+		ccBits: [
+			9,
+			11,
+			13
+		]
+	}, e.BYTE = {
+		id: "Byte",
+		bit: 4,
+		ccBits: [
+			8,
+			16,
+			16
+		]
+	}, e.KANJI = {
+		id: "Kanji",
+		bit: 8,
+		ccBits: [
+			8,
+			10,
+			12
+		]
+	}, e.MIXED = { bit: -1 }, e.getCharCountIndicator = function(e, w) {
+		if (!e.ccBits) throw Error("Invalid mode: " + e);
+		if (!C.isValid(w)) throw Error("Invalid version: " + w);
+		return w >= 1 && w < 10 ? e.ccBits[0] : w < 27 ? e.ccBits[1] : e.ccBits[2];
+	}, e.getBestModeForData = function(C) {
+		return w.testNumeric(C) ? e.NUMERIC : w.testAlphanumeric(C) ? e.ALPHANUMERIC : w.testKanji(C) ? e.KANJI : e.BYTE;
+	}, e.toString = function(e) {
+		if (e && e.id) return e.id;
+		throw Error("Invalid mode");
+	}, e.isValid = function(e) {
+		return e && e.bit && e.ccBits;
+	};
+	function T(C) {
+		if (typeof C != "string") throw Error("Param is not a string");
+		switch (C.toLowerCase()) {
+			case "numeric": return e.NUMERIC;
+			case "alphanumeric": return e.ALPHANUMERIC;
+			case "kanji": return e.KANJI;
+			case "byte": return e.BYTE;
+			default: throw Error("Unknown mode: " + C);
+		}
+	}
+	e.from = function(C, w) {
+		if (e.isValid(C)) return C;
+		try {
+			return T(C);
+		} catch {
+			return w;
+		}
+	};
+})), require_version = /* @__PURE__ */ __commonJSMin(((e) => {
+	var C = require_utils$1(), w = require_error_correction_code(), T = require_error_correction_level(), E = require_mode(), D = require_version_check(), O = 7973, k = C.getBCHDigit(O);
+	function A(C, w, T) {
+		for (let E = 1; E <= 40; E++) if (w <= e.getCapacity(E, T, C)) return E;
+	}
+	function j(e, C) {
+		return E.getCharCountIndicator(e, C) + 4;
+	}
+	function M(e, C) {
+		let w = 0;
+		return e.forEach(function(e) {
+			let T = j(e.mode, C);
+			w += T + e.getBitsLength();
+		}), w;
+	}
+	function N(C, w) {
+		for (let T = 1; T <= 40; T++) if (M(C, T) <= e.getCapacity(T, w, E.MIXED)) return T;
+	}
+	e.from = function(e, C) {
+		return D.isValid(e) ? parseInt(e, 10) : C;
+	}, e.getCapacity = function(e, T, O) {
+		if (!D.isValid(e)) throw Error("Invalid QR Code version");
+		O === void 0 && (O = E.BYTE);
+		let k = (C.getSymbolTotalCodewords(e) - w.getTotalCodewordsCount(e, T)) * 8;
+		if (O === E.MIXED) return k;
+		let A = k - j(O, e);
+		switch (O) {
+			case E.NUMERIC: return Math.floor(A / 10 * 3);
+			case E.ALPHANUMERIC: return Math.floor(A / 11 * 2);
+			case E.KANJI: return Math.floor(A / 13);
+			case E.BYTE:
+			default: return Math.floor(A / 8);
+		}
+	}, e.getBestVersionForData = function(e, C) {
+		let w, E = T.from(C, T.M);
+		if (Array.isArray(e)) {
+			if (e.length > 1) return N(e, E);
+			if (e.length === 0) return 1;
+			w = e[0];
+		} else w = e;
+		return A(w.mode, w.getLength(), E);
+	}, e.getEncodedBits = function(e) {
+		if (!D.isValid(e) || e < 7) throw Error("Invalid QR Code version");
+		let w = e << 12;
+		for (; C.getBCHDigit(w) - k >= 0;) w ^= O << C.getBCHDigit(w) - k;
+		return e << 12 | w;
+	};
+})), require_format_info = /* @__PURE__ */ __commonJSMin(((e) => {
+	var C = require_utils$1(), w = 1335, T = 21522, E = C.getBCHDigit(w);
+	e.getEncodedBits = function(e, D) {
+		let O = e.bit << 3 | D, k = O << 10;
+		for (; C.getBCHDigit(k) - E >= 0;) k ^= w << C.getBCHDigit(k) - E;
+		return (O << 10 | k) ^ T;
+	};
+})), require_numeric_data = /* @__PURE__ */ __commonJSMin(((e, C) => {
+	var w = require_mode();
+	function T(e) {
+		this.mode = w.NUMERIC, this.data = e.toString();
+	}
+	T.getBitsLength = function(e) {
+		return 10 * Math.floor(e / 3) + (e % 3 ? e % 3 * 3 + 1 : 0);
+	}, T.prototype.getLength = function() {
+		return this.data.length;
+	}, T.prototype.getBitsLength = function() {
+		return T.getBitsLength(this.data.length);
+	}, T.prototype.write = function(e) {
+		let C, w, T;
+		for (C = 0; C + 3 <= this.data.length; C += 3) w = this.data.substr(C, 3), T = parseInt(w, 10), e.put(T, 10);
+		let E = this.data.length - C;
+		E > 0 && (w = this.data.substr(C), T = parseInt(w, 10), e.put(T, E * 3 + 1));
+	}, C.exports = T;
+})), require_alphanumeric_data = /* @__PURE__ */ __commonJSMin(((e, C) => {
+	var w = require_mode(), T = /* @__PURE__ */ "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:".split("");
+	function E(e) {
+		this.mode = w.ALPHANUMERIC, this.data = e;
+	}
+	E.getBitsLength = function(e) {
+		return 11 * Math.floor(e / 2) + 6 * (e % 2);
+	}, E.prototype.getLength = function() {
+		return this.data.length;
+	}, E.prototype.getBitsLength = function() {
+		return E.getBitsLength(this.data.length);
+	}, E.prototype.write = function(e) {
+		let C;
+		for (C = 0; C + 2 <= this.data.length; C += 2) {
+			let w = T.indexOf(this.data[C]) * 45;
+			w += T.indexOf(this.data[C + 1]), e.put(w, 11);
+		}
+		this.data.length % 2 && e.put(T.indexOf(this.data[C]), 6);
+	}, C.exports = E;
+})), require_byte_data = /* @__PURE__ */ __commonJSMin(((e, C) => {
+	var w = require_mode();
+	function T(e) {
+		this.mode = w.BYTE, typeof e == "string" ? this.data = new TextEncoder().encode(e) : this.data = new Uint8Array(e);
+	}
+	T.getBitsLength = function(e) {
+		return e * 8;
+	}, T.prototype.getLength = function() {
+		return this.data.length;
+	}, T.prototype.getBitsLength = function() {
+		return T.getBitsLength(this.data.length);
+	}, T.prototype.write = function(e) {
+		for (let C = 0, w = this.data.length; C < w; C++) e.put(this.data[C], 8);
+	}, C.exports = T;
+})), require_kanji_data = /* @__PURE__ */ __commonJSMin(((e, C) => {
+	var w = require_mode(), T = require_utils$1();
+	function E(e) {
+		this.mode = w.KANJI, this.data = e;
+	}
+	E.getBitsLength = function(e) {
+		return e * 13;
+	}, E.prototype.getLength = function() {
+		return this.data.length;
+	}, E.prototype.getBitsLength = function() {
+		return E.getBitsLength(this.data.length);
+	}, E.prototype.write = function(e) {
+		let C;
+		for (C = 0; C < this.data.length; C++) {
+			let w = T.toSJIS(this.data[C]);
+			if (w >= 33088 && w <= 40956) w -= 33088;
+			else if (w >= 57408 && w <= 60351) w -= 49472;
+			else throw Error("Invalid SJIS character: " + this.data[C] + "\nMake sure your charset is UTF-8");
+			w = (w >>> 8 & 255) * 192 + (w & 255), e.put(w, 13);
+		}
+	}, C.exports = E;
+})), require_dijkstra = /* @__PURE__ */ __commonJSMin(((e, C) => {
+	var w = {
+		single_source_shortest_paths: function(e, C, T) {
+			var E = {}, D = {};
+			D[C] = 0;
+			var O = w.PriorityQueue.make();
+			O.push(C, 0);
+			for (var k, A, j, M, N, P, F, I, L; !O.empty();) for (j in k = O.pop(), A = k.value, M = k.cost, N = e[A] || {}, N) N.hasOwnProperty(j) && (P = N[j], F = M + P, I = D[j], L = D[j] === void 0, (L || I > F) && (D[j] = F, O.push(j, F), E[j] = A));
+			if (T !== void 0 && D[T] === void 0) {
+				var R = [
+					"Could not find a path from ",
+					C,
+					" to ",
+					T,
+					"."
+				].join("");
+				throw Error(R);
+			}
+			return E;
+		},
+		extract_shortest_path_from_predecessor_list: function(e, C) {
+			for (var w = [], T = C; T;) w.push(T), e[T], T = e[T];
+			return w.reverse(), w;
+		},
+		find_path: function(e, C, T) {
+			var E = w.single_source_shortest_paths(e, C, T);
+			return w.extract_shortest_path_from_predecessor_list(E, T);
+		},
+		PriorityQueue: {
+			make: function(e) {
+				var C = w.PriorityQueue, T = {}, E;
+				for (E in e ||= {}, C) C.hasOwnProperty(E) && (T[E] = C[E]);
+				return T.queue = [], T.sorter = e.sorter || C.default_sorter, T;
+			},
+			default_sorter: function(e, C) {
+				return e.cost - C.cost;
+			},
+			push: function(e, C) {
+				var w = {
+					value: e,
+					cost: C
+				};
+				this.queue.push(w), this.queue.sort(this.sorter);
+			},
+			pop: function() {
+				return this.queue.shift();
+			},
+			empty: function() {
+				return this.queue.length === 0;
+			}
+		}
+	};
+	C !== void 0 && (C.exports = w);
+})), require_segments = /* @__PURE__ */ __commonJSMin(((e) => {
+	var C = require_mode(), w = require_numeric_data(), T = require_alphanumeric_data(), E = require_byte_data(), D = require_kanji_data(), O = require_regex(), k = require_utils$1(), A = require_dijkstra();
+	function j(e) {
+		return unescape(encodeURIComponent(e)).length;
+	}
+	function M(e, C, w) {
+		let T = [], E;
+		for (; (E = e.exec(w)) !== null;) T.push({
+			data: E[0],
+			index: E.index,
+			mode: C,
+			length: E[0].length
+		});
+		return T;
+	}
+	function N(e) {
+		let w = M(O.NUMERIC, C.NUMERIC, e), T = M(O.ALPHANUMERIC, C.ALPHANUMERIC, e), E, D;
+		return k.isKanjiModeEnabled() ? (E = M(O.BYTE, C.BYTE, e), D = M(O.KANJI, C.KANJI, e)) : (E = M(O.BYTE_KANJI, C.BYTE, e), D = []), w.concat(T, E, D).sort(function(e, C) {
+			return e.index - C.index;
+		}).map(function(e) {
+			return {
+				data: e.data,
+				mode: e.mode,
+				length: e.length
+			};
+		});
+	}
+	function P(e, O) {
+		switch (O) {
+			case C.NUMERIC: return w.getBitsLength(e);
+			case C.ALPHANUMERIC: return T.getBitsLength(e);
+			case C.KANJI: return D.getBitsLength(e);
+			case C.BYTE: return E.getBitsLength(e);
+		}
+	}
+	function I(e) {
+		return e.reduce(function(e, C) {
+			let w = e.length - 1 >= 0 ? e[e.length - 1] : null;
+			return w && w.mode === C.mode ? (e[e.length - 1].data += C.data, e) : (e.push(C), e);
+		}, []);
+	}
+	function L(e) {
+		let w = [];
+		for (let T = 0; T < e.length; T++) {
+			let E = e[T];
+			switch (E.mode) {
+				case C.NUMERIC:
+					w.push([
+						E,
+						{
+							data: E.data,
+							mode: C.ALPHANUMERIC,
+							length: E.length
+						},
+						{
+							data: E.data,
+							mode: C.BYTE,
+							length: E.length
+						}
+					]);
+					break;
+				case C.ALPHANUMERIC:
+					w.push([E, {
+						data: E.data,
+						mode: C.BYTE,
+						length: E.length
+					}]);
+					break;
+				case C.KANJI:
+					w.push([E, {
+						data: E.data,
+						mode: C.BYTE,
+						length: j(E.data)
+					}]);
+					break;
+				case C.BYTE: w.push([{
+					data: E.data,
+					mode: C.BYTE,
+					length: j(E.data)
+				}]);
+			}
+		}
+		return w;
+	}
+	function R(e, w) {
+		let T = {}, E = { start: {} }, D = ["start"];
+		for (let O = 0; O < e.length; O++) {
+			let k = e[O], A = [];
+			for (let e = 0; e < k.length; e++) {
+				let j = k[e], M = "" + O + e;
+				A.push(M), T[M] = {
+					node: j,
+					lastCount: 0
+				}, E[M] = {};
+				for (let e = 0; e < D.length; e++) {
+					let O = D[e];
+					T[O] && T[O].node.mode === j.mode ? (E[O][M] = P(T[O].lastCount + j.length, j.mode) - P(T[O].lastCount, j.mode), T[O].lastCount += j.length) : (T[O] && (T[O].lastCount = j.length), E[O][M] = P(j.length, j.mode) + 4 + C.getCharCountIndicator(j.mode, w));
+				}
+			}
+			D = A;
+		}
+		for (let e = 0; e < D.length; e++) E[D[e]].end = 0;
+		return {
+			map: E,
+			table: T
+		};
+	}
+	function z(e, O) {
+		let A, j = C.getBestModeForData(e);
+		if (A = C.from(O, j), A !== C.BYTE && A.bit < j.bit) throw Error("\"" + e + "\" cannot be encoded with mode " + C.toString(A) + ".\n Suggested mode is: " + C.toString(j));
+		switch (A === C.KANJI && !k.isKanjiModeEnabled() && (A = C.BYTE), A) {
+			case C.NUMERIC: return new w(e);
+			case C.ALPHANUMERIC: return new T(e);
+			case C.KANJI: return new D(e);
+			case C.BYTE: return new E(e);
+		}
+	}
+	e.fromArray = function(e) {
+		return e.reduce(function(e, C) {
+			return typeof C == "string" ? e.push(z(C, null)) : C.data && e.push(z(C.data, C.mode)), e;
+		}, []);
+	}, e.fromString = function(C, w) {
+		let T = R(L(N(C, k.isKanjiModeEnabled())), w), E = A.find_path(T.map, "start", "end"), D = [];
+		for (let e = 1; e < E.length - 1; e++) D.push(T.table[E[e]].node);
+		return e.fromArray(I(D));
+	}, e.rawSplit = function(C) {
+		return e.fromArray(N(C, k.isKanjiModeEnabled()));
+	};
+})), require_qrcode = /* @__PURE__ */ __commonJSMin(((e) => {
+	var C = require_utils$1(), w = require_error_correction_level(), T = require_bit_buffer(), E = require_bit_matrix(), D = require_alignment_pattern(), O = require_finder_pattern(), k = require_mask_pattern(), A = require_error_correction_code(), j = require_reed_solomon_encoder(), M = require_version(), N = require_format_info(), P = require_mode(), U = require_segments();
+	function W(e, C) {
+		let w = e.size, T = O.getPositions(C);
+		for (let C = 0; C < T.length; C++) {
+			let E = T[C][0], D = T[C][1];
+			for (let C = -1; C <= 7; C++) if (!(E + C <= -1 || w <= E + C)) for (let T = -1; T <= 7; T++) D + T <= -1 || w <= D + T || (C >= 0 && C <= 6 && (T === 0 || T === 6) || T >= 0 && T <= 6 && (C === 0 || C === 6) || C >= 2 && C <= 4 && T >= 2 && T <= 4 ? e.set(E + C, D + T, !0, !0) : e.set(E + C, D + T, !1, !0));
+		}
+	}
+	function K(e) {
+		let C = e.size;
+		for (let w = 8; w < C - 8; w++) {
+			let C = w % 2 == 0;
+			e.set(w, 6, C, !0), e.set(6, w, C, !0);
+		}
+	}
+	function q(e, C) {
+		let w = D.getPositions(C);
+		for (let C = 0; C < w.length; C++) {
+			let T = w[C][0], E = w[C][1];
+			for (let C = -2; C <= 2; C++) for (let w = -2; w <= 2; w++) C === -2 || C === 2 || w === -2 || w === 2 || C === 0 && w === 0 ? e.set(T + C, E + w, !0, !0) : e.set(T + C, E + w, !1, !0);
+		}
+	}
+	function J(e, C) {
+		let w = e.size, T = M.getEncodedBits(C), E, D, O;
+		for (let C = 0; C < 18; C++) E = Math.floor(C / 3), D = C % 3 + w - 8 - 3, O = (T >> C & 1) == 1, e.set(E, D, O, !0), e.set(D, E, O, !0);
+	}
+	function Y(e, C, w) {
+		let T = e.size, E = N.getEncodedBits(C, w), D, O;
+		for (D = 0; D < 15; D++) O = (E >> D & 1) == 1, D < 6 ? e.set(D, 8, O, !0) : D < 8 ? e.set(D + 1, 8, O, !0) : e.set(T - 15 + D, 8, O, !0), D < 8 ? e.set(8, T - D - 1, O, !0) : D < 9 ? e.set(8, 15 - D - 1 + 1, O, !0) : e.set(8, 15 - D - 1, O, !0);
+		e.set(T - 8, 8, 1, !0);
+	}
+	function X(e, C) {
+		let w = e.size, T = -1, E = w - 1, D = 7, O = 0;
+		for (let k = w - 1; k > 0; k -= 2) for (k === 6 && k--;;) {
+			for (let w = 0; w < 2; w++) if (!e.isReserved(E, k - w)) {
+				let T = !1;
+				O < C.length && (T = (C[O] >>> D & 1) == 1), e.set(E, k - w, T), D--, D === -1 && (O++, D = 7);
+			}
+			if (E += T, E < 0 || w <= E) {
+				E -= T, T = -T;
+				break;
+			}
+		}
+	}
+	function Z(e, w, E) {
+		let D = new T();
+		E.forEach(function(C) {
+			D.put(C.mode.bit, 4), D.put(C.getLength(), P.getCharCountIndicator(C.mode, e)), C.write(D);
+		});
+		let O = (C.getSymbolTotalCodewords(e) - A.getTotalCodewordsCount(e, w)) * 8;
+		for (D.getLengthInBits() + 4 <= O && D.put(0, 4); D.getLengthInBits() % 8 != 0;) D.putBit(0);
+		let k = (O - D.getLengthInBits()) / 8;
+		for (let e = 0; e < k; e++) D.put(e % 2 ? 17 : 236, 8);
+		return Q(D, e, w);
+	}
+	function Q(e, w, T) {
+		let E = C.getSymbolTotalCodewords(w), D = E - A.getTotalCodewordsCount(w, T), O = A.getBlocksCount(w, T), k = O - E % O, M = Math.floor(E / O), N = Math.floor(D / O), P = N + 1, F = M - N, I = new j(F), L = 0, R = Array(O), z = Array(O), B = 0, V = new Uint8Array(e.buffer);
+		for (let e = 0; e < O; e++) {
+			let C = e < k ? N : P;
+			R[e] = V.slice(L, L + C), z[e] = I.encode(R[e]), L += C, B = Math.max(B, C);
+		}
+		let H = new Uint8Array(E), U = 0, W, G;
+		for (W = 0; W < B; W++) for (G = 0; G < O; G++) W < R[G].length && (H[U++] = R[G][W]);
+		for (W = 0; W < F; W++) for (G = 0; G < O; G++) H[U++] = z[G][W];
+		return H;
+	}
+	function $(e, w, T, D) {
+		let O;
+		if (Array.isArray(e)) O = U.fromArray(e);
+		else if (typeof e == "string") {
+			let C = w;
+			if (!C) {
+				let w = U.rawSplit(e);
+				C = M.getBestVersionForData(w, T);
+			}
+			O = U.fromString(e, C || 40);
+		} else throw Error("Invalid data");
+		let A = M.getBestVersionForData(O, T);
+		if (!A) throw Error("The amount of data is too big to be stored in a QR Code");
+		if (!w) w = A;
+		else if (w < A) throw Error("\nThe chosen QR Code version cannot contain this amount of data.\nMinimum version required to store current data is: " + A + ".\n");
+		let j = Z(w, T, O), N = new E(C.getSymbolSize(w));
+		return W(N, w), K(N), q(N, w), Y(N, T, 0), w >= 7 && J(N, w), X(N, j), isNaN(D) && (D = k.getBestMask(N, Y.bind(null, N, T))), k.applyMask(D, N), Y(N, T, D), {
+			modules: N,
+			version: w,
+			errorCorrectionLevel: T,
+			maskPattern: D,
+			segments: O
+		};
+	}
+	e.create = function(e, T) {
+		if (e === void 0 || e === "") throw Error("No input text");
+		let E = w.M, D, O;
+		return T !== void 0 && (E = w.from(T.errorCorrectionLevel, w.M), D = M.from(T.version), O = k.from(T.maskPattern), T.toSJISFunc && C.setToSJISFunction(T.toSJISFunc)), $(e, D, E, O);
+	};
+})), require_utils = /* @__PURE__ */ __commonJSMin(((e) => {
+	function C(e) {
+		if (typeof e == "number" && (e = e.toString()), typeof e != "string") throw Error("Color should be defined as hex string");
+		let C = e.slice().replace("#", "").split("");
+		if (C.length < 3 || C.length === 5 || C.length > 8) throw Error("Invalid hex color: " + e);
+		(C.length === 3 || C.length === 4) && (C = Array.prototype.concat.apply([], C.map(function(e) {
+			return [e, e];
+		}))), C.length === 6 && C.push("F", "F");
+		let w = parseInt(C.join(""), 16);
+		return {
+			r: w >> 24 & 255,
+			g: w >> 16 & 255,
+			b: w >> 8 & 255,
+			a: w & 255,
+			hex: "#" + C.slice(0, 6).join("")
+		};
+	}
+	e.getOptions = function(e) {
+		e ||= {}, e.color ||= {};
+		let w = e.margin === void 0 || e.margin === null || e.margin < 0 ? 4 : e.margin, T = e.width && e.width >= 21 ? e.width : void 0, E = e.scale || 4;
+		return {
+			width: T,
+			scale: T ? 4 : E,
+			margin: w,
+			color: {
+				dark: C(e.color.dark || "#000000ff"),
+				light: C(e.color.light || "#ffffffff")
+			},
+			type: e.type,
+			rendererOpts: e.rendererOpts || {}
+		};
+	}, e.getScale = function(e, C) {
+		return C.width && C.width >= e + C.margin * 2 ? C.width / (e + C.margin * 2) : C.scale;
+	}, e.getImageWidth = function(C, w) {
+		let T = e.getScale(C, w);
+		return Math.floor((C + w.margin * 2) * T);
+	}, e.qrToImageData = function(C, w, T) {
+		let E = w.modules.size, D = w.modules.data, O = e.getScale(E, T), k = Math.floor((E + T.margin * 2) * O), A = T.margin * O, j = [T.color.light, T.color.dark];
+		for (let e = 0; e < k; e++) for (let w = 0; w < k; w++) {
+			let M = (e * k + w) * 4, N = T.color.light;
+			if (e >= A && w >= A && e < k - A && w < k - A) {
+				let C = Math.floor((e - A) / O), T = Math.floor((w - A) / O);
+				N = j[D[C * E + T] ? 1 : 0];
+			}
+			C[M++] = N.r, C[M++] = N.g, C[M++] = N.b, C[M] = N.a;
+		}
+	};
+})), require_canvas = /* @__PURE__ */ __commonJSMin(((e) => {
+	var C = require_utils();
+	function w(e, C, w) {
+		e.clearRect(0, 0, C.width, C.height), C.style ||= {}, C.height = w, C.width = w, C.style.height = w + "px", C.style.width = w + "px";
+	}
+	function T() {
+		try {
+			return document.createElement("canvas");
+		} catch {
+			throw Error("You need to specify a canvas element");
+		}
+	}
+	e.render = function(e, E, D) {
+		let O = D, k = E;
+		O === void 0 && (!E || !E.getContext) && (O = E, E = void 0), E || (k = T()), O = C.getOptions(O);
+		let A = C.getImageWidth(e.modules.size, O), j = k.getContext("2d"), M = j.createImageData(A, A);
+		return C.qrToImageData(M.data, e, O), w(j, k, A), j.putImageData(M, 0, 0), k;
+	}, e.renderToDataURL = function(C, w, T) {
+		let E = T;
+		E === void 0 && (!w || !w.getContext) && (E = w, w = void 0), E ||= {};
+		let D = e.render(C, w, E), O = E.type || "image/png", k = E.rendererOpts || {};
+		return D.toDataURL(O, k.quality);
+	};
+})), require_svg_tag = /* @__PURE__ */ __commonJSMin(((e) => {
+	var C = require_utils();
+	function w(e, C) {
+		let w = e.a / 255, T = C + "=\"" + e.hex + "\"";
+		return w < 1 ? T + " " + C + "-opacity=\"" + w.toFixed(2).slice(1) + "\"" : T;
+	}
+	function T(e, C, w) {
+		let T = e + C;
+		return w !== void 0 && (T += " " + w), T;
+	}
+	function E(e, C, w) {
+		let E = "", D = 0, O = !1, k = 0;
+		for (let A = 0; A < e.length; A++) {
+			let j = Math.floor(A % C), M = Math.floor(A / C);
+			!j && !O && (O = !0), e[A] ? (k++, A > 0 && j > 0 && e[A - 1] || (E += O ? T("M", j + w, .5 + M + w) : T("m", D, 0), D = 0, O = !1), j + 1 < C && e[A + 1] || (E += T("h", k), k = 0)) : D++;
+		}
+		return E;
+	}
+	e.render = function(e, T, D) {
+		let O = C.getOptions(T), k = e.modules.size, A = e.modules.data, j = k + O.margin * 2, M = O.color.light.a ? "<path " + w(O.color.light, "fill") + " d=\"M0 0h" + j + "v" + j + "H0z\"/>" : "", N = "<path " + w(O.color.dark, "stroke") + " d=\"" + E(A, k, O.margin) + "\"/>", P = "viewBox=\"0 0 " + j + " " + j + "\"", F = "<svg xmlns=\"http://www.w3.org/2000/svg\" " + (O.width ? "width=\"" + O.width + "\" height=\"" + O.width + "\" " : "") + P + " shape-rendering=\"crispEdges\">" + M + N + "</svg>\n";
+		return typeof D == "function" && D(null, F), F;
+	};
+})), require_browser = /* @__PURE__ */ __commonJSMin(((e) => {
+	var C = require_can_promise(), w = require_qrcode(), T = require_canvas(), E = require_svg_tag();
+	function D(e, T, E, D, O) {
+		let k = [].slice.call(arguments, 1), A = k.length, j = typeof k[A - 1] == "function";
+		if (!j && !C()) throw Error("Callback required as last argument");
+		if (j) {
+			if (A < 2) throw Error("Too few arguments provided");
+			A === 2 ? (O = E, E = T, T = D = void 0) : A === 3 && (T.getContext && O === void 0 ? (O = D, D = void 0) : (O = D, D = E, E = T, T = void 0));
+		} else {
+			if (A < 1) throw Error("Too few arguments provided");
+			return A === 1 ? (E = T, T = D = void 0) : A === 2 && !T.getContext && (D = E, E = T, T = void 0), new Promise(function(C, O) {
+				try {
+					C(e(w.create(E, D), T, D));
+				} catch (e) {
+					O(e);
+				}
+			});
+		}
+		try {
+			let C = w.create(E, D);
+			O(null, e(C, T, D));
+		} catch (e) {
+			O(e);
+		}
+	}
+	e.create = w.create, e.toCanvas = D.bind(null, T.render), e.toDataURL = D.bind(null, T.renderToDataURL), e.toString = D.bind(null, function(e, C, w) {
+		return E.render(e, w);
+	});
+}));
+function isFunction(e) {
+	return typeof e == "function";
+}
+function hasLift(e) {
+	return isFunction(e?.lift);
+}
+function operate(e) {
+	return function(C) {
+		if (hasLift(C)) return C.lift(function(C) {
+			try {
+				return e(C, this);
+			} catch (e) {
+				this.error(e);
+			}
+		});
+		throw TypeError("Unable to lift unknown Observable type");
+	};
+}
+var extendStatics = function(e, C) {
+	return extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(e, C) {
+		e.__proto__ = C;
+	} || function(e, C) {
+		for (var w in C) Object.prototype.hasOwnProperty.call(C, w) && (e[w] = C[w]);
+	}, extendStatics(e, C);
+};
+function __extends(e, C) {
+	if (typeof C != "function" && C !== null) throw TypeError("Class extends value " + String(C) + " is not a constructor or null");
+	extendStatics(e, C);
+	function w() {
+		this.constructor = e;
+	}
+	e.prototype = C === null ? Object.create(C) : (w.prototype = C.prototype, new w());
+}
+function __awaiter(e, C, w, T) {
+	function E(e) {
+		return e instanceof w ? e : new w(function(C) {
+			C(e);
+		});
+	}
+	return new (w ||= Promise)(function(w, D) {
+		function O(e) {
+			try {
+				A(T.next(e));
+			} catch (e) {
+				D(e);
+			}
+		}
+		function k(e) {
+			try {
+				A(T.throw(e));
+			} catch (e) {
+				D(e);
+			}
+		}
+		function A(e) {
+			e.done ? w(e.value) : E(e.value).then(O, k);
+		}
+		A((T = T.apply(e, C || [])).next());
+	});
+}
+function __generator(e, C) {
+	var w = {
+		label: 0,
+		sent: function() {
+			if (D[0] & 1) throw D[1];
+			return D[1];
+		},
+		trys: [],
+		ops: []
+	}, T, E, D, O = Object.create((typeof Iterator == "function" ? Iterator : Object).prototype);
+	return O.next = k(0), O.throw = k(1), O.return = k(2), typeof Symbol == "function" && (O[Symbol.iterator] = function() {
+		return this;
+	}), O;
+	function k(e) {
+		return function(C) {
+			return A([e, C]);
+		};
+	}
+	function A(k) {
+		if (T) throw TypeError("Generator is already executing.");
+		for (; O && (O = 0, k[0] && (w = 0)), w;) try {
+			if (T = 1, E && (D = k[0] & 2 ? E.return : k[0] ? E.throw || ((D = E.return) && D.call(E), 0) : E.next) && !(D = D.call(E, k[1])).done) return D;
+			switch (E = 0, D && (k = [k[0] & 2, D.value]), k[0]) {
+				case 0:
+				case 1:
+					D = k;
+					break;
+				case 4: return w.label++, {
+					value: k[1],
+					done: !1
+				};
+				case 5:
+					w.label++, E = k[1], k = [0];
+					continue;
+				case 7:
+					k = w.ops.pop(), w.trys.pop();
+					continue;
+				default:
+					if ((D = w.trys, !(D = D.length > 0 && D[D.length - 1])) && (k[0] === 6 || k[0] === 2)) {
+						w = 0;
+						continue;
+					}
+					if (k[0] === 3 && (!D || k[1] > D[0] && k[1] < D[3])) {
+						w.label = k[1];
+						break;
+					}
+					if (k[0] === 6 && w.label < D[1]) {
+						w.label = D[1], D = k;
+						break;
+					}
+					if (D && w.label < D[2]) {
+						w.label = D[2], w.ops.push(k);
+						break;
+					}
+					D[2] && w.ops.pop(), w.trys.pop();
+					continue;
+			}
+			k = C.call(e, w);
+		} catch (e) {
+			k = [6, e], E = 0;
+		} finally {
+			T = D = 0;
+		}
+		if (k[0] & 5) throw k[1];
+		return {
+			value: k[0] ? k[1] : void 0,
+			done: !0
+		};
+	}
+}
+function __values(e) {
+	var C = typeof Symbol == "function" && Symbol.iterator, w = C && e[C], T = 0;
+	if (w) return w.call(e);
+	if (e && typeof e.length == "number") return { next: function() {
+		return e && T >= e.length && (e = void 0), {
+			value: e && e[T++],
+			done: !e
+		};
+	} };
+	throw TypeError(C ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __read(e, C) {
+	var w = typeof Symbol == "function" && e[Symbol.iterator];
+	if (!w) return e;
+	var T = w.call(e), E, D = [], O;
+	try {
+		for (; (C === void 0 || C-- > 0) && !(E = T.next()).done;) D.push(E.value);
+	} catch (e) {
+		O = { error: e };
+	} finally {
+		try {
+			E && !E.done && (w = T.return) && w.call(T);
+		} finally {
+			if (O) throw O.error;
+		}
+	}
+	return D;
+}
+function __spreadArray(e, C, w) {
+	if (w || arguments.length === 2) for (var T = 0, E = C.length, D; T < E; T++) (D || !(T in C)) && (D ||= Array.prototype.slice.call(C, 0, T), D[T] = C[T]);
+	return e.concat(D || Array.prototype.slice.call(C));
+}
+function __await(e) {
+	return this instanceof __await ? (this.v = e, this) : new __await(e);
+}
+function __asyncGenerator(e, C, w) {
+	if (!Symbol.asyncIterator) throw TypeError("Symbol.asyncIterator is not defined.");
+	var T = w.apply(e, C || []), E, D = [];
+	return E = Object.create((typeof AsyncIterator == "function" ? AsyncIterator : Object).prototype), k("next"), k("throw"), k("return", O), E[Symbol.asyncIterator] = function() {
+		return this;
+	}, E;
+	function O(e) {
+		return function(C) {
+			return Promise.resolve(C).then(e, N);
+		};
+	}
+	function k(e, C) {
+		T[e] && (E[e] = function(C) {
+			return new Promise(function(w, T) {
+				D.push([
+					e,
+					C,
+					w,
+					T
+				]) > 1 || A(e, C);
+			});
+		}, C && (E[e] = C(E[e])));
+	}
+	function A(e, C) {
+		try {
+			j(T[e](C));
+		} catch (e) {
+			P(D[0][3], e);
+		}
+	}
+	function j(e) {
+		e.value instanceof __await ? Promise.resolve(e.value.v).then(M, N) : P(D[0][2], e);
+	}
+	function M(e) {
+		A("next", e);
+	}
+	function N(e) {
+		A("throw", e);
+	}
+	function P(e, C) {
+		e(C), D.shift(), D.length && A(D[0][0], D[0][1]);
+	}
+}
+function __asyncValues(e) {
+	if (!Symbol.asyncIterator) throw TypeError("Symbol.asyncIterator is not defined.");
+	var C = e[Symbol.asyncIterator], w;
+	return C ? C.call(e) : (e = typeof __values == "function" ? __values(e) : e[Symbol.iterator](), w = {}, T("next"), T("throw"), T("return"), w[Symbol.asyncIterator] = function() {
+		return this;
+	}, w);
+	function T(C) {
+		w[C] = e[C] && function(w) {
+			return new Promise(function(T, D) {
+				w = e[C](w), E(T, D, w.done, w.value);
+			});
+		};
+	}
+	function E(e, C, w, T) {
+		Promise.resolve(T).then(function(C) {
+			e({
+				value: C,
+				done: w
+			});
+		}, C);
+	}
+}
+var isArrayLike = (function(e) {
+	return e && typeof e.length == "number" && typeof e != "function";
+});
+function isPromise(e) {
+	return isFunction(e?.then);
+}
+function createErrorClass(e) {
+	var C = e(function(e) {
+		Error.call(e), e.stack = (/* @__PURE__ */ Error()).stack;
+	});
+	return C.prototype = Object.create(Error.prototype), C.prototype.constructor = C, C;
+}
+var UnsubscriptionError = createErrorClass(function(e) {
+	return function(C) {
+		e(this), this.message = C ? C.length + " errors occurred during unsubscription:\n" + C.map(function(e, C) {
+			return C + 1 + ") " + e.toString();
+		}).join("\n  ") : "", this.name = "UnsubscriptionError", this.errors = C;
+	};
+});
+function arrRemove(e, C) {
+	if (e) {
+		var w = e.indexOf(C);
+		0 <= w && e.splice(w, 1);
+	}
+}
+var Subscription = function() {
+	function e(e) {
+		this.initialTeardown = e, this.closed = !1, this._parentage = null, this._finalizers = null;
+	}
+	return e.prototype.unsubscribe = function() {
+		var e, C, w, T, E;
+		if (!this.closed) {
+			this.closed = !0;
+			var D = this._parentage;
+			if (D) if (this._parentage = null, Array.isArray(D)) try {
+				for (var O = __values(D), k = O.next(); !k.done; k = O.next()) k.value.remove(this);
+			} catch (C) {
+				e = { error: C };
+			} finally {
+				try {
+					k && !k.done && (C = O.return) && C.call(O);
+				} finally {
+					if (e) throw e.error;
+				}
+			}
+			else D.remove(this);
+			var A = this.initialTeardown;
+			if (isFunction(A)) try {
+				A();
+			} catch (e) {
+				E = e instanceof UnsubscriptionError ? e.errors : [e];
+			}
+			var j = this._finalizers;
+			if (j) {
+				this._finalizers = null;
+				try {
+					for (var M = __values(j), N = M.next(); !N.done; N = M.next()) {
+						var P = N.value;
+						try {
+							execFinalizer(P);
+						} catch (e) {
+							E ??= [], e instanceof UnsubscriptionError ? E = __spreadArray(__spreadArray([], __read(E)), __read(e.errors)) : E.push(e);
+						}
+					}
+				} catch (e) {
+					w = { error: e };
+				} finally {
+					try {
+						N && !N.done && (T = M.return) && T.call(M);
+					} finally {
+						if (w) throw w.error;
+					}
+				}
+			}
+			if (E) throw new UnsubscriptionError(E);
+		}
+	}, e.prototype.add = function(C) {
+		if (C && C !== this) if (this.closed) execFinalizer(C);
+		else {
+			if (C instanceof e) {
+				if (C.closed || C._hasParent(this)) return;
+				C._addParent(this);
+			}
+			(this._finalizers = this._finalizers ?? []).push(C);
+		}
+	}, e.prototype._hasParent = function(e) {
+		var C = this._parentage;
+		return C === e || Array.isArray(C) && C.includes(e);
+	}, e.prototype._addParent = function(e) {
+		var C = this._parentage;
+		this._parentage = Array.isArray(C) ? (C.push(e), C) : C ? [C, e] : e;
+	}, e.prototype._removeParent = function(e) {
+		var C = this._parentage;
+		C === e ? this._parentage = null : Array.isArray(C) && arrRemove(C, e);
+	}, e.prototype.remove = function(C) {
+		var w = this._finalizers;
+		w && arrRemove(w, C), C instanceof e && C._removeParent(this);
+	}, e.EMPTY = (function() {
+		var C = new e();
+		return C.closed = !0, C;
+	})(), e;
+}();
+Subscription.EMPTY;
+function isSubscription(e) {
+	return e instanceof Subscription || e && "closed" in e && isFunction(e.remove) && isFunction(e.add) && isFunction(e.unsubscribe);
+}
+function execFinalizer(e) {
+	isFunction(e) ? e() : e.unsubscribe();
+}
+var config = {
+	onUnhandledError: null,
+	onStoppedNotification: null,
+	Promise: void 0,
+	useDeprecatedSynchronousErrorHandling: !1,
+	useDeprecatedNextContext: !1
+}, timeoutProvider = {
+	setTimeout: function(e, C) {
+		var w = [...arguments].slice(2), T = timeoutProvider.delegate;
+		return T?.setTimeout ? T.setTimeout.apply(T, __spreadArray([e, C], __read(w))) : setTimeout.apply(void 0, __spreadArray([e, C], __read(w)));
+	},
+	clearTimeout: function(e) {
+		return (timeoutProvider.delegate?.clearTimeout || clearTimeout)(e);
+	},
+	delegate: void 0
+};
+function reportUnhandledError(e) {
+	timeoutProvider.setTimeout(function() {
+		var C = config.onUnhandledError;
+		if (C) C(e);
+		else throw e;
+	});
+}
+function noop() {}
+var COMPLETE_NOTIFICATION = (function() {
+	return createNotification("C", void 0, void 0);
+})();
+function errorNotification(e) {
+	return createNotification("E", void 0, e);
+}
+function nextNotification(e) {
+	return createNotification("N", e, void 0);
+}
+function createNotification(e, C, w) {
+	return {
+		kind: e,
+		value: C,
+		error: w
+	};
+}
+var context = null;
+function errorContext(e) {
+	if (config.useDeprecatedSynchronousErrorHandling) {
+		var C = !context;
+		if (C && (context = {
+			errorThrown: !1,
+			error: null
+		}), e(), C) {
+			var w = context, T = w.errorThrown, E = w.error;
+			if (context = null, T) throw E;
+		}
+	} else e();
+}
+function captureError(e) {
+	config.useDeprecatedSynchronousErrorHandling && context && (context.errorThrown = !0, context.error = e);
+}
+var Subscriber = function(e) {
+	__extends(C, e);
+	function C(C) {
+		var w = e.call(this) || this;
+		return w.isStopped = !1, C ? (w.destination = C, isSubscription(C) && C.add(w)) : w.destination = EMPTY_OBSERVER, w;
+	}
+	return C.create = function(e, C, w) {
+		return new SafeSubscriber(e, C, w);
+	}, C.prototype.next = function(e) {
+		this.isStopped ? handleStoppedNotification(nextNotification(e), this) : this._next(e);
+	}, C.prototype.error = function(e) {
+		this.isStopped ? handleStoppedNotification(errorNotification(e), this) : (this.isStopped = !0, this._error(e));
+	}, C.prototype.complete = function() {
+		this.isStopped ? handleStoppedNotification(COMPLETE_NOTIFICATION, this) : (this.isStopped = !0, this._complete());
+	}, C.prototype.unsubscribe = function() {
+		this.closed || (this.isStopped = !0, e.prototype.unsubscribe.call(this), this.destination = null);
+	}, C.prototype._next = function(e) {
+		this.destination.next(e);
+	}, C.prototype._error = function(e) {
+		try {
+			this.destination.error(e);
+		} finally {
+			this.unsubscribe();
+		}
+	}, C.prototype._complete = function() {
+		try {
+			this.destination.complete();
+		} finally {
+			this.unsubscribe();
+		}
+	}, C;
+}(Subscription), _bind = Function.prototype.bind;
+function bind(e, C) {
+	return _bind.call(e, C);
+}
+var ConsumerObserver = function() {
+	function e(e) {
+		this.partialObserver = e;
+	}
+	return e.prototype.next = function(e) {
+		var C = this.partialObserver;
+		if (C.next) try {
+			C.next(e);
+		} catch (e) {
+			handleUnhandledError(e);
+		}
+	}, e.prototype.error = function(e) {
+		var C = this.partialObserver;
+		if (C.error) try {
+			C.error(e);
+		} catch (e) {
+			handleUnhandledError(e);
+		}
+		else handleUnhandledError(e);
+	}, e.prototype.complete = function() {
+		var e = this.partialObserver;
+		if (e.complete) try {
+			e.complete();
+		} catch (e) {
+			handleUnhandledError(e);
+		}
+	}, e;
+}(), SafeSubscriber = function(e) {
+	__extends(C, e);
+	function C(C, w, T) {
+		var E = e.call(this) || this, D;
+		if (isFunction(C) || !C) D = {
+			next: C ?? void 0,
+			error: w ?? void 0,
+			complete: T ?? void 0
+		};
+		else {
+			var O;
+			E && config.useDeprecatedNextContext ? (O = Object.create(C), O.unsubscribe = function() {
+				return E.unsubscribe();
+			}, D = {
+				next: C.next && bind(C.next, O),
+				error: C.error && bind(C.error, O),
+				complete: C.complete && bind(C.complete, O)
+			}) : D = C;
+		}
+		return E.destination = new ConsumerObserver(D), E;
+	}
+	return C;
+}(Subscriber);
+function handleUnhandledError(e) {
+	config.useDeprecatedSynchronousErrorHandling ? captureError(e) : reportUnhandledError(e);
+}
+function defaultErrorHandler(e) {
+	throw e;
+}
+function handleStoppedNotification(e, C) {
+	var w = config.onStoppedNotification;
+	w && timeoutProvider.setTimeout(function() {
+		return w(e, C);
+	});
+}
+var EMPTY_OBSERVER = {
+	closed: !0,
+	next: noop,
+	error: defaultErrorHandler,
+	complete: noop
+}, observable = (function() {
+	return typeof Symbol == "function" && Symbol.observable || "@@observable";
+})();
+function identity(e) {
+	return e;
+}
+function pipeFromArray(e) {
+	return e.length === 0 ? identity : e.length === 1 ? e[0] : function(C) {
+		return e.reduce(function(e, C) {
+			return C(e);
+		}, C);
+	};
+}
+var Observable = function() {
+	function e(e) {
+		e && (this._subscribe = e);
+	}
+	return e.prototype.lift = function(C) {
+		var w = new e();
+		return w.source = this, w.operator = C, w;
+	}, e.prototype.subscribe = function(e, C, w) {
+		var T = this, E = isSubscriber(e) ? e : new SafeSubscriber(e, C, w);
+		return errorContext(function() {
+			var e = T, C = e.operator, w = e.source;
+			E.add(C ? C.call(E, w) : w ? T._subscribe(E) : T._trySubscribe(E));
+		}), E;
+	}, e.prototype._trySubscribe = function(e) {
+		try {
+			return this._subscribe(e);
+		} catch (C) {
+			e.error(C);
+		}
+	}, e.prototype.forEach = function(e, C) {
+		var w = this;
+		return C = getPromiseCtor(C), new C(function(C, T) {
+			var E = new SafeSubscriber({
+				next: function(C) {
+					try {
+						e(C);
+					} catch (e) {
+						T(e), E.unsubscribe();
+					}
+				},
+				error: T,
+				complete: C
+			});
+			w.subscribe(E);
+		});
+	}, e.prototype._subscribe = function(e) {
+		return this.source?.subscribe(e);
+	}, e.prototype[observable] = function() {
+		return this;
+	}, e.prototype.pipe = function() {
+		return pipeFromArray([...arguments])(this);
+	}, e.prototype.toPromise = function(e) {
+		var C = this;
+		return e = getPromiseCtor(e), new e(function(e, w) {
+			var T;
+			C.subscribe(function(e) {
+				return T = e;
+			}, function(e) {
+				return w(e);
+			}, function() {
+				return e(T);
+			});
+		});
+	}, e.create = function(C) {
+		return new e(C);
+	}, e;
+}();
+function getPromiseCtor(e) {
+	return e ?? config.Promise ?? Promise;
+}
+function isObserver(e) {
+	return e && isFunction(e.next) && isFunction(e.error) && isFunction(e.complete);
+}
+function isSubscriber(e) {
+	return e && e instanceof Subscriber || isObserver(e) && isSubscription(e);
+}
+function isInteropObservable(e) {
+	return isFunction(e[observable]);
+}
+function isAsyncIterable(e) {
+	return Symbol.asyncIterator && isFunction(e?.[Symbol.asyncIterator]);
+}
+function createInvalidObservableTypeError(e) {
+	return /* @__PURE__ */ TypeError("You provided " + (typeof e == "object" && e ? "an invalid object" : "'" + e + "'") + " where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.");
+}
+function getSymbolIterator() {
+	return typeof Symbol != "function" || !Symbol.iterator ? "@@iterator" : Symbol.iterator;
+}
+var iterator = getSymbolIterator();
+function isIterable(e) {
+	return isFunction(e?.[iterator]);
+}
+function readableStreamLikeToAsyncGenerator(e) {
+	return __asyncGenerator(this, arguments, function() {
+		var C, w, T, E;
+		return __generator(this, function(D) {
+			switch (D.label) {
+				case 0: C = e.getReader(), D.label = 1;
+				case 1: D.trys.push([
+					1,
+					,
+					9,
+					10
+				]), D.label = 2;
+				case 2: return [4, __await(C.read())];
+				case 3: return w = D.sent(), T = w.value, E = w.done, E ? [4, __await(void 0)] : [3, 5];
+				case 4: return [2, D.sent()];
+				case 5: return [4, __await(T)];
+				case 6: return [4, D.sent()];
+				case 7: return D.sent(), [3, 2];
+				case 8: return [3, 10];
+				case 9: return C.releaseLock(), [7];
+				case 10: return [2];
+			}
+		});
+	});
+}
+function isReadableStreamLike(e) {
+	return isFunction(e?.getReader);
+}
+function innerFrom(e) {
+	if (e instanceof Observable) return e;
+	if (e != null) {
+		if (isInteropObservable(e)) return fromInteropObservable(e);
+		if (isArrayLike(e)) return fromArrayLike(e);
+		if (isPromise(e)) return fromPromise(e);
+		if (isAsyncIterable(e)) return fromAsyncIterable(e);
+		if (isIterable(e)) return fromIterable(e);
+		if (isReadableStreamLike(e)) return fromReadableStreamLike(e);
+	}
+	throw createInvalidObservableTypeError(e);
+}
+function fromInteropObservable(e) {
+	return new Observable(function(C) {
+		var w = e[observable]();
+		if (isFunction(w.subscribe)) return w.subscribe(C);
+		throw TypeError("Provided object does not correctly implement Symbol.observable");
+	});
+}
+function fromArrayLike(e) {
+	return new Observable(function(C) {
+		for (var w = 0; w < e.length && !C.closed; w++) C.next(e[w]);
+		C.complete();
+	});
+}
+function fromPromise(e) {
+	return new Observable(function(C) {
+		e.then(function(e) {
+			C.closed || (C.next(e), C.complete());
+		}, function(e) {
+			return C.error(e);
+		}).then(null, reportUnhandledError);
+	});
+}
+function fromIterable(e) {
+	return new Observable(function(C) {
+		var w, T;
+		try {
+			for (var E = __values(e), D = E.next(); !D.done; D = E.next()) {
+				var O = D.value;
+				if (C.next(O), C.closed) return;
+			}
+		} catch (e) {
+			w = { error: e };
+		} finally {
+			try {
+				D && !D.done && (T = E.return) && T.call(E);
+			} finally {
+				if (w) throw w.error;
+			}
+		}
+		C.complete();
+	});
+}
+function fromAsyncIterable(e) {
+	return new Observable(function(C) {
+		process(e, C).catch(function(e) {
+			return C.error(e);
+		});
+	});
+}
+function fromReadableStreamLike(e) {
+	return fromAsyncIterable(readableStreamLikeToAsyncGenerator(e));
+}
+function process(e, C) {
+	var w, T, E, D;
+	return __awaiter(this, void 0, void 0, function() {
+		var O, k;
+		return __generator(this, function(A) {
+			switch (A.label) {
+				case 0: A.trys.push([
+					0,
+					5,
+					6,
+					11
+				]), w = __asyncValues(e), A.label = 1;
+				case 1: return [4, w.next()];
+				case 2:
+					if (T = A.sent(), T.done) return [3, 4];
+					if (O = T.value, C.next(O), C.closed) return [2];
+					A.label = 3;
+				case 3: return [3, 1];
+				case 4: return [3, 11];
+				case 5: return k = A.sent(), E = { error: k }, [3, 11];
+				case 6: return A.trys.push([
+					6,
+					,
+					9,
+					10
+				]), T && !T.done && (D = w.return) ? [4, D.call(w)] : [3, 8];
+				case 7: A.sent(), A.label = 8;
+				case 8: return [3, 10];
+				case 9:
+					if (E) throw E.error;
+					return [7];
+				case 10: return [7];
+				case 11: return C.complete(), [2];
+			}
+		});
+	});
+}
+function createOperatorSubscriber(e, C, w, T, E) {
+	return new OperatorSubscriber(e, C, w, T, E);
+}
+var OperatorSubscriber = function(e) {
+	__extends(C, e);
+	function C(C, w, T, E, D, O) {
+		var k = e.call(this, C) || this;
+		return k.onFinalize = D, k.shouldUnsubscribe = O, k._next = w ? function(e) {
+			try {
+				w(e);
+			} catch (e) {
+				C.error(e);
+			}
+		} : e.prototype._next, k._error = E ? function(e) {
+			try {
+				E(e);
+			} catch (e) {
+				C.error(e);
+			} finally {
+				this.unsubscribe();
+			}
+		} : e.prototype._error, k._complete = T ? function() {
+			try {
+				T();
+			} catch (e) {
+				C.error(e);
+			} finally {
+				this.unsubscribe();
+			}
+		} : e.prototype._complete, k;
+	}
+	return C.prototype.unsubscribe = function() {
+		var C;
+		if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
+			var w = this.closed;
+			e.prototype.unsubscribe.call(this), !w && ((C = this.onFinalize) == null || C.call(this));
+		}
+	}, C;
+}(Subscriber), Action = function(e) {
+	__extends(C, e);
+	function C(C, w) {
+		return e.call(this) || this;
+	}
+	return C.prototype.schedule = function(e, C) {
+		return C === void 0 && (C = 0), this;
+	}, C;
+}(Subscription), intervalProvider = {
+	setInterval: function(e, C) {
+		var w = [...arguments].slice(2), T = intervalProvider.delegate;
+		return T?.setInterval ? T.setInterval.apply(T, __spreadArray([e, C], __read(w))) : setInterval.apply(void 0, __spreadArray([e, C], __read(w)));
+	},
+	clearInterval: function(e) {
+		return (intervalProvider.delegate?.clearInterval || clearInterval)(e);
+	},
+	delegate: void 0
+}, AsyncAction = function(e) {
+	__extends(C, e);
+	function C(C, w) {
+		var T = e.call(this, C, w) || this;
+		return T.scheduler = C, T.work = w, T.pending = !1, T;
+	}
+	return C.prototype.schedule = function(e, C) {
+		if (C === void 0 && (C = 0), this.closed) return this;
+		this.state = e;
+		var w = this.id, T = this.scheduler;
+		return w != null && (this.id = this.recycleAsyncId(T, w, C)), this.pending = !0, this.delay = C, this.id = this.id ?? this.requestAsyncId(T, this.id, C), this;
+	}, C.prototype.requestAsyncId = function(e, C, w) {
+		return w === void 0 && (w = 0), intervalProvider.setInterval(e.flush.bind(e, this), w);
+	}, C.prototype.recycleAsyncId = function(e, C, w) {
+		if (w === void 0 && (w = 0), w != null && this.delay === w && this.pending === !1) return C;
+		C != null && intervalProvider.clearInterval(C);
+	}, C.prototype.execute = function(e, C) {
+		if (this.closed) return /* @__PURE__ */ Error("executing a cancelled action");
+		this.pending = !1;
+		var w = this._execute(e, C);
+		if (w) return w;
+		this.pending === !1 && this.id != null && (this.id = this.recycleAsyncId(this.scheduler, this.id, null));
+	}, C.prototype._execute = function(e, C) {
+		var w = !1, T;
+		try {
+			this.work(e);
+		} catch (e) {
+			w = !0, T = e || /* @__PURE__ */ Error("Scheduled action threw falsy error");
+		}
+		if (w) return this.unsubscribe(), T;
+	}, C.prototype.unsubscribe = function() {
+		if (!this.closed) {
+			var C = this, w = C.id, T = C.scheduler, E = T.actions;
+			this.work = this.state = this.scheduler = null, this.pending = !1, arrRemove(E, this), w != null && (this.id = this.recycleAsyncId(T, w, null)), this.delay = null, e.prototype.unsubscribe.call(this);
+		}
+	}, C;
+}(Action), dateTimestampProvider = {
+	now: function() {
+		return (dateTimestampProvider.delegate || Date).now();
+	},
+	delegate: void 0
+}, Scheduler = function() {
+	function e(C, w) {
+		w === void 0 && (w = e.now), this.schedulerActionCtor = C, this.now = w;
+	}
+	return e.prototype.schedule = function(e, C, w) {
+		return C === void 0 && (C = 0), new this.schedulerActionCtor(this, e).schedule(w, C);
+	}, e.now = dateTimestampProvider.now, e;
+}(), asyncScheduler = new (function(e) {
+	__extends(C, e);
+	function C(C, w) {
+		w === void 0 && (w = Scheduler.now);
+		var T = e.call(this, C, w) || this;
+		return T.actions = [], T._active = !1, T;
+	}
+	return C.prototype.flush = function(e) {
+		var C = this.actions;
+		if (this._active) {
+			C.push(e);
+			return;
+		}
+		var w;
+		this._active = !0;
+		do
+			if (w = e.execute(e.state, e.delay)) break;
+		while (e = C.shift());
+		if (this._active = !1, w) {
+			for (; e = C.shift();) e.unsubscribe();
+			throw w;
+		}
+	}, C;
+}(Scheduler))(AsyncAction), async = asyncScheduler;
+function isScheduler(e) {
+	return e && isFunction(e.schedule);
+}
+function isValidDate(e) {
+	return e instanceof Date && !isNaN(e);
+}
+function timer(e, C, w) {
+	e === void 0 && (e = 0), w === void 0 && (w = async);
+	var T = -1;
+	return C != null && (isScheduler(C) ? w = C : T = C), new Observable(function(C) {
+		var E = isValidDate(e) ? +e - w.now() : e;
+		E < 0 && (E = 0);
+		var D = 0;
+		return w.schedule(function() {
+			C.closed || (C.next(D++), 0 <= T ? this.schedule(void 0, T) : C.complete());
+		}, E);
+	});
+}
+function executeSchedule(e, C, w, T, E) {
+	T === void 0 && (T = 0), E === void 0 && (E = !1);
+	var D = C.schedule(function() {
+		w(), E ? e.add(this.schedule(null, T)) : this.unsubscribe();
+	}, T);
+	if (e.add(D), !E) return D;
+}
+function mergeInternals(e, C, w, T, E, D, O, k) {
+	var A = [], j = 0, M = 0, N = !1, P = function() {
+		N && !A.length && !j && C.complete();
+	}, F = function(e) {
+		return j < T ? I(e) : A.push(e);
+	}, I = function(e) {
+		D && C.next(e), j++;
+		var k = !1;
+		innerFrom(w(e, M++)).subscribe(createOperatorSubscriber(C, function(e) {
+			E?.(e), D ? F(e) : C.next(e);
+		}, function() {
+			k = !0;
+		}, void 0, function() {
+			if (k) try {
+				j--;
+				for (var e = function() {
+					var e = A.shift();
+					O ? executeSchedule(C, O, function() {
+						return I(e);
+					}) : I(e);
+				}; A.length && j < T;) e();
+				P();
+			} catch (e) {
+				C.error(e);
+			}
+		}));
+	};
+	return e.subscribe(createOperatorSubscriber(C, F, function() {
+		N = !0, P();
+	})), function() {
+		k?.();
+	};
+}
+function expand(e, C, w) {
+	return C === void 0 && (C = Infinity), C = (C || 0) < 1 ? Infinity : C, operate(function(T, E) {
+		return mergeInternals(T, E, e, C, void 0, !0, w);
+	});
+}
+function retry(e) {
+	e === void 0 && (e = Infinity);
+	var C = e && typeof e == "object" ? e : { count: e }, w = C.count, T = w === void 0 ? Infinity : w, E = C.delay, D = C.resetOnSuccess, O = D === void 0 ? !1 : D;
+	return T <= 0 ? identity : operate(function(e, C) {
+		var w = 0, D, k = function() {
+			var A = !1;
+			D = e.subscribe(createOperatorSubscriber(C, function(e) {
+				O && (w = 0), C.next(e);
+			}, void 0, function(e) {
+				if (w++ < T) {
+					var O = function() {
+						D ? (D.unsubscribe(), D = null, k()) : A = !0;
+					};
+					if (E != null) {
+						var j = typeof E == "number" ? timer(E) : innerFrom(E(e, w)), M = createOperatorSubscriber(C, function() {
+							M.unsubscribe(), O();
+						}, function() {
+							C.complete();
+						});
+						j.subscribe(M);
+					} else O();
+				} else C.error(e);
+			})), A && (D.unsubscribe(), D = null, k());
+		};
+		k();
+	});
+}
+function switchMap(e, C) {
+	return operate(function(w, T) {
+		var E = null, D = 0, O = !1, k = function() {
+			return O && !E && T.complete();
+		};
+		w.subscribe(createOperatorSubscriber(T, function(w) {
+			E?.unsubscribe();
+			var O = 0, A = D++;
+			innerFrom(e(w, A)).subscribe(E = createOperatorSubscriber(T, function(e) {
+				return T.next(C ? C(w, e, A, O++) : e);
+			}, function() {
+				E = null, k();
+			}));
+		}, function() {
+			O = !0, k();
+		}));
+	});
+}
+function tap(e, C, w) {
+	var T = isFunction(e) || C || w ? {
+		next: e,
+		error: C,
+		complete: w
+	} : e;
+	return T ? operate(function(e, C) {
+		var w;
+		(w = T.subscribe) == null || w.call(T);
+		var E = !0;
+		e.subscribe(createOperatorSubscriber(C, function(e) {
+			var w;
+			(w = T.next) == null || w.call(T, e), C.next(e);
+		}, function() {
+			var e;
+			E = !1, (e = T.complete) == null || e.call(T), C.complete();
+		}, function(e) {
+			var w;
+			E = !1, (w = T.error) == null || w.call(T, e), C.error(e);
+		}, function() {
+			var e, C;
+			E && ((e = T.unsubscribe) == null || e.call(T)), (C = T.finalize) == null || C.call(T);
+		}));
+	}) : identity;
+}
+var TimeoutError = createErrorClass(function(e) {
+	return function(C) {
+		C === void 0 && (C = null), e(this), this.message = "Timeout has occurred", this.name = "TimeoutError", this.info = C;
+	};
+});
+function timeout(e, C) {
+	var w = isValidDate(e) ? { first: e } : typeof e == "number" ? { each: e } : e, T = w.first, E = w.each, D = w.with, O = D === void 0 ? timeoutErrorFactory : D, k = w.scheduler, A = k === void 0 ? C ?? asyncScheduler : k, j = w.meta, M = j === void 0 ? null : j;
+	if (T == null && E == null) throw TypeError("No timeout provided.");
+	return operate(function(e, C) {
+		var w, D, k = null, j = 0, N = function(e) {
+			D = executeSchedule(C, A, function() {
+				try {
+					w.unsubscribe(), innerFrom(O({
+						meta: M,
+						lastValue: k,
+						seen: j
+					})).subscribe(C);
+				} catch (e) {
+					C.error(e);
+				}
+			}, e);
+		};
+		w = e.subscribe(createOperatorSubscriber(C, function(e) {
+			D?.unsubscribe(), j++, C.next(k = e), E > 0 && N(E);
+		}, void 0, void 0, function() {
+			D?.closed || D?.unsubscribe(), k = null;
+		})), !j && N(T == null ? E : typeof T == "number" ? T : +T - A.now());
+	});
+}
+function timeoutErrorFactory(e) {
+	throw new TimeoutError(e);
+}
+function defineChain(e) {
+	let C = {
+		formatters: void 0,
+		fees: void 0,
+		serializers: void 0,
+		...e
+	};
+	function w(e) {
+		return (C) => {
+			let T = typeof C == "function" ? C(e) : C, E = {
+				...e,
+				...T
+			};
+			return Object.assign(E, { extend: w(E) });
+		};
+	}
+	return Object.assign(C, { extend: w(C) });
+}
+const version = "2.44.4";
+var errorConfig = {
+	getDocsUrl: ({ docsBaseUrl: e, docsPath: C = "", docsSlug: w }) => C ? `${e ?? "https://viem.sh"}${C}${w ? `#${w}` : ""}` : void 0,
+	version: `viem@${version}`
+}, BaseError = class e extends Error {
+	constructor(C, w = {}) {
+		let T = (() => w.cause instanceof e ? w.cause.details : w.cause?.message ? w.cause.message : w.details)(), E = (() => w.cause instanceof e && w.cause.docsPath || w.docsPath)(), D = errorConfig.getDocsUrl?.({
+			...w,
+			docsPath: E
+		}), O = [
+			C || "An error occurred.",
+			"",
+			...w.metaMessages ? [...w.metaMessages, ""] : [],
+			...D ? [`Docs: ${D}`] : [],
+			...T ? [`Details: ${T}`] : [],
+			...errorConfig.version ? [`Version: ${errorConfig.version}`] : []
+		].join("\n");
+		super(O, w.cause ? { cause: w.cause } : void 0), Object.defineProperty(this, "details", {
+			enumerable: !0,
+			configurable: !0,
+			writable: !0,
+			value: void 0
+		}), Object.defineProperty(this, "docsPath", {
+			enumerable: !0,
+			configurable: !0,
+			writable: !0,
+			value: void 0
+		}), Object.defineProperty(this, "metaMessages", {
+			enumerable: !0,
+			configurable: !0,
+			writable: !0,
+			value: void 0
+		}), Object.defineProperty(this, "shortMessage", {
+			enumerable: !0,
+			configurable: !0,
+			writable: !0,
+			value: void 0
+		}), Object.defineProperty(this, "version", {
+			enumerable: !0,
+			configurable: !0,
+			writable: !0,
+			value: void 0
+		}), Object.defineProperty(this, "name", {
+			enumerable: !0,
+			configurable: !0,
+			writable: !0,
+			value: "BaseError"
+		}), this.details = T, this.docsPath = E, this.metaMessages = w.metaMessages, this.name = w.name ?? this.name, this.shortMessage = C, this.version = version;
+	}
+	walk(e) {
+		return walk(this, e);
+	}
+};
+function walk(e, C) {
+	return C?.(e) ? e : e && typeof e == "object" && "cause" in e && e.cause !== void 0 ? walk(e.cause, C) : C ? null : e;
+}
+var IntegerOutOfRangeError = class extends BaseError {
+	constructor({ max: e, min: C, signed: w, size: T, value: E }) {
+		super(`Number "${E}" is not in safe ${T ? `${T * 8}-bit ${w ? "signed" : "unsigned"} ` : ""}integer range ${e ? `(${C} to ${e})` : `(above ${C})`}`, { name: "IntegerOutOfRangeError" });
+	}
+}, SizeOverflowError = class extends BaseError {
+	constructor({ givenSize: e, maxSize: C }) {
+		super(`Size cannot exceed ${C} bytes. Given size: ${e} bytes.`, { name: "SizeOverflowError" });
+	}
+};
+function isHex(e, { strict: C = !0 } = {}) {
+	return !e || typeof e != "string" ? !1 : C ? /^0x[0-9a-fA-F]*$/.test(e) : e.startsWith("0x");
+}
+function size(e) {
+	return isHex(e, { strict: !1 }) ? Math.ceil((e.length - 2) / 2) : e.length;
+}
+function trim(e, { dir: C = "left" } = {}) {
+	let w = typeof e == "string" ? e.replace("0x", "") : e, T = 0;
+	for (let e = 0; e < w.length - 1 && w[C === "left" ? e : w.length - e - 1].toString() === "0"; e++) T++;
+	return w = C === "left" ? w.slice(T) : w.slice(0, w.length - T), typeof e == "string" ? (w.length === 1 && C === "right" && (w = `${w}0`), `0x${w.length % 2 == 1 ? `0${w}` : w}`) : w;
+}
+var SliceOffsetOutOfBoundsError = class extends BaseError {
+	constructor({ offset: e, position: C, size: w }) {
+		super(`Slice ${C === "start" ? "starting" : "ending"} at offset "${e}" is out-of-bounds (size: ${w}).`, { name: "SliceOffsetOutOfBoundsError" });
+	}
+}, SizeExceedsPaddingSizeError = class extends BaseError {
+	constructor({ size: e, targetSize: C, type: w }) {
+		super(`${w.charAt(0).toUpperCase()}${w.slice(1).toLowerCase()} size (${e}) exceeds padding size (${C}).`, { name: "SizeExceedsPaddingSizeError" });
+	}
+};
+function pad(e, { dir: C, size: w = 32 } = {}) {
+	return typeof e == "string" ? padHex(e, {
+		dir: C,
+		size: w
+	}) : padBytes(e, {
+		dir: C,
+		size: w
+	});
+}
+function padHex(e, { dir: C, size: w = 32 } = {}) {
+	if (w === null) return e;
+	let T = e.replace("0x", "");
+	if (T.length > w * 2) throw new SizeExceedsPaddingSizeError({
+		size: Math.ceil(T.length / 2),
+		targetSize: w,
+		type: "hex"
+	});
+	return `0x${T[C === "right" ? "padEnd" : "padStart"](w * 2, "0")}`;
+}
+function padBytes(e, { dir: C, size: w = 32 } = {}) {
+	if (w === null) return e;
+	if (e.length > w) throw new SizeExceedsPaddingSizeError({
+		size: e.length,
+		targetSize: w,
+		type: "bytes"
+	});
+	let T = new Uint8Array(w);
+	for (let E = 0; E < w; E++) {
+		let D = C === "right";
+		T[D ? E : w - E - 1] = e[D ? E : e.length - E - 1];
+	}
+	return T;
+}
+var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (e, C) => C.toString(16).padStart(2, "0"));
+function toHex(e, C = {}) {
+	return typeof e == "number" || typeof e == "bigint" ? numberToHex(e, C) : typeof e == "string" ? stringToHex(e, C) : typeof e == "boolean" ? boolToHex(e, C) : bytesToHex(e, C);
+}
+function boolToHex(e, C = {}) {
+	let w = `0x${Number(e)}`;
+	return typeof C.size == "number" ? (assertSize(w, { size: C.size }), pad(w, { size: C.size })) : w;
+}
+function bytesToHex(e, C = {}) {
+	let w = "";
+	for (let C = 0; C < e.length; C++) w += hexes[e[C]];
+	let T = `0x${w}`;
+	return typeof C.size == "number" ? (assertSize(T, { size: C.size }), pad(T, {
+		dir: "right",
+		size: C.size
+	})) : T;
+}
+function numberToHex(e, C = {}) {
+	let { signed: w, size: T } = C, E = BigInt(e), D;
+	T ? D = w ? (1n << BigInt(T) * 8n - 1n) - 1n : 2n ** (BigInt(T) * 8n) - 1n : typeof e == "number" && (D = BigInt(2 ** 53 - 1));
+	let O = typeof D == "bigint" && w ? -D - 1n : 0;
+	if (D && E > D || E < O) {
+		let C = typeof e == "bigint" ? "n" : "";
+		throw new IntegerOutOfRangeError({
+			max: D ? `${D}${C}` : void 0,
+			min: `${O}${C}`,
+			signed: w,
+			size: T,
+			value: `${e}${C}`
+		});
+	}
+	let k = `0x${(w && E < 0 ? (1n << BigInt(T * 8)) + BigInt(E) : E).toString(16)}`;
+	return T ? pad(k, { size: T }) : k;
+}
+var encoder$1 = /* @__PURE__ */ new TextEncoder();
+function stringToHex(e, C = {}) {
+	return bytesToHex(encoder$1.encode(e), C);
+}
+var encoder = /* @__PURE__ */ new TextEncoder();
+function toBytes(e, C = {}) {
+	return typeof e == "number" || typeof e == "bigint" ? numberToBytes(e, C) : typeof e == "boolean" ? boolToBytes(e, C) : isHex(e) ? hexToBytes(e, C) : stringToBytes(e, C);
+}
+function boolToBytes(e, C = {}) {
+	let w = new Uint8Array(1);
+	return w[0] = Number(e), typeof C.size == "number" ? (assertSize(w, { size: C.size }), pad(w, { size: C.size })) : w;
+}
+var charCodeMap = {
+	zero: 48,
+	nine: 57,
+	A: 65,
+	F: 70,
+	a: 97,
+	f: 102
+};
+function charCodeToBase16(e) {
+	if (e >= charCodeMap.zero && e <= charCodeMap.nine) return e - charCodeMap.zero;
+	if (e >= charCodeMap.A && e <= charCodeMap.F) return e - (charCodeMap.A - 10);
+	if (e >= charCodeMap.a && e <= charCodeMap.f) return e - (charCodeMap.a - 10);
+}
+function hexToBytes(e, C = {}) {
+	let w = e;
+	C.size && (assertSize(w, { size: C.size }), w = pad(w, {
+		dir: "right",
+		size: C.size
+	}));
+	let T = w.slice(2);
+	T.length % 2 && (T = `0${T}`);
+	let E = T.length / 2, D = new Uint8Array(E);
+	for (let e = 0, C = 0; e < E; e++) {
+		let w = charCodeToBase16(T.charCodeAt(C++)), E = charCodeToBase16(T.charCodeAt(C++));
+		if (w === void 0 || E === void 0) throw new BaseError(`Invalid byte sequence ("${T[C - 2]}${T[C - 1]}" in "${T}").`);
+		D[e] = w * 16 + E;
+	}
+	return D;
+}
+function numberToBytes(e, C) {
+	return hexToBytes(numberToHex(e, C));
+}
+function stringToBytes(e, C = {}) {
+	let w = encoder.encode(e);
+	return typeof C.size == "number" ? (assertSize(w, { size: C.size }), pad(w, {
+		dir: "right",
+		size: C.size
+	})) : w;
+}
+function assertSize(e, { size: C }) {
+	if (size(e) > C) throw new SizeOverflowError({
+		givenSize: size(e),
+		maxSize: C
+	});
+}
+function hexToBigInt(e, C = {}) {
+	let { signed: w } = C;
+	C.size && assertSize(e, { size: C.size });
+	let T = BigInt(e);
+	if (!w) return T;
+	let E = (e.length - 2) / 2;
+	return T <= (1n << BigInt(E) * 8n - 1n) - 1n ? T : T - BigInt(`0x${"f".padStart(E * 2, "f")}`) - 1n;
+}
+function hexToNumber(e, C = {}) {
+	let w = hexToBigInt(e, C), T = Number(w);
+	if (!Number.isSafeInteger(T)) throw new IntegerOutOfRangeError({
+		max: `${2 ** 53 - 1}`,
+		min: `${-(2 ** 53 - 1)}`,
+		signed: C.signed,
+		size: C.size,
+		value: `${w}n`
+	});
+	return T;
+}
+function defineFormatter(e, C) {
+	return ({ exclude: w, format: T }) => ({
+		exclude: w,
+		format: (e, E) => {
+			let D = C(e, E);
+			if (w) for (let e of w) delete D[e];
+			return {
+				...D,
+				...T(e, E)
+			};
+		},
+		type: e
+	});
+}
+const transactionType = {
+	"0x0": "legacy",
+	"0x1": "eip2930",
+	"0x2": "eip1559",
+	"0x3": "eip4844",
+	"0x4": "eip7702"
+};
+function formatTransaction(e, C) {
+	let w = {
+		...e,
+		blockHash: e.blockHash ? e.blockHash : null,
+		blockNumber: e.blockNumber ? BigInt(e.blockNumber) : null,
+		chainId: e.chainId ? hexToNumber(e.chainId) : void 0,
+		gas: e.gas ? BigInt(e.gas) : void 0,
+		gasPrice: e.gasPrice ? BigInt(e.gasPrice) : void 0,
+		maxFeePerBlobGas: e.maxFeePerBlobGas ? BigInt(e.maxFeePerBlobGas) : void 0,
+		maxFeePerGas: e.maxFeePerGas ? BigInt(e.maxFeePerGas) : void 0,
+		maxPriorityFeePerGas: e.maxPriorityFeePerGas ? BigInt(e.maxPriorityFeePerGas) : void 0,
+		nonce: e.nonce ? hexToNumber(e.nonce) : void 0,
+		to: e.to ? e.to : null,
+		transactionIndex: e.transactionIndex ? Number(e.transactionIndex) : null,
+		type: e.type ? transactionType[e.type] : void 0,
+		typeHex: e.type ? e.type : void 0,
+		value: e.value ? BigInt(e.value) : void 0,
+		v: e.v ? BigInt(e.v) : void 0
+	};
+	return e.authorizationList && (w.authorizationList = formatAuthorizationList(e.authorizationList)), w.yParity = (() => {
+		if (e.yParity) return Number(e.yParity);
+		if (typeof w.v == "bigint") {
+			if (w.v === 0n || w.v === 27n) return 0;
+			if (w.v === 1n || w.v === 28n) return 1;
+			if (w.v >= 35n) return w.v % 2n == 0n ? 1 : 0;
+		}
+	})(), w.type === "legacy" && (delete w.accessList, delete w.maxFeePerBlobGas, delete w.maxFeePerGas, delete w.maxPriorityFeePerGas, delete w.yParity), w.type === "eip2930" && (delete w.maxFeePerBlobGas, delete w.maxFeePerGas, delete w.maxPriorityFeePerGas), w.type === "eip1559" && delete w.maxFeePerBlobGas, w;
+}
+const defineTransaction = /* @__PURE__ */ defineFormatter("transaction", formatTransaction);
+function formatAuthorizationList(e) {
+	return e.map((e) => ({
+		address: e.address,
+		chainId: Number(e.chainId),
+		nonce: Number(e.nonce),
+		r: e.r,
+		s: e.s,
+		yParity: Number(e.yParity)
+	}));
+}
+function formatBlock(e, C) {
+	let w = (e.transactions ?? []).map((e) => typeof e == "string" ? e : formatTransaction(e));
+	return {
+		...e,
+		baseFeePerGas: e.baseFeePerGas ? BigInt(e.baseFeePerGas) : null,
+		blobGasUsed: e.blobGasUsed ? BigInt(e.blobGasUsed) : void 0,
+		difficulty: e.difficulty ? BigInt(e.difficulty) : void 0,
+		excessBlobGas: e.excessBlobGas ? BigInt(e.excessBlobGas) : void 0,
+		gasLimit: e.gasLimit ? BigInt(e.gasLimit) : void 0,
+		gasUsed: e.gasUsed ? BigInt(e.gasUsed) : void 0,
+		hash: e.hash ? e.hash : null,
+		logsBloom: e.logsBloom ? e.logsBloom : null,
+		nonce: e.nonce ? e.nonce : null,
+		number: e.number ? BigInt(e.number) : null,
+		size: e.size ? BigInt(e.size) : void 0,
+		timestamp: e.timestamp ? BigInt(e.timestamp) : void 0,
+		transactions: w,
+		totalDifficulty: e.totalDifficulty ? BigInt(e.totalDifficulty) : null
+	};
+}
+const defineBlock = /* @__PURE__ */ defineFormatter("block", formatBlock);
+function formatLog(e, { args: C, eventName: w } = {}) {
+	return {
+		...e,
+		blockHash: e.blockHash ? e.blockHash : null,
+		blockNumber: e.blockNumber ? BigInt(e.blockNumber) : null,
+		blockTimestamp: e.blockTimestamp ? BigInt(e.blockTimestamp) : e.blockTimestamp === null ? null : void 0,
+		logIndex: e.logIndex ? Number(e.logIndex) : null,
+		transactionHash: e.transactionHash ? e.transactionHash : null,
+		transactionIndex: e.transactionIndex ? Number(e.transactionIndex) : null,
+		...w ? {
+			args: C,
+			eventName: w
+		} : {}
+	};
+}
+const receiptStatuses = {
+	"0x0": "reverted",
+	"0x1": "success"
+};
+function formatTransactionReceipt(e, C) {
+	let w = {
+		...e,
+		blockNumber: e.blockNumber ? BigInt(e.blockNumber) : null,
+		contractAddress: e.contractAddress ? e.contractAddress : null,
+		cumulativeGasUsed: e.cumulativeGasUsed ? BigInt(e.cumulativeGasUsed) : null,
+		effectiveGasPrice: e.effectiveGasPrice ? BigInt(e.effectiveGasPrice) : null,
+		gasUsed: e.gasUsed ? BigInt(e.gasUsed) : null,
+		logs: e.logs ? e.logs.map((e) => formatLog(e)) : null,
+		to: e.to ? e.to : null,
+		transactionIndex: e.transactionIndex ? hexToNumber(e.transactionIndex) : null,
+		status: e.status ? receiptStatuses[e.status] : null,
+		type: e.type ? transactionType[e.type] || e.type : null
+	};
+	return e.blobGasPrice && (w.blobGasPrice = BigInt(e.blobGasPrice)), e.blobGasUsed && (w.blobGasUsed = BigInt(e.blobGasUsed)), w;
+}
+const defineTransactionReceipt = /* @__PURE__ */ defineFormatter("transactionReceipt", formatTransactionReceipt);
+2n ** (8n - 1n) - 1n, 2n ** (16n - 1n) - 1n, 2n ** (24n - 1n) - 1n, 2n ** (32n - 1n) - 1n, 2n ** (40n - 1n) - 1n, 2n ** (48n - 1n) - 1n, 2n ** (56n - 1n) - 1n, 2n ** (64n - 1n) - 1n, 2n ** (72n - 1n) - 1n, 2n ** (80n - 1n) - 1n, 2n ** (88n - 1n) - 1n, 2n ** (96n - 1n) - 1n, 2n ** (104n - 1n) - 1n, 2n ** (112n - 1n) - 1n, 2n ** (120n - 1n) - 1n, 2n ** (128n - 1n) - 1n, 2n ** (136n - 1n) - 1n, 2n ** (144n - 1n) - 1n, 2n ** (152n - 1n) - 1n, 2n ** (160n - 1n) - 1n, 2n ** (168n - 1n) - 1n, 2n ** (176n - 1n) - 1n, 2n ** (184n - 1n) - 1n, 2n ** (192n - 1n) - 1n, 2n ** (200n - 1n) - 1n, 2n ** (208n - 1n) - 1n, 2n ** (216n - 1n) - 1n, 2n ** (224n - 1n) - 1n, 2n ** (232n - 1n) - 1n, 2n ** (240n - 1n) - 1n, 2n ** (248n - 1n) - 1n, 2n ** (256n - 1n) - 1n, -(2n ** (8n - 1n)), -(2n ** (16n - 1n)), -(2n ** (24n - 1n)), -(2n ** (32n - 1n)), -(2n ** (40n - 1n)), -(2n ** (48n - 1n)), -(2n ** (56n - 1n)), -(2n ** (64n - 1n)), -(2n ** (72n - 1n)), -(2n ** (80n - 1n)), -(2n ** (88n - 1n)), -(2n ** (96n - 1n)), -(2n ** (104n - 1n)), -(2n ** (112n - 1n)), -(2n ** (120n - 1n)), -(2n ** (128n - 1n)), -(2n ** (136n - 1n)), -(2n ** (144n - 1n)), -(2n ** (152n - 1n)), -(2n ** (160n - 1n)), -(2n ** (168n - 1n)), -(2n ** (176n - 1n)), -(2n ** (184n - 1n)), -(2n ** (192n - 1n)), -(2n ** (200n - 1n)), -(2n ** (208n - 1n)), -(2n ** (216n - 1n)), -(2n ** (224n - 1n)), -(2n ** (232n - 1n)), -(2n ** (240n - 1n)), -(2n ** (248n - 1n)), -(2n ** (256n - 1n));
+const maxUint256 = 2n ** 256n - 1n;
+function concatHex(e) {
+	return `0x${e.reduce((e, C) => e + C.replace("0x", ""), "")}`;
+}
+var NegativeOffsetError = class extends BaseError {
+	constructor({ offset: e }) {
+		super(`Offset \`${e}\` cannot be negative.`, { name: "NegativeOffsetError" });
+	}
+}, PositionOutOfBoundsError = class extends BaseError {
+	constructor({ length: e, position: C }) {
+		super(`Position \`${C}\` is out of bounds (\`0 < position < ${e}\`).`, { name: "PositionOutOfBoundsError" });
+	}
+}, RecursiveReadLimitExceededError = class extends BaseError {
+	constructor({ count: e, limit: C }) {
+		super(`Recursive read limit of \`${C}\` exceeded (recursive read count: \`${e}\`).`, { name: "RecursiveReadLimitExceededError" });
+	}
+}, staticCursor = {
+	bytes: new Uint8Array(),
+	dataView: /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(0)),
+	position: 0,
+	positionReadCount: /* @__PURE__ */ new Map(),
+	recursiveReadCount: 0,
+	recursiveReadLimit: Infinity,
+	assertReadLimit() {
+		if (this.recursiveReadCount >= this.recursiveReadLimit) throw new RecursiveReadLimitExceededError({
+			count: this.recursiveReadCount + 1,
+			limit: this.recursiveReadLimit
+		});
+	},
+	assertPosition(e) {
+		if (e < 0 || e > this.bytes.length - 1) throw new PositionOutOfBoundsError({
+			length: this.bytes.length,
+			position: e
+		});
+	},
+	decrementPosition(e) {
+		if (e < 0) throw new NegativeOffsetError({ offset: e });
+		let C = this.position - e;
+		this.assertPosition(C), this.position = C;
+	},
+	getReadCount(e) {
+		return this.positionReadCount.get(e || this.position) || 0;
+	},
+	incrementPosition(e) {
+		if (e < 0) throw new NegativeOffsetError({ offset: e });
+		let C = this.position + e;
+		this.assertPosition(C), this.position = C;
+	},
+	inspectByte(e) {
+		let C = e ?? this.position;
+		return this.assertPosition(C), this.bytes[C];
+	},
+	inspectBytes(e, C) {
+		let w = C ?? this.position;
+		return this.assertPosition(w + e - 1), this.bytes.subarray(w, w + e);
+	},
+	inspectUint8(e) {
+		let C = e ?? this.position;
+		return this.assertPosition(C), this.bytes[C];
+	},
+	inspectUint16(e) {
+		let C = e ?? this.position;
+		return this.assertPosition(C + 1), this.dataView.getUint16(C);
+	},
+	inspectUint24(e) {
+		let C = e ?? this.position;
+		return this.assertPosition(C + 2), (this.dataView.getUint16(C) << 8) + this.dataView.getUint8(C + 2);
+	},
+	inspectUint32(e) {
+		let C = e ?? this.position;
+		return this.assertPosition(C + 3), this.dataView.getUint32(C);
+	},
+	pushByte(e) {
+		this.assertPosition(this.position), this.bytes[this.position] = e, this.position++;
+	},
+	pushBytes(e) {
+		this.assertPosition(this.position + e.length - 1), this.bytes.set(e, this.position), this.position += e.length;
+	},
+	pushUint8(e) {
+		this.assertPosition(this.position), this.bytes[this.position] = e, this.position++;
+	},
+	pushUint16(e) {
+		this.assertPosition(this.position + 1), this.dataView.setUint16(this.position, e), this.position += 2;
+	},
+	pushUint24(e) {
+		this.assertPosition(this.position + 2), this.dataView.setUint16(this.position, e >> 8), this.dataView.setUint8(this.position + 2, e & 255), this.position += 3;
+	},
+	pushUint32(e) {
+		this.assertPosition(this.position + 3), this.dataView.setUint32(this.position, e), this.position += 4;
+	},
+	readByte() {
+		this.assertReadLimit(), this._touch();
+		let e = this.inspectByte();
+		return this.position++, e;
+	},
+	readBytes(e, C) {
+		this.assertReadLimit(), this._touch();
+		let w = this.inspectBytes(e);
+		return this.position += C ?? e, w;
+	},
+	readUint8() {
+		this.assertReadLimit(), this._touch();
+		let e = this.inspectUint8();
+		return this.position += 1, e;
+	},
+	readUint16() {
+		this.assertReadLimit(), this._touch();
+		let e = this.inspectUint16();
+		return this.position += 2, e;
+	},
+	readUint24() {
+		this.assertReadLimit(), this._touch();
+		let e = this.inspectUint24();
+		return this.position += 3, e;
+	},
+	readUint32() {
+		this.assertReadLimit(), this._touch();
+		let e = this.inspectUint32();
+		return this.position += 4, e;
+	},
+	get remaining() {
+		return this.bytes.length - this.position;
+	},
+	setPosition(e) {
+		let C = this.position;
+		return this.assertPosition(e), this.position = e, () => this.position = C;
+	},
+	_touch() {
+		if (this.recursiveReadLimit === Infinity) return;
+		let e = this.getReadCount();
+		this.positionReadCount.set(this.position, e + 1), e > 0 && this.recursiveReadCount++;
+	}
+};
+function createCursor(e, { recursiveReadLimit: C = 8192 } = {}) {
+	let w = Object.create(staticCursor);
+	return w.bytes = e, w.dataView = new DataView(e.buffer ?? e, e.byteOffset, e.byteLength), w.positionReadCount = /* @__PURE__ */ new Map(), w.recursiveReadLimit = C, w;
+}
+function toRlp(e, C = "hex") {
+	let w = getEncodable(e), T = createCursor(new Uint8Array(w.length));
+	return w.encode(T), C === "hex" ? bytesToHex(T.bytes) : T.bytes;
+}
+function getEncodable(e) {
+	return Array.isArray(e) ? getEncodableList(e.map((e) => getEncodable(e))) : getEncodableBytes(e);
+}
+function getEncodableList(e) {
+	let C = e.reduce((e, C) => e + C.length, 0), w = getSizeOfLength(C);
+	return {
+		length: (() => C <= 55 ? 1 + C : 1 + w + C)(),
+		encode(T) {
+			C <= 55 ? T.pushByte(192 + C) : (T.pushByte(247 + w), w === 1 ? T.pushUint8(C) : w === 2 ? T.pushUint16(C) : w === 3 ? T.pushUint24(C) : T.pushUint32(C));
+			for (let { encode: C } of e) C(T);
+		}
+	};
+}
+function getEncodableBytes(e) {
+	let C = typeof e == "string" ? hexToBytes(e) : e, w = getSizeOfLength(C.length);
+	return {
+		length: (() => C.length === 1 && C[0] < 128 ? 1 : C.length <= 55 ? 1 + C.length : 1 + w + C.length)(),
+		encode(e) {
+			C.length === 1 && C[0] < 128 ? e.pushBytes(C) : C.length <= 55 ? (e.pushByte(128 + C.length), e.pushBytes(C)) : (e.pushByte(183 + w), w === 1 ? e.pushUint8(C.length) : w === 2 ? e.pushUint16(C.length) : w === 3 ? e.pushUint24(C.length) : e.pushUint32(C.length), e.pushBytes(C));
+		}
+	};
+}
+function getSizeOfLength(e) {
+	if (e < 2 ** 8) return 1;
+	if (e < 2 ** 16) return 2;
+	if (e < 2 ** 24) return 3;
+	if (e < 2 ** 32) return 4;
+	throw new BaseError("Length is too large.");
+}
+const gweiUnits = {
+	ether: -9,
+	wei: 9
+};
+function formatUnits(e, C) {
+	let w = e.toString(), T = w.startsWith("-");
+	T && (w = w.slice(1)), w = w.padStart(C, "0");
+	let [E, D] = [w.slice(0, w.length - C), w.slice(w.length - C)];
+	return D = D.replace(/(0+)$/, ""), `${T ? "-" : ""}${E || "0"}${D ? `.${D}` : ""}`;
+}
+function formatGwei(e, C = "wei") {
+	return formatUnits(e, gweiUnits[C]);
+}
+function prettyPrint(e) {
+	let C = Object.entries(e).map(([e, C]) => C === void 0 || C === !1 ? null : [e, C]).filter(Boolean), w = C.reduce((e, [C]) => Math.max(e, C.length), 0);
+	return C.map(([e, C]) => `  ${`${e}:`.padEnd(w + 1)}  ${C}`).join("\n");
+}
+var InvalidLegacyVError = class extends BaseError {
+	constructor({ v: e }) {
+		super(`Invalid \`v\` value "${e}". Expected 27 or 28.`, { name: "InvalidLegacyVError" });
+	}
+}, InvalidSerializableTransactionError = class extends BaseError {
+	constructor({ transaction: e }) {
+		super("Cannot infer a transaction type from provided transaction.", {
+			metaMessages: [
+				"Provided Transaction:",
+				"{",
+				prettyPrint(e),
+				"}",
+				"",
+				"To infer the type, either provide:",
+				"- a `type` to the Transaction, or",
+				"- an EIP-1559 Transaction with `maxFeePerGas`, or",
+				"- an EIP-2930 Transaction with `gasPrice` & `accessList`, or",
+				"- an EIP-4844 Transaction with `blobs`, `blobVersionedHashes`, `sidecars`, or",
+				"- an EIP-7702 Transaction with `authorizationList`, or",
+				"- a Legacy Transaction with `gasPrice`"
+			],
+			name: "InvalidSerializableTransactionError"
+		});
+	}
+}, InvalidStorageKeySizeError = class extends BaseError {
+	constructor({ storageKey: e }) {
+		super(`Size for storage key "${e}" is invalid. Expected 32 bytes. Got ${Math.floor((e.length - 2) / 2)} bytes.`, { name: "InvalidStorageKeySizeError" });
+	}
+};
+function serializeAuthorizationList(e) {
+	if (!e || e.length === 0) return [];
+	let C = [];
+	for (let w of e) {
+		let { chainId: e, nonce: T, ...E } = w, D = w.address;
+		C.push([
+			e ? toHex(e) : "0x",
+			D,
+			T ? toHex(T) : "0x",
+			...toYParitySignatureArray({}, E)
+		]);
+	}
+	return C;
+}
+function blobsToCommitments(e) {
+	let { kzg: C } = e, w = e.to ?? (typeof e.blobs[0] == "string" ? "hex" : "bytes"), T = typeof e.blobs[0] == "string" ? e.blobs.map((e) => hexToBytes(e)) : e.blobs, E = [];
+	for (let e of T) E.push(Uint8Array.from(C.blobToKzgCommitment(e)));
+	return w === "bytes" ? E : E.map((e) => bytesToHex(e));
+}
+function blobsToProofs(e) {
+	let { kzg: C } = e, w = e.to ?? (typeof e.blobs[0] == "string" ? "hex" : "bytes"), T = typeof e.blobs[0] == "string" ? e.blobs.map((e) => hexToBytes(e)) : e.blobs, E = typeof e.commitments[0] == "string" ? e.commitments.map((e) => hexToBytes(e)) : e.commitments, D = [];
+	for (let e = 0; e < T.length; e++) {
+		let w = T[e], O = E[e];
+		D.push(Uint8Array.from(C.computeBlobKzgProof(w, O)));
+	}
+	return w === "bytes" ? D : D.map((e) => bytesToHex(e));
+}
+function isBytes(e) {
+	return e instanceof Uint8Array || ArrayBuffer.isView(e) && e.constructor.name === "Uint8Array";
+}
+function anumber(e) {
+	if (!Number.isSafeInteger(e) || e < 0) throw Error("positive integer expected, got " + e);
+}
+function abytes(e, ...C) {
+	if (!isBytes(e)) throw Error("Uint8Array expected");
+	if (C.length > 0 && !C.includes(e.length)) throw Error("Uint8Array expected of length " + C + ", got length=" + e.length);
+}
+function aexists(e, C = !0) {
+	if (e.destroyed) throw Error("Hash instance has been destroyed");
+	if (C && e.finished) throw Error("Hash#digest() has already been called");
+}
+function aoutput(e, C) {
+	abytes(e);
+	let w = C.outputLen;
+	if (e.length < w) throw Error("digestInto() expects output buffer of length at least " + w);
+}
+function u32(e) {
+	return new Uint32Array(e.buffer, e.byteOffset, Math.floor(e.byteLength / 4));
+}
+function clean(...e) {
+	for (let C = 0; C < e.length; C++) e[C].fill(0);
+}
+function createView(e) {
+	return new DataView(e.buffer, e.byteOffset, e.byteLength);
+}
+function rotr(e, C) {
+	return e << 32 - C | e >>> C;
+}
+const isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+function byteSwap(e) {
+	return e << 24 & 4278190080 | e << 8 & 16711680 | e >>> 8 & 65280 | e >>> 24 & 255;
+}
+function byteSwap32(e) {
+	for (let C = 0; C < e.length; C++) e[C] = byteSwap(e[C]);
+	return e;
+}
+const swap32IfBE = isLE ? (e) => e : byteSwap32;
+function utf8ToBytes(e) {
+	if (typeof e != "string") throw Error("string expected");
+	return new Uint8Array(new TextEncoder().encode(e));
+}
+function toBytes$1(e) {
+	return typeof e == "string" && (e = utf8ToBytes(e)), abytes(e), e;
+}
+var Hash = class {};
+function createHasher(e) {
+	let C = (C) => e().update(toBytes$1(C)).digest(), w = e();
+	return C.outputLen = w.outputLen, C.blockLen = w.blockLen, C.create = () => e(), C;
+}
+function setBigUint64(e, C, w, T) {
+	if (typeof e.setBigUint64 == "function") return e.setBigUint64(C, w, T);
+	let E = BigInt(32), D = BigInt(4294967295), O = Number(w >> E & D), k = Number(w & D), A = T ? 4 : 0, j = T ? 0 : 4;
+	e.setUint32(C + A, O, T), e.setUint32(C + j, k, T);
+}
+function Chi(e, C, w) {
+	return e & C ^ ~e & w;
+}
+function Maj(e, C, w) {
+	return e & C ^ e & w ^ C & w;
+}
+var HashMD = class extends Hash {
+	constructor(e, C, w, T) {
+		super(), this.finished = !1, this.length = 0, this.pos = 0, this.destroyed = !1, this.blockLen = e, this.outputLen = C, this.padOffset = w, this.isLE = T, this.buffer = new Uint8Array(e), this.view = createView(this.buffer);
+	}
+	update(e) {
+		aexists(this), e = toBytes$1(e), abytes(e);
+		let { view: C, buffer: w, blockLen: T } = this, E = e.length;
+		for (let D = 0; D < E;) {
+			let O = Math.min(T - this.pos, E - D);
+			if (O === T) {
+				let C = createView(e);
+				for (; T <= E - D; D += T) this.process(C, D);
+				continue;
+			}
+			w.set(e.subarray(D, D + O), this.pos), this.pos += O, D += O, this.pos === T && (this.process(C, 0), this.pos = 0);
+		}
+		return this.length += e.length, this.roundClean(), this;
+	}
+	digestInto(e) {
+		aexists(this), aoutput(e, this), this.finished = !0;
+		let { buffer: C, view: w, blockLen: T, isLE: E } = this, { pos: D } = this;
+		C[D++] = 128, clean(this.buffer.subarray(D)), this.padOffset > T - D && (this.process(w, 0), D = 0);
+		for (let e = D; e < T; e++) C[e] = 0;
+		setBigUint64(w, T - 8, BigInt(this.length * 8), E), this.process(w, 0);
+		let O = createView(e), k = this.outputLen;
+		if (k % 4) throw Error("_sha2: outputLen should be aligned to 32bit");
+		let A = k / 4, j = this.get();
+		if (A > j.length) throw Error("_sha2: outputLen bigger than state");
+		for (let e = 0; e < A; e++) O.setUint32(4 * e, j[e], E);
+	}
+	digest() {
+		let { buffer: e, outputLen: C } = this;
+		this.digestInto(e);
+		let w = e.slice(0, C);
+		return this.destroy(), w;
+	}
+	_cloneInto(e) {
+		e ||= new this.constructor(), e.set(...this.get());
+		let { blockLen: C, buffer: w, length: T, finished: E, destroyed: D, pos: O } = this;
+		return e.destroyed = D, e.finished = E, e.length = T, e.pos = O, T % C && e.buffer.set(w), e;
+	}
+	clone() {
+		return this._cloneInto();
+	}
+};
+const SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+	1779033703,
+	3144134277,
+	1013904242,
+	2773480762,
+	1359893119,
+	2600822924,
+	528734635,
+	1541459225
+]);
+var U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1), _32n = /* @__PURE__ */ BigInt(32);
+function fromBig(e, C = !1) {
+	return C ? {
+		h: Number(e & U32_MASK64),
+		l: Number(e >> _32n & U32_MASK64)
+	} : {
+		h: Number(e >> _32n & U32_MASK64) | 0,
+		l: Number(e & U32_MASK64) | 0
+	};
+}
+function split(e, C = !1) {
+	let w = e.length, T = new Uint32Array(w), E = new Uint32Array(w);
+	for (let D = 0; D < w; D++) {
+		let { h: w, l: O } = fromBig(e[D], C);
+		[T[D], E[D]] = [w, O];
+	}
+	return [T, E];
+}
+var rotlSH = (e, C, w) => e << w | C >>> 32 - w, rotlSL = (e, C, w) => C << w | e >>> 32 - w, rotlBH = (e, C, w) => C << w - 32 | e >>> 64 - w, rotlBL = (e, C, w) => e << w - 32 | C >>> 64 - w, SHA256_K = /* @__PURE__ */ Uint32Array.from([
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+]), SHA256_W = /* @__PURE__ */ new Uint32Array(64), SHA256 = class extends HashMD {
+	constructor(e = 32) {
+		super(64, e, 8, !1), this.A = SHA256_IV[0] | 0, this.B = SHA256_IV[1] | 0, this.C = SHA256_IV[2] | 0, this.D = SHA256_IV[3] | 0, this.E = SHA256_IV[4] | 0, this.F = SHA256_IV[5] | 0, this.G = SHA256_IV[6] | 0, this.H = SHA256_IV[7] | 0;
+	}
+	get() {
+		let { A: e, B: C, C: w, D: T, E, F: D, G: O, H: k } = this;
+		return [
+			e,
+			C,
+			w,
+			T,
+			E,
+			D,
+			O,
+			k
+		];
+	}
+	set(e, C, w, T, E, D, O, k) {
+		this.A = e | 0, this.B = C | 0, this.C = w | 0, this.D = T | 0, this.E = E | 0, this.F = D | 0, this.G = O | 0, this.H = k | 0;
+	}
+	process(e, C) {
+		for (let w = 0; w < 16; w++, C += 4) SHA256_W[w] = e.getUint32(C, !1);
+		for (let e = 16; e < 64; e++) {
+			let C = SHA256_W[e - 15], w = SHA256_W[e - 2], T = rotr(C, 7) ^ rotr(C, 18) ^ C >>> 3;
+			SHA256_W[e] = (rotr(w, 17) ^ rotr(w, 19) ^ w >>> 10) + SHA256_W[e - 7] + T + SHA256_W[e - 16] | 0;
+		}
+		let { A: w, B: T, C: E, D, E: O, F: k, G: A, H: j } = this;
+		for (let e = 0; e < 64; e++) {
+			let C = rotr(O, 6) ^ rotr(O, 11) ^ rotr(O, 25), M = j + C + Chi(O, k, A) + SHA256_K[e] + SHA256_W[e] | 0, N = (rotr(w, 2) ^ rotr(w, 13) ^ rotr(w, 22)) + Maj(w, T, E) | 0;
+			j = A, A = k, k = O, O = D + M | 0, D = E, E = T, T = w, w = M + N | 0;
+		}
+		w = w + this.A | 0, T = T + this.B | 0, E = E + this.C | 0, D = D + this.D | 0, O = O + this.E | 0, k = k + this.F | 0, A = A + this.G | 0, j = j + this.H | 0, this.set(w, T, E, D, O, k, A, j);
+	}
+	roundClean() {
+		clean(SHA256_W);
+	}
+	destroy() {
+		this.set(0, 0, 0, 0, 0, 0, 0, 0), clean(this.buffer);
+	}
+};
+const sha256$1 = /* @__PURE__ */ createHasher(() => new SHA256());
+function sha256(e, C) {
+	let w = C || "hex", T = sha256$1(isHex(e, { strict: !1 }) ? toBytes(e) : e);
+	return w === "bytes" ? T : toHex(T);
+}
+function commitmentToVersionedHash(e) {
+	let { commitment: C, version: w = 1 } = e, T = e.to ?? (typeof C == "string" ? "hex" : "bytes"), E = sha256(C, "bytes");
+	return E.set([w], 0), T === "bytes" ? E : bytesToHex(E);
+}
+function commitmentsToVersionedHashes(e) {
+	let { commitments: C, version: w } = e, T = e.to ?? (typeof C[0] == "string" ? "hex" : "bytes"), E = [];
+	for (let e of C) E.push(commitmentToVersionedHash({
+		commitment: e,
+		to: T,
+		version: w
+	}));
+	return E;
+}
+var blobsPerTransaction = 6;
+const fieldElementsPerBlob = 4096, bytesPerBlob = 32 * fieldElementsPerBlob, maxBytesPerTransaction = bytesPerBlob * blobsPerTransaction - 1 - 1 * fieldElementsPerBlob * blobsPerTransaction;
+var BlobSizeTooLargeError = class extends BaseError {
+	constructor({ maxSize: e, size: C }) {
+		super("Blob size is too large.", {
+			metaMessages: [`Max: ${e} bytes`, `Given: ${C} bytes`],
+			name: "BlobSizeTooLargeError"
+		});
+	}
+}, EmptyBlobError = class extends BaseError {
+	constructor() {
+		super("Blob data must not be empty.", { name: "EmptyBlobError" });
+	}
+}, InvalidVersionedHashSizeError = class extends BaseError {
+	constructor({ hash: e, size: C }) {
+		super(`Versioned hash "${e}" size is invalid.`, {
+			metaMessages: ["Expected: 32", `Received: ${C}`],
+			name: "InvalidVersionedHashSizeError"
+		});
+	}
+}, InvalidVersionedHashVersionError = class extends BaseError {
+	constructor({ hash: e, version: C }) {
+		super(`Versioned hash "${e}" version is invalid.`, {
+			metaMessages: ["Expected: 1", `Received: ${C}`],
+			name: "InvalidVersionedHashVersionError"
+		});
+	}
+};
+function toBlobs(e) {
+	let C = e.to ?? (typeof e.data == "string" ? "hex" : "bytes"), w = typeof e.data == "string" ? hexToBytes(e.data) : e.data, T = size(w);
+	if (!T) throw new EmptyBlobError();
+	if (T > 761855) throw new BlobSizeTooLargeError({
+		maxSize: maxBytesPerTransaction,
+		size: T
+	});
+	let E = [], D = !0, O = 0;
+	for (; D;) {
+		let e = createCursor(new Uint8Array(bytesPerBlob)), C = 0;
+		for (; C < fieldElementsPerBlob;) {
+			let T = w.slice(O, O + 31);
+			if (e.pushByte(0), e.pushBytes(T), T.length < 31) {
+				e.pushByte(128), D = !1;
+				break;
+			}
+			C++, O += 31;
+		}
+		E.push(e);
+	}
+	return C === "bytes" ? E.map((e) => e.bytes) : E.map((e) => bytesToHex(e.bytes));
+}
+function toBlobSidecars(e) {
+	let { data: C, kzg: w, to: T } = e, E = e.blobs ?? toBlobs({
+		data: C,
+		to: T
+	}), D = e.commitments ?? blobsToCommitments({
+		blobs: E,
+		kzg: w,
+		to: T
+	}), O = e.proofs ?? blobsToProofs({
+		blobs: E,
+		commitments: D,
+		kzg: w,
+		to: T
+	}), k = [];
+	for (let e = 0; e < E.length; e++) k.push({
+		blob: E[e],
+		commitment: D[e],
+		proof: O[e]
+	});
+	return k;
+}
+var InvalidAddressError = class extends BaseError {
+	constructor({ address: e }) {
+		super(`Address "${e}" is invalid.`, {
+			metaMessages: ["- Address must be a hex value of 20 bytes (40 hex characters).", "- Address must match its checksum counterpart."],
+			name: "InvalidAddressError"
+		});
+	}
+}, InvalidChainIdError = class extends BaseError {
+	constructor({ chainId: e }) {
+		super(typeof e == "number" ? `Chain ID "${e}" is invalid.` : "Chain ID is invalid.", { name: "InvalidChainIdError" });
+	}
+}, ExecutionRevertedError = class extends BaseError {
+	constructor({ cause: e, message: C } = {}) {
+		let w = C?.replace("execution reverted: ", "")?.replace("execution reverted", "");
+		super(`Execution reverted ${w ? `with reason: ${w}` : "for an unknown reason"}.`, {
+			cause: e,
+			name: "ExecutionRevertedError"
+		});
+	}
+};
+Object.defineProperty(ExecutionRevertedError, "code", {
+	enumerable: !0,
+	configurable: !0,
+	writable: !0,
+	value: 3
+}), Object.defineProperty(ExecutionRevertedError, "nodeMessage", {
+	enumerable: !0,
+	configurable: !0,
+	writable: !0,
+	value: /execution reverted|gas required exceeds allowance/
+});
+var FeeCapTooHighError = class extends BaseError {
+	constructor({ cause: e, maxFeePerGas: C } = {}) {
+		super(`The fee cap (\`maxFeePerGas\`${C ? ` = ${formatGwei(C)} gwei` : ""}) cannot be higher than the maximum allowed value (2^256-1).`, {
+			cause: e,
+			name: "FeeCapTooHighError"
+		});
+	}
+};
+Object.defineProperty(FeeCapTooHighError, "nodeMessage", {
+	enumerable: !0,
+	configurable: !0,
+	writable: !0,
+	value: /max fee per gas higher than 2\^256-1|fee cap higher than 2\^256-1/
+});
+var FeeCapTooLowError = class extends BaseError {
+	constructor({ cause: e, maxFeePerGas: C } = {}) {
+		super(`The fee cap (\`maxFeePerGas\`${C ? ` = ${formatGwei(C)}` : ""} gwei) cannot be lower than the block base fee.`, {
+			cause: e,
+			name: "FeeCapTooLowError"
+		});
+	}
+};
+Object.defineProperty(FeeCapTooLowError, "nodeMessage", {
+	enumerable: !0,
+	configurable: !0,
+	writable: !0,
+	value: /max fee per gas less than block base fee|fee cap less than block base fee|transaction is outdated/
+});
+var NonceTooHighError = class extends BaseError {
+	constructor({ cause: e, nonce: C } = {}) {
+		super(`Nonce provided for the transaction ${C ? `(${C}) ` : ""}is higher than the next one expected.`, {
+			cause: e,
+			name: "NonceTooHighError"
+		});
+	}
+};
+Object.defineProperty(NonceTooHighError, "nodeMessage", {
+	enumerable: !0,
+	configurable: !0,
+	writable: !0,
+	value: /nonce too high/
+});
+var NonceTooLowError = class extends BaseError {
+	constructor({ cause: e, nonce: C } = {}) {
+		super([`Nonce provided for the transaction ${C ? `(${C}) ` : ""}is lower than the current nonce of the account.`, "Try increasing the nonce or find the latest nonce with `getTransactionCount`."].join("\n"), {
+			cause: e,
+			name: "NonceTooLowError"
+		});
+	}
+};
+Object.defineProperty(NonceTooLowError, "nodeMessage", {
+	enumerable: !0,
+	configurable: !0,
+	writable: !0,
+	value: /nonce too low|transaction already imported|already known/
+});
+var NonceMaxValueError = class extends BaseError {
+	constructor({ cause: e, nonce: C } = {}) {
+		super(`Nonce provided for the transaction ${C ? `(${C}) ` : ""}exceeds the maximum allowed nonce.`, {
+			cause: e,
+			name: "NonceMaxValueError"
+		});
+	}
+};
+Object.defineProperty(NonceMaxValueError, "nodeMessage", {
+	enumerable: !0,
+	configurable: !0,
+	writable: !0,
+	value: /nonce has max value/
+});
+var InsufficientFundsError = class extends BaseError {
+	constructor({ cause: e } = {}) {
+		super(["The total cost (gas * gas fee + value) of executing this transaction exceeds the balance of the account."].join("\n"), {
+			cause: e,
+			metaMessages: [
+				"This error could arise when the account does not have enough funds to:",
+				" - pay for the total gas fee,",
+				" - pay for the value to send.",
+				" ",
+				"The cost of the transaction is calculated as `gas * gas fee + value`, where:",
+				" - `gas` is the amount of gas needed for transaction to execute,",
+				" - `gas fee` is the gas fee,",
+				" - `value` is the amount of ether to send to the recipient."
+			],
+			name: "InsufficientFundsError"
+		});
+	}
+};
+Object.defineProperty(InsufficientFundsError, "nodeMessage", {
+	enumerable: !0,
+	configurable: !0,
+	writable: !0,
+	value: /insufficient funds|exceeds transaction sender account balance/
+});
+var IntrinsicGasTooHighError = class extends BaseError {
+	constructor({ cause: e, gas: C } = {}) {
+		super(`The amount of gas ${C ? `(${C}) ` : ""}provided for the transaction exceeds the limit allowed for the block.`, {
+			cause: e,
+			name: "IntrinsicGasTooHighError"
+		});
+	}
+};
+Object.defineProperty(IntrinsicGasTooHighError, "nodeMessage", {
+	enumerable: !0,
+	configurable: !0,
+	writable: !0,
+	value: /intrinsic gas too high|gas limit reached/
+});
+var IntrinsicGasTooLowError = class extends BaseError {
+	constructor({ cause: e, gas: C } = {}) {
+		super(`The amount of gas ${C ? `(${C}) ` : ""}provided for the transaction is too low.`, {
+			cause: e,
+			name: "IntrinsicGasTooLowError"
+		});
+	}
+};
+Object.defineProperty(IntrinsicGasTooLowError, "nodeMessage", {
+	enumerable: !0,
+	configurable: !0,
+	writable: !0,
+	value: /intrinsic gas too low/
+});
+var TransactionTypeNotSupportedError = class extends BaseError {
+	constructor({ cause: e }) {
+		super("The transaction type is not supported for this chain.", {
+			cause: e,
+			name: "TransactionTypeNotSupportedError"
+		});
+	}
+};
+Object.defineProperty(TransactionTypeNotSupportedError, "nodeMessage", {
+	enumerable: !0,
+	configurable: !0,
+	writable: !0,
+	value: /transaction type not valid/
+});
+var TipAboveFeeCapError = class extends BaseError {
+	constructor({ cause: e, maxPriorityFeePerGas: C, maxFeePerGas: w } = {}) {
+		super([`The provided tip (\`maxPriorityFeePerGas\`${C ? ` = ${formatGwei(C)} gwei` : ""}) cannot be higher than the fee cap (\`maxFeePerGas\`${w ? ` = ${formatGwei(w)} gwei` : ""}).`].join("\n"), {
+			cause: e,
+			name: "TipAboveFeeCapError"
+		});
+	}
+};
+Object.defineProperty(TipAboveFeeCapError, "nodeMessage", {
+	enumerable: !0,
+	configurable: !0,
+	writable: !0,
+	value: /max priority fee per gas higher than max fee per gas|tip higher than fee cap/
+});
+var LruMap = class extends Map {
+	constructor(e) {
+		super(), Object.defineProperty(this, "maxSize", {
+			enumerable: !0,
+			configurable: !0,
+			writable: !0,
+			value: void 0
+		}), this.maxSize = e;
+	}
+	get(e) {
+		let C = super.get(e);
+		return super.has(e) && C !== void 0 && (this.delete(e), super.set(e, C)), C;
+	}
+	set(e, C) {
+		if (super.set(e, C), this.maxSize && this.size > this.maxSize) {
+			let e = this.keys().next().value;
+			e && this.delete(e);
+		}
+		return this;
+	}
+}, _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _7n = BigInt(7), _256n = BigInt(256), _0x71n = BigInt(113), SHA3_PI = [], SHA3_ROTL = [], _SHA3_IOTA = [];
+for (let e = 0, C = _1n, w = 1, T = 0; e < 24; e++) {
+	[w, T] = [T, (2 * w + 3 * T) % 5], SHA3_PI.push(2 * (5 * T + w)), SHA3_ROTL.push((e + 1) * (e + 2) / 2 % 64);
+	let E = _0n;
+	for (let e = 0; e < 7; e++) C = (C << _1n ^ (C >> _7n) * _0x71n) % _256n, C & _2n && (E ^= _1n << (_1n << /* @__PURE__ */ BigInt(e)) - _1n);
+	_SHA3_IOTA.push(E);
+}
+var IOTAS = split(_SHA3_IOTA, !0), SHA3_IOTA_H = IOTAS[0], SHA3_IOTA_L = IOTAS[1], rotlH = (e, C, w) => w > 32 ? rotlBH(e, C, w) : rotlSH(e, C, w), rotlL = (e, C, w) => w > 32 ? rotlBL(e, C, w) : rotlSL(e, C, w);
+function keccakP(e, C = 24) {
+	let w = new Uint32Array(10);
+	for (let T = 24 - C; T < 24; T++) {
+		for (let C = 0; C < 10; C++) w[C] = e[C] ^ e[C + 10] ^ e[C + 20] ^ e[C + 30] ^ e[C + 40];
+		for (let C = 0; C < 10; C += 2) {
+			let T = (C + 8) % 10, E = (C + 2) % 10, D = w[E], O = w[E + 1], k = rotlH(D, O, 1) ^ w[T], A = rotlL(D, O, 1) ^ w[T + 1];
+			for (let w = 0; w < 50; w += 10) e[C + w] ^= k, e[C + w + 1] ^= A;
+		}
+		let C = e[2], E = e[3];
+		for (let w = 0; w < 24; w++) {
+			let T = SHA3_ROTL[w], D = rotlH(C, E, T), O = rotlL(C, E, T), k = SHA3_PI[w];
+			C = e[k], E = e[k + 1], e[k] = D, e[k + 1] = O;
+		}
+		for (let C = 0; C < 50; C += 10) {
+			for (let T = 0; T < 10; T++) w[T] = e[C + T];
+			for (let T = 0; T < 10; T++) e[C + T] ^= ~w[(T + 2) % 10] & w[(T + 4) % 10];
+		}
+		e[0] ^= SHA3_IOTA_H[T], e[1] ^= SHA3_IOTA_L[T];
+	}
+	clean(w);
+}
+var Keccak = class e extends Hash {
+	constructor(e, C, w, T = !1, E = 24) {
+		if (super(), this.pos = 0, this.posOut = 0, this.finished = !1, this.destroyed = !1, this.enableXOF = !1, this.blockLen = e, this.suffix = C, this.outputLen = w, this.enableXOF = T, this.rounds = E, anumber(w), !(0 < e && e < 200)) throw Error("only keccak-f1600 function is supported");
+		this.state = new Uint8Array(200), this.state32 = u32(this.state);
+	}
+	clone() {
+		return this._cloneInto();
+	}
+	keccak() {
+		swap32IfBE(this.state32), keccakP(this.state32, this.rounds), swap32IfBE(this.state32), this.posOut = 0, this.pos = 0;
+	}
+	update(e) {
+		aexists(this), e = toBytes$1(e), abytes(e);
+		let { blockLen: C, state: w } = this, T = e.length;
+		for (let E = 0; E < T;) {
+			let D = Math.min(C - this.pos, T - E);
+			for (let C = 0; C < D; C++) w[this.pos++] ^= e[E++];
+			this.pos === C && this.keccak();
+		}
+		return this;
+	}
+	finish() {
+		if (this.finished) return;
+		this.finished = !0;
+		let { state: e, suffix: C, pos: w, blockLen: T } = this;
+		e[w] ^= C, C & 128 && w === T - 1 && this.keccak(), e[T - 1] ^= 128, this.keccak();
+	}
+	writeInto(e) {
+		aexists(this, !1), abytes(e), this.finish();
+		let C = this.state, { blockLen: w } = this;
+		for (let T = 0, E = e.length; T < E;) {
+			this.posOut >= w && this.keccak();
+			let D = Math.min(w - this.posOut, E - T);
+			e.set(C.subarray(this.posOut, this.posOut + D), T), this.posOut += D, T += D;
+		}
+		return e;
+	}
+	xofInto(e) {
+		if (!this.enableXOF) throw Error("XOF is not possible for this instance");
+		return this.writeInto(e);
+	}
+	xof(e) {
+		return anumber(e), this.xofInto(new Uint8Array(e));
+	}
+	digestInto(e) {
+		if (aoutput(e, this), this.finished) throw Error("digest() was already called");
+		return this.writeInto(e), this.destroy(), e;
+	}
+	digest() {
+		return this.digestInto(new Uint8Array(this.outputLen));
+	}
+	destroy() {
+		this.destroyed = !0, clean(this.state);
+	}
+	_cloneInto(C) {
+		let { blockLen: w, suffix: T, outputLen: E, rounds: D, enableXOF: O } = this;
+		return C ||= new e(w, T, E, O, D), C.state32.set(this.state32), C.pos = this.pos, C.posOut = this.posOut, C.finished = this.finished, C.rounds = D, C.suffix = T, C.outputLen = E, C.enableXOF = O, C.destroyed = this.destroyed, C;
+	}
+}, gen = (e, C, w) => createHasher(() => new Keccak(C, e, w));
+const keccak_256 = /* @__PURE__ */ (() => gen(1, 136, 256 / 8))();
+function keccak256(e, C) {
+	let w = C || "hex", T = keccak_256(isHex(e, { strict: !1 }) ? toBytes(e) : e);
+	return w === "bytes" ? T : toHex(T);
+}
+var checksumAddressCache = /* @__PURE__ */ new LruMap(8192);
+function checksumAddress(e, C) {
+	if (checksumAddressCache.has(`${e}.${C}`)) return checksumAddressCache.get(`${e}.${C}`);
+	let w = C ? `${C}${e.toLowerCase()}` : e.substring(2).toLowerCase(), T = keccak256(stringToBytes(w), "bytes"), E = (C ? w.substring(`${C}0x`.length) : w).split("");
+	for (let e = 0; e < 40; e += 2) T[e >> 1] >> 4 >= 8 && E[e] && (E[e] = E[e].toUpperCase()), (T[e >> 1] & 15) >= 8 && E[e + 1] && (E[e + 1] = E[e + 1].toUpperCase());
+	let D = `0x${E.join("")}`;
+	return checksumAddressCache.set(`${e}.${C}`, D), D;
+}
+var addressRegex = /^0x[a-fA-F0-9]{40}$/;
+const isAddressCache = /* @__PURE__ */ new LruMap(8192);
+function isAddress(e, C) {
+	let { strict: w = !0 } = C ?? {}, T = `${e}.${w}`;
+	if (isAddressCache.has(T)) return isAddressCache.get(T);
+	let E = (() => addressRegex.test(e) ? e.toLowerCase() === e ? !0 : w ? checksumAddress(e) === e : !0 : !1)();
+	return isAddressCache.set(T, E), E;
+}
+function slice(e, C, w, { strict: T } = {}) {
+	return isHex(e, { strict: !1 }) ? sliceHex(e, C, w, { strict: T }) : sliceBytes(e, C, w, { strict: T });
+}
+function assertStartOffset(e, C) {
+	if (typeof C == "number" && C > 0 && C > size(e) - 1) throw new SliceOffsetOutOfBoundsError({
+		offset: C,
+		position: "start",
+		size: size(e)
+	});
+}
+function assertEndOffset(e, C, w) {
+	if (typeof C == "number" && typeof w == "number" && size(e) !== w - C) throw new SliceOffsetOutOfBoundsError({
+		offset: w,
+		position: "end",
+		size: size(e)
+	});
+}
+function sliceBytes(e, C, w, { strict: T } = {}) {
+	assertStartOffset(e, C);
+	let E = e.slice(C, w);
+	return T && assertEndOffset(E, C, w), E;
+}
+function sliceHex(e, C, w, { strict: T } = {}) {
+	assertStartOffset(e, C);
+	let E = `0x${e.replace("0x", "").slice((C ?? 0) * 2, (w ?? e.length) * 2)}`;
+	return T && assertEndOffset(E, C, w), E;
+}
+function assertTransactionEIP7702(e) {
+	let { authorizationList: C } = e;
+	if (C) for (let e of C) {
+		let { chainId: C } = e, w = e.address;
+		if (!isAddress(w)) throw new InvalidAddressError({ address: w });
+		if (C < 0) throw new InvalidChainIdError({ chainId: C });
+	}
+	assertTransactionEIP1559(e);
+}
+function assertTransactionEIP4844(e) {
+	let { blobVersionedHashes: C } = e;
+	if (C) {
+		if (C.length === 0) throw new EmptyBlobError();
+		for (let e of C) {
+			let C = size(e), w = hexToNumber(slice(e, 0, 1));
+			if (C !== 32) throw new InvalidVersionedHashSizeError({
+				hash: e,
+				size: C
+			});
+			if (w !== 1) throw new InvalidVersionedHashVersionError({
+				hash: e,
+				version: w
+			});
+		}
+	}
+	assertTransactionEIP1559(e);
+}
+function assertTransactionEIP1559(e) {
+	let { chainId: C, maxPriorityFeePerGas: w, maxFeePerGas: T, to: E } = e;
+	if (C <= 0) throw new InvalidChainIdError({ chainId: C });
+	if (E && !isAddress(E)) throw new InvalidAddressError({ address: E });
+	if (T && T > maxUint256) throw new FeeCapTooHighError({ maxFeePerGas: T });
+	if (w && T && w > T) throw new TipAboveFeeCapError({
+		maxFeePerGas: T,
+		maxPriorityFeePerGas: w
+	});
+}
+function assertTransactionEIP2930(e) {
+	let { chainId: C, maxPriorityFeePerGas: w, gasPrice: T, maxFeePerGas: E, to: D } = e;
+	if (C <= 0) throw new InvalidChainIdError({ chainId: C });
+	if (D && !isAddress(D)) throw new InvalidAddressError({ address: D });
+	if (w || E) throw new BaseError("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid EIP-2930 Transaction attribute.");
+	if (T && T > maxUint256) throw new FeeCapTooHighError({ maxFeePerGas: T });
+}
+function assertTransactionLegacy(e) {
+	let { chainId: C, maxPriorityFeePerGas: w, gasPrice: T, maxFeePerGas: E, to: D } = e;
+	if (D && !isAddress(D)) throw new InvalidAddressError({ address: D });
+	if (C !== void 0 && C <= 0) throw new InvalidChainIdError({ chainId: C });
+	if (w || E) throw new BaseError("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid Legacy Transaction attribute.");
+	if (T && T > maxUint256) throw new FeeCapTooHighError({ maxFeePerGas: T });
+}
+function getTransactionType(e) {
+	if (e.type) return e.type;
+	if (e.authorizationList !== void 0) return "eip7702";
+	if (e.blobs !== void 0 || e.blobVersionedHashes !== void 0 || e.maxFeePerBlobGas !== void 0 || e.sidecars !== void 0) return "eip4844";
+	if (e.maxFeePerGas !== void 0 || e.maxPriorityFeePerGas !== void 0) return "eip1559";
+	if (e.gasPrice !== void 0) return e.accessList === void 0 ? "legacy" : "eip2930";
+	throw new InvalidSerializableTransactionError({ transaction: e });
+}
+function serializeAccessList(e) {
+	if (!e || e.length === 0) return [];
+	let C = [];
+	for (let w = 0; w < e.length; w++) {
+		let { address: T, storageKeys: E } = e[w];
+		for (let e = 0; e < E.length; e++) if (E[e].length - 2 != 64) throw new InvalidStorageKeySizeError({ storageKey: E[e] });
+		if (!isAddress(T, { strict: !1 })) throw new InvalidAddressError({ address: T });
+		C.push([T, E]);
+	}
+	return C;
+}
+function serializeTransaction(e, C) {
+	let w = getTransactionType(e);
+	return w === "eip1559" ? serializeTransactionEIP1559(e, C) : w === "eip2930" ? serializeTransactionEIP2930(e, C) : w === "eip4844" ? serializeTransactionEIP4844(e, C) : w === "eip7702" ? serializeTransactionEIP7702(e, C) : serializeTransactionLegacy(e, C);
+}
+function serializeTransactionEIP7702(e, C) {
+	let { authorizationList: w, chainId: T, gas: E, nonce: D, to: O, value: k, maxFeePerGas: A, maxPriorityFeePerGas: j, accessList: M, data: N } = e;
+	assertTransactionEIP7702(e);
+	let P = serializeAccessList(M), F = serializeAuthorizationList(w);
+	return concatHex(["0x04", toRlp([
+		numberToHex(T),
+		D ? numberToHex(D) : "0x",
+		j ? numberToHex(j) : "0x",
+		A ? numberToHex(A) : "0x",
+		E ? numberToHex(E) : "0x",
+		O ?? "0x",
+		k ? numberToHex(k) : "0x",
+		N ?? "0x",
+		P,
+		F,
+		...toYParitySignatureArray(e, C)
+	])]);
+}
+function serializeTransactionEIP4844(e, C) {
+	let { chainId: w, gas: T, nonce: E, to: D, value: O, maxFeePerBlobGas: k, maxFeePerGas: A, maxPriorityFeePerGas: j, accessList: M, data: N } = e;
+	assertTransactionEIP4844(e);
+	let P = e.blobVersionedHashes, F = e.sidecars;
+	if (e.blobs && (P === void 0 || F === void 0)) {
+		let C = typeof e.blobs[0] == "string" ? e.blobs : e.blobs.map((e) => bytesToHex(e)), w = e.kzg, T = blobsToCommitments({
+			blobs: C,
+			kzg: w
+		});
+		P === void 0 && (P = commitmentsToVersionedHashes({ commitments: T })), F === void 0 && (F = toBlobSidecars({
+			blobs: C,
+			commitments: T,
+			proofs: blobsToProofs({
+				blobs: C,
+				commitments: T,
+				kzg: w
+			})
+		}));
+	}
+	let I = serializeAccessList(M), L = [
+		numberToHex(w),
+		E ? numberToHex(E) : "0x",
+		j ? numberToHex(j) : "0x",
+		A ? numberToHex(A) : "0x",
+		T ? numberToHex(T) : "0x",
+		D ?? "0x",
+		O ? numberToHex(O) : "0x",
+		N ?? "0x",
+		I,
+		k ? numberToHex(k) : "0x",
+		P ?? [],
+		...toYParitySignatureArray(e, C)
+	], R = [], z = [], B = [];
+	if (F) for (let e = 0; e < F.length; e++) {
+		let { blob: C, commitment: w, proof: T } = F[e];
+		R.push(C), z.push(w), B.push(T);
+	}
+	return concatHex(["0x03", toRlp(F ? [
+		L,
+		R,
+		z,
+		B
+	] : L)]);
+}
+function serializeTransactionEIP1559(e, C) {
+	let { chainId: w, gas: T, nonce: E, to: D, value: O, maxFeePerGas: k, maxPriorityFeePerGas: A, accessList: j, data: M } = e;
+	assertTransactionEIP1559(e);
+	let N = serializeAccessList(j);
+	return concatHex(["0x02", toRlp([
+		numberToHex(w),
+		E ? numberToHex(E) : "0x",
+		A ? numberToHex(A) : "0x",
+		k ? numberToHex(k) : "0x",
+		T ? numberToHex(T) : "0x",
+		D ?? "0x",
+		O ? numberToHex(O) : "0x",
+		M ?? "0x",
+		N,
+		...toYParitySignatureArray(e, C)
+	])]);
+}
+function serializeTransactionEIP2930(e, C) {
+	let { chainId: w, gas: T, data: E, nonce: D, to: O, value: k, accessList: A, gasPrice: j } = e;
+	assertTransactionEIP2930(e);
+	let M = serializeAccessList(A);
+	return concatHex(["0x01", toRlp([
+		numberToHex(w),
+		D ? numberToHex(D) : "0x",
+		j ? numberToHex(j) : "0x",
+		T ? numberToHex(T) : "0x",
+		O ?? "0x",
+		k ? numberToHex(k) : "0x",
+		E ?? "0x",
+		M,
+		...toYParitySignatureArray(e, C)
+	])]);
+}
+function serializeTransactionLegacy(e, C) {
+	let { chainId: w = 0, gas: T, data: E, nonce: D, to: O, value: k, gasPrice: A } = e;
+	assertTransactionLegacy(e);
+	let j = [
+		D ? numberToHex(D) : "0x",
+		A ? numberToHex(A) : "0x",
+		T ? numberToHex(T) : "0x",
+		O ?? "0x",
+		k ? numberToHex(k) : "0x",
+		E ?? "0x"
+	];
+	if (C) {
+		let e = (() => {
+			if (C.v >= 35n) return (C.v - 35n) / 2n > 0 ? C.v : 27n + (C.v === 35n ? 0n : 1n);
+			if (w > 0) return BigInt(w * 2) + BigInt(35n + C.v - 27n);
+			let e = 27n + (C.v === 27n ? 0n : 1n);
+			if (C.v !== e) throw new InvalidLegacyVError({ v: C.v });
+			return e;
+		})(), T = trim(C.r), E = trim(C.s);
+		j = [
+			...j,
+			numberToHex(e),
+			T === "0x00" ? "0x" : T,
+			E === "0x00" ? "0x" : E
+		];
+	} else w > 0 && (j = [
+		...j,
+		numberToHex(w),
+		"0x",
+		"0x"
+	]);
+	return toRlp(j);
+}
+function toYParitySignatureArray(e, C) {
+	let w = C ?? e, { v: T, yParity: E } = w;
+	if (w.r === void 0 || w.s === void 0 || T === void 0 && E === void 0) return [];
+	let D = trim(w.r), O = trim(w.s);
+	return [
+		(() => typeof E == "number" ? E ? numberToHex(1) : "0x" : T === 0n ? "0x" : T === 1n ? numberToHex(1) : T === 27n ? "0x" : numberToHex(1))(),
+		D === "0x00" ? "0x" : D,
+		O === "0x00" ? "0x" : O
+	];
+}
+const contracts = {
+	gasPriceOracle: { address: "0x420000000000000000000000000000000000000F" },
+	l1Block: { address: "0x4200000000000000000000000000000000000015" },
+	l2CrossDomainMessenger: { address: "0x4200000000000000000000000000000000000007" },
+	l2Erc721Bridge: { address: "0x4200000000000000000000000000000000000014" },
+	l2StandardBridge: { address: "0x4200000000000000000000000000000000000010" },
+	l2ToL1MessagePasser: { address: "0x4200000000000000000000000000000000000016" }
+}, formatters = {
+	block: /* @__PURE__ */ defineBlock({ format(e) {
+		return {
+			transactions: e.transactions?.map((e) => {
+				if (typeof e == "string") return e;
+				let C = formatTransaction(e);
+				return C.typeHex === "0x7e" && (C.isSystemTx = e.isSystemTx, C.mint = e.mint ? hexToBigInt(e.mint) : void 0, C.sourceHash = e.sourceHash, C.type = "deposit"), C;
+			}),
+			stateRoot: e.stateRoot
+		};
+	} }),
+	transaction: /* @__PURE__ */ defineTransaction({ format(e) {
+		let C = {};
+		return e.type === "0x7e" && (C.isSystemTx = e.isSystemTx, C.mint = e.mint ? hexToBigInt(e.mint) : void 0, C.sourceHash = e.sourceHash, C.type = "deposit"), C;
+	} }),
+	transactionReceipt: /* @__PURE__ */ defineTransactionReceipt({ format(e) {
+		return {
+			l1GasPrice: e.l1GasPrice ? hexToBigInt(e.l1GasPrice) : null,
+			l1GasUsed: e.l1GasUsed ? hexToBigInt(e.l1GasUsed) : null,
+			l1Fee: e.l1Fee ? hexToBigInt(e.l1Fee) : null,
+			l1FeeScalar: e.l1FeeScalar ? Number(e.l1FeeScalar) : null
+		};
+	} })
+};
+function serializeTransaction$1(e, C) {
+	return isDeposit(e) ? serializeTransactionDeposit(e) : serializeTransaction(e, C);
+}
+const serializers = { transaction: serializeTransaction$1 };
+function serializeTransactionDeposit(e) {
+	assertTransactionDeposit(e);
+	let { sourceHash: C, data: w, from: T, gas: E, isSystemTx: D, mint: O, to: k, value: A } = e;
+	return concatHex(["0x7e", toRlp([
+		C,
+		T,
+		k ?? "0x",
+		O ? toHex(O) : "0x",
+		A ? toHex(A) : "0x",
+		E ? toHex(E) : "0x",
+		D ? "0x1" : "0x",
+		w ?? "0x"
+	])]);
+}
+function isDeposit(e) {
+	return e.type === "deposit" || e.sourceHash !== void 0;
+}
+function assertTransactionDeposit(e) {
+	let { from: C, to: w } = e;
+	if (C && !isAddress(C)) throw new InvalidAddressError({ address: C });
+	if (w && !isAddress(w)) throw new InvalidAddressError({ address: w });
+}
+const chainConfig = {
+	blockTime: 2e3,
+	contracts,
+	formatters,
+	serializers
+}, arbitrum = /* @__PURE__ */ defineChain({
+	id: 42161,
+	name: "Arbitrum One",
+	nativeCurrency: {
+		name: "Ether",
+		symbol: "ETH",
+		decimals: 18
+	},
+	blockTime: 250,
+	rpcUrls: { default: { http: ["https://arb1.arbitrum.io/rpc"] } },
+	blockExplorers: { default: {
+		name: "Arbiscan",
+		url: "https://arbiscan.io",
+		apiUrl: "https://api.arbiscan.io/api"
+	} },
+	contracts: { multicall3: {
+		address: "0xca11bde05977b3631167028862be2a173976ca11",
+		blockCreated: 7654707
+	} }
+});
+var sourceId$1 = 1;
+const base = /* @__PURE__ */ defineChain({
+	...chainConfig,
+	id: 8453,
+	name: "Base",
+	nativeCurrency: {
+		name: "Ether",
+		symbol: "ETH",
+		decimals: 18
+	},
+	rpcUrls: { default: { http: ["https://mainnet.base.org"] } },
+	blockExplorers: { default: {
+		name: "Basescan",
+		url: "https://basescan.org",
+		apiUrl: "https://api.basescan.org/api"
+	} },
+	contracts: {
+		...chainConfig.contracts,
+		disputeGameFactory: { [sourceId$1]: { address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e" } },
+		l2OutputOracle: { [sourceId$1]: { address: "0x56315b90c40730925ec5485cf004d835058518A0" } },
+		multicall3: {
+			address: "0xca11bde05977b3631167028862be2a173976ca11",
+			blockCreated: 5022
+		},
+		portal: { [sourceId$1]: {
+			address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e",
+			blockCreated: 17482143
+		} },
+		l1StandardBridge: { [sourceId$1]: {
+			address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35",
+			blockCreated: 17482143
+		} }
+	},
+	sourceId: sourceId$1
+});
+({ ...base });
+const bsc = /* @__PURE__ */ defineChain({
+	id: 56,
+	name: "BNB Smart Chain",
+	blockTime: 750,
+	nativeCurrency: {
+		decimals: 18,
+		name: "BNB",
+		symbol: "BNB"
+	},
+	rpcUrls: { default: { http: ["https://56.rpc.thirdweb.com"] } },
+	blockExplorers: { default: {
+		name: "BscScan",
+		url: "https://bscscan.com",
+		apiUrl: "https://api.bscscan.com/api"
+	} },
+	contracts: { multicall3: {
+		address: "0xca11bde05977b3631167028862be2a173976ca11",
+		blockCreated: 15921452
+	} }
+}), mainnet = /* @__PURE__ */ defineChain({
+	id: 1,
+	name: "Ethereum",
+	nativeCurrency: {
+		name: "Ether",
+		symbol: "ETH",
+		decimals: 18
+	},
+	blockTime: 12e3,
+	rpcUrls: { default: { http: ["https://eth.merkle.io"] } },
+	blockExplorers: { default: {
+		name: "Etherscan",
+		url: "https://etherscan.io",
+		apiUrl: "https://api.etherscan.io/api"
+	} },
+	contracts: {
+		ensUniversalResolver: {
+			address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee",
+			blockCreated: 23085558
+		},
+		multicall3: {
+			address: "0xca11bde05977b3631167028862be2a173976ca11",
+			blockCreated: 14353601
+		}
+	}
+});
+var sourceId = 1;
+const optimism = /* @__PURE__ */ defineChain({
+	...chainConfig,
+	id: 10,
+	name: "OP Mainnet",
+	nativeCurrency: {
+		name: "Ether",
+		symbol: "ETH",
+		decimals: 18
+	},
+	rpcUrls: { default: { http: ["https://mainnet.optimism.io"] } },
+	blockExplorers: { default: {
+		name: "Optimism Explorer",
+		url: "https://optimistic.etherscan.io",
+		apiUrl: "https://api-optimistic.etherscan.io/api"
+	} },
+	contracts: {
+		...chainConfig.contracts,
+		disputeGameFactory: { [sourceId]: { address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9" } },
+		l2OutputOracle: { [sourceId]: { address: "0xdfe97868233d1aa22e815a266982f2cf17685a27" } },
+		multicall3: {
+			address: "0xca11bde05977b3631167028862be2a173976ca11",
+			blockCreated: 4286263
+		},
+		portal: { [sourceId]: { address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed" } },
+		l1StandardBridge: { [sourceId]: { address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1" } }
+	},
+	sourceId
+}), polygon = /* @__PURE__ */ defineChain({
+	id: 137,
+	name: "Polygon",
+	blockTime: 2e3,
+	nativeCurrency: {
+		name: "POL",
+		symbol: "POL",
+		decimals: 18
+	},
+	rpcUrls: { default: { http: ["https://polygon-rpc.com"] } },
+	blockExplorers: { default: {
+		name: "PolygonScan",
+		url: "https://polygonscan.com",
+		apiUrl: "https://api.etherscan.io/v2/api"
+	} },
+	contracts: { multicall3: {
+		address: "0xca11bde05977b3631167028862be2a173976ca11",
+		blockCreated: 25770160
+	} }
+});
+export { __toESM as _, base as a, tap as c, expand as d, require_browser as f, __require as g, __commonJSMin as h, bsc as i, switchMap as l, payment_dialog_default as m, optimism as n, arbitrum as o, injectStyle as p, mainnet as r, timeout as s, polygon as t, retry as u };