useblocks 1.1.60 → 1.1.64

package/static/core/b165c6f6.js

@@ -0,0 +1,1241 @@
+__useblocks__.define("static/core/b165c6f6.js", [
+	"require",
+	"exports",
+	"module",
+	"static/core/63b7b25e.js",
+	"static/core/8460710a.js"
+], function(O, G, Nt) {
+	O("./63b7b25e.js");
+	const P = O("./8460710a.js");
+	var tt = P.o(((i, s) => {
+		s.exports = function() {
+			return typeof Promise == "function" && Promise.prototype && Promise.prototype.then;
+		};
+	})), _ = P.o(((i) => {
+		var s, a = [
+			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
+		];
+		i.getSymbolSize = function(r) {
+			if (!r) throw Error("\"version\" cannot be null or undefined");
+			if (r < 1 || r > 40) throw Error("\"version\" should be in range from 1 to 40");
+			return r * 4 + 17;
+		}, i.getSymbolTotalCodewords = function(r) {
+			return a[r];
+		}, i.getBCHDigit = function(r) {
+			let t = 0;
+			for (; r !== 0;) t++, r >>>= 1;
+			return t;
+		}, i.setToSJISFunction = function(r) {
+			if (typeof r != "function") throw Error("\"toSJISFunc\" is not a valid function.");
+			s = r;
+		}, i.isKanjiModeEnabled = function() {
+			return s !== void 0;
+		}, i.toSJIS = function(r) {
+			return s(r);
+		};
+	})), H = P.o(((i) => {
+		i.L = { bit: 1 }, i.M = { bit: 0 }, i.Q = { bit: 3 }, i.H = { bit: 2 };
+		function s(a) {
+			if (typeof a != "string") throw Error("Param is not a string");
+			switch (a.toLowerCase()) {
+				case "l":
+				case "low": return i.L;
+				case "m":
+				case "medium": return i.M;
+				case "q":
+				case "quartile": return i.Q;
+				case "h":
+				case "high": return i.H;
+				default: throw Error("Unknown EC Level: " + a);
+			}
+		}
+		i.isValid = function(a) {
+			return a && a.bit !== void 0 && a.bit >= 0 && a.bit < 4;
+		}, i.from = function(a, r) {
+			if (i.isValid(a)) return a;
+			try {
+				return s(a);
+			} catch {
+				return r;
+			}
+		};
+	})), rt = P.o(((i, s) => {
+		function a() {
+			this.buffer = [], this.length = 0;
+		}
+		a.prototype = {
+			get: function(r) {
+				let t = Math.floor(r / 8);
+				return (this.buffer[t] >>> 7 - r % 8 & 1) == 1;
+			},
+			put: function(r, t) {
+				for (let e = 0; e < t; e++) this.putBit((r >>> t - e - 1 & 1) == 1);
+			},
+			getLengthInBits: function() {
+				return this.length;
+			},
+			putBit: function(r) {
+				let t = Math.floor(this.length / 8);
+				this.buffer.length <= t && this.buffer.push(0), r && (this.buffer[t] |= 128 >>> this.length % 8), this.length++;
+			}
+		}, s.exports = a;
+	})), et = P.o(((i, s) => {
+		function a(r) {
+			if (!r || r < 1) throw Error("BitMatrix size must be defined and greater than 0");
+			this.size = r, this.data = new Uint8Array(r * r), this.reservedBit = new Uint8Array(r * r);
+		}
+		a.prototype.set = function(r, t, e, n) {
+			let o = r * this.size + t;
+			this.data[o] = e, n && (this.reservedBit[o] = !0);
+		}, a.prototype.get = function(r, t) {
+			return this.data[r * this.size + t];
+		}, a.prototype.xor = function(r, t, e) {
+			this.data[r * this.size + t] ^= e;
+		}, a.prototype.isReserved = function(r, t) {
+			return this.reservedBit[r * this.size + t];
+		}, s.exports = a;
+	})), nt = P.o(((i) => {
+		var s = _().getSymbolSize;
+		i.getRowColCoords = function(a) {
+			if (a === 1) return [];
+			let r = Math.floor(a / 7) + 2, t = s(a), e = t === 145 ? 26 : Math.ceil((t - 13) / (2 * r - 2)) * 2, n = [t - 7];
+			for (let o = 1; o < r - 1; o++) n[o] = n[o - 1] - e;
+			return n.push(6), n.reverse();
+		}, i.getPositions = function(a) {
+			let r = [], t = i.getRowColCoords(a), e = t.length;
+			for (let n = 0; n < e; n++) for (let o = 0; o < e; o++) n === 0 && o === 0 || n === 0 && o === e - 1 || n === e - 1 && o === 0 || r.push([t[n], t[o]]);
+			return r;
+		};
+	})), ot = P.o(((i) => {
+		var s = _().getSymbolSize, a = 7;
+		i.getPositions = function(r) {
+			let t = s(r);
+			return [
+				[0, 0],
+				[t - a, 0],
+				[0, t - a]
+			];
+		};
+	})), it = P.o(((i) => {
+		i.Patterns = {
+			PATTERN000: 0,
+			PATTERN001: 1,
+			PATTERN010: 2,
+			PATTERN011: 3,
+			PATTERN100: 4,
+			PATTERN101: 5,
+			PATTERN110: 6,
+			PATTERN111: 7
+		};
+		var s = {
+			N1: 3,
+			N2: 3,
+			N3: 40,
+			N4: 10
+		};
+		i.isValid = function(r) {
+			return r != null && r !== "" && !isNaN(r) && r >= 0 && r <= 7;
+		}, i.from = function(r) {
+			return i.isValid(r) ? parseInt(r, 10) : void 0;
+		}, i.getPenaltyN1 = function(r) {
+			let t = r.size, e = 0, n = 0, o = 0, u = null, c = null;
+			for (let E = 0; E < t; E++) {
+				n = o = 0, u = c = null;
+				for (let y = 0; y < t; y++) {
+					let l = r.get(E, y);
+					l === u ? n++ : (n >= 5 && (e += s.N1 + (n - 5)), u = l, n = 1), l = r.get(y, E), l === c ? o++ : (o >= 5 && (e += s.N1 + (o - 5)), c = l, o = 1);
+				}
+				n >= 5 && (e += s.N1 + (n - 5)), o >= 5 && (e += s.N1 + (o - 5));
+			}
+			return e;
+		}, i.getPenaltyN2 = function(r) {
+			let t = r.size, e = 0;
+			for (let n = 0; n < t - 1; n++) for (let o = 0; o < t - 1; o++) {
+				let u = r.get(n, o) + r.get(n, o + 1) + r.get(n + 1, o) + r.get(n + 1, o + 1);
+				(u === 4 || u === 0) && e++;
+			}
+			return e * s.N2;
+		}, i.getPenaltyN3 = function(r) {
+			let t = r.size, e = 0, n = 0, o = 0;
+			for (let u = 0; u < t; u++) {
+				n = o = 0;
+				for (let c = 0; c < t; c++) n = n << 1 & 2047 | r.get(u, c), c >= 10 && (n === 1488 || n === 93) && e++, o = o << 1 & 2047 | r.get(c, u), c >= 10 && (o === 1488 || o === 93) && e++;
+			}
+			return e * s.N3;
+		}, i.getPenaltyN4 = function(r) {
+			let t = 0, e = r.data.length;
+			for (let n = 0; n < e; n++) t += r.data[n];
+			return Math.abs(Math.ceil(t * 100 / e / 5) - 10) * s.N4;
+		};
+		function a(r, t, e) {
+			switch (r) {
+				case i.Patterns.PATTERN000: return (t + e) % 2 == 0;
+				case i.Patterns.PATTERN001: return t % 2 == 0;
+				case i.Patterns.PATTERN010: return e % 3 == 0;
+				case i.Patterns.PATTERN011: return (t + e) % 3 == 0;
+				case i.Patterns.PATTERN100: return (Math.floor(t / 2) + Math.floor(e / 3)) % 2 == 0;
+				case i.Patterns.PATTERN101: return t * e % 2 + t * e % 3 == 0;
+				case i.Patterns.PATTERN110: return (t * e % 2 + t * e % 3) % 2 == 0;
+				case i.Patterns.PATTERN111: return (t * e % 3 + (t + e) % 2) % 2 == 0;
+				default: throw Error("bad maskPattern:" + r);
+			}
+		}
+		i.applyMask = function(r, t) {
+			let e = t.size;
+			for (let n = 0; n < e; n++) for (let o = 0; o < e; o++) t.isReserved(o, n) || t.xor(o, n, a(r, o, n));
+		}, i.getBestMask = function(r, t) {
+			let e = Object.keys(i.Patterns).length, n = 0, o = Infinity;
+			for (let u = 0; u < e; u++) {
+				t(u), i.applyMask(u, r);
+				let c = i.getPenaltyN1(r) + i.getPenaltyN2(r) + i.getPenaltyN3(r) + i.getPenaltyN4(r);
+				i.applyMask(u, r), c < o && (o = c, n = u);
+			}
+			return n;
+		};
+	})), V = P.o(((i) => {
+		var s = H(), a = [
+			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
+		], r = [
+			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
+		];
+		i.getBlocksCount = function(t, e) {
+			switch (e) {
+				case s.L: return a[(t - 1) * 4 + 0];
+				case s.M: return a[(t - 1) * 4 + 1];
+				case s.Q: return a[(t - 1) * 4 + 2];
+				case s.H: return a[(t - 1) * 4 + 3];
+				default: return;
+			}
+		}, i.getTotalCodewordsCount = function(t, e) {
+			switch (e) {
+				case s.L: return r[(t - 1) * 4 + 0];
+				case s.M: return r[(t - 1) * 4 + 1];
+				case s.Q: return r[(t - 1) * 4 + 2];
+				case s.H: return r[(t - 1) * 4 + 3];
+				default: return;
+			}
+		};
+	})), at = P.o(((i) => {
+		var s = new Uint8Array(512), a = new Uint8Array(256);
+		(function() {
+			let r = 1;
+			for (let t = 0; t < 255; t++) s[t] = r, a[r] = t, r <<= 1, r & 256 && (r ^= 285);
+			for (let t = 255; t < 512; t++) s[t] = s[t - 255];
+		})(), i.log = function(r) {
+			if (r < 1) throw Error("log(" + r + ")");
+			return a[r];
+		}, i.exp = function(r) {
+			return s[r];
+		}, i.mul = function(r, t) {
+			return r === 0 || t === 0 ? 0 : s[a[r] + a[t]];
+		};
+	})), st = P.o(((i) => {
+		var s = at();
+		i.mul = function(a, r) {
+			let t = new Uint8Array(a.length + r.length - 1);
+			for (let e = 0; e < a.length; e++) for (let n = 0; n < r.length; n++) t[e + n] ^= s.mul(a[e], r[n]);
+			return t;
+		}, i.mod = function(a, r) {
+			let t = new Uint8Array(a);
+			for (; t.length - r.length >= 0;) {
+				let e = t[0];
+				for (let o = 0; o < r.length; o++) t[o] ^= s.mul(r[o], e);
+				let n = 0;
+				for (; n < t.length && t[n] === 0;) n++;
+				t = t.slice(n);
+			}
+			return t;
+		}, i.generateECPolynomial = function(a) {
+			let r = new Uint8Array([1]);
+			for (let t = 0; t < a; t++) r = i.mul(r, new Uint8Array([1, s.exp(t)]));
+			return r;
+		};
+	})), ut = P.o(((i, s) => {
+		var a = st();
+		function r(t) {
+			this.genPoly = void 0, this.degree = t, this.degree && this.initialize(this.degree);
+		}
+		r.prototype.initialize = function(t) {
+			this.degree = t, this.genPoly = a.generateECPolynomial(this.degree);
+		}, r.prototype.encode = function(t) {
+			if (!this.genPoly) throw Error("Encoder not initialized");
+			let e = new Uint8Array(t.length + this.degree);
+			e.set(t);
+			let n = a.mod(e, this.genPoly), o = this.degree - n.length;
+			if (o > 0) {
+				let u = new Uint8Array(this.degree);
+				return u.set(n, o), u;
+			}
+			return n;
+		}, s.exports = r;
+	})), q = P.o(((i) => {
+		i.isValid = function(s) {
+			return !isNaN(s) && s >= 1 && s <= 40;
+		};
+	})), Q = P.o(((i) => {
+		var s = "[0-9]+", a = "[A-Z $%*+\\-./:]+", r = "(?:[u3000-u303F]|[u3040-u309F]|[u30A0-u30FF]|[uFF00-uFFEF]|[u4E00-u9FAF]|[u2605-u2606]|[u2190-u2195]|u203B|[u2010u2015u2018u2019u2025u2026u201Cu201Du2225u2260]|[u0391-u0451]|[u00A7u00A8u00B1u00B4u00D7u00F7])+";
+		r = r.replace(/u/g, "\\u");
+		var t = "(?:(?![A-Z0-9 $%*+\\-./:]|" + r + `)(?:.|[\r
+]))+`;
+		i.KANJI = new RegExp(r, "g"), i.BYTE_KANJI = RegExp("[^A-Z0-9 $%*+\\-./:]+", "g"), i.BYTE = new RegExp(t, "g"), i.NUMERIC = new RegExp(s, "g"), i.ALPHANUMERIC = new RegExp(a, "g");
+		var e = RegExp("^" + r + "$"), n = RegExp("^[0-9]+$"), o = RegExp("^[A-Z0-9 $%*+\\-./:]+$");
+		i.testKanji = function(u) {
+			return e.test(u);
+		}, i.testNumeric = function(u) {
+			return n.test(u);
+		}, i.testAlphanumeric = function(u) {
+			return o.test(u);
+		};
+	})), k = P.o(((i) => {
+		var s = q(), a = Q();
+		i.NUMERIC = {
+			id: "Numeric",
+			bit: 1,
+			ccBits: [
+				10,
+				12,
+				14
+			]
+		}, i.ALPHANUMERIC = {
+			id: "Alphanumeric",
+			bit: 2,
+			ccBits: [
+				9,
+				11,
+				13
+			]
+		}, i.BYTE = {
+			id: "Byte",
+			bit: 4,
+			ccBits: [
+				8,
+				16,
+				16
+			]
+		}, i.KANJI = {
+			id: "Kanji",
+			bit: 8,
+			ccBits: [
+				8,
+				10,
+				12
+			]
+		}, i.MIXED = { bit: -1 }, i.getCharCountIndicator = function(t, e) {
+			if (!t.ccBits) throw Error("Invalid mode: " + t);
+			if (!s.isValid(e)) throw Error("Invalid version: " + e);
+			return e >= 1 && e < 10 ? t.ccBits[0] : e < 27 ? t.ccBits[1] : t.ccBits[2];
+		}, i.getBestModeForData = function(t) {
+			return a.testNumeric(t) ? i.NUMERIC : a.testAlphanumeric(t) ? i.ALPHANUMERIC : a.testKanji(t) ? i.KANJI : i.BYTE;
+		}, i.toString = function(t) {
+			if (t && t.id) return t.id;
+			throw Error("Invalid mode");
+		}, i.isValid = function(t) {
+			return t && t.bit && t.ccBits;
+		};
+		function r(t) {
+			if (typeof t != "string") throw Error("Param is not a string");
+			switch (t.toLowerCase()) {
+				case "numeric": return i.NUMERIC;
+				case "alphanumeric": return i.ALPHANUMERIC;
+				case "kanji": return i.KANJI;
+				case "byte": return i.BYTE;
+				default: throw Error("Unknown mode: " + t);
+			}
+		}
+		i.from = function(t, e) {
+			if (i.isValid(t)) return t;
+			try {
+				return r(t);
+			} catch {
+				return e;
+			}
+		};
+	})), lt = P.o(((i) => {
+		var s = _(), a = V(), r = H(), t = k(), e = q(), n = 7973, o = s.getBCHDigit(n);
+		function u(l, m, v) {
+			for (let T = 1; T <= 40; T++) if (m <= i.getCapacity(T, v, l)) return T;
+		}
+		function c(l, m) {
+			return t.getCharCountIndicator(l, m) + 4;
+		}
+		function E(l, m) {
+			let v = 0;
+			return l.forEach(function(T) {
+				let x = c(T.mode, m);
+				v += x + T.getBitsLength();
+			}), v;
+		}
+		function y(l, m) {
+			for (let v = 1; v <= 40; v++) if (E(l, v) <= i.getCapacity(v, m, t.MIXED)) return v;
+		}
+		i.from = function(l, m) {
+			return e.isValid(l) ? parseInt(l, 10) : m;
+		}, i.getCapacity = function(l, m, v) {
+			if (!e.isValid(l)) throw Error("Invalid QR Code version");
+			v === void 0 && (v = t.BYTE);
+			let T = (s.getSymbolTotalCodewords(l) - a.getTotalCodewordsCount(l, m)) * 8;
+			if (v === t.MIXED) return T;
+			let x = T - c(v, l);
+			switch (v) {
+				case t.NUMERIC: return Math.floor(x / 10 * 3);
+				case t.ALPHANUMERIC: return Math.floor(x / 11 * 2);
+				case t.KANJI: return Math.floor(x / 13);
+				case t.BYTE:
+				default: return Math.floor(x / 8);
+			}
+		}, i.getBestVersionForData = function(l, m) {
+			let v, T = r.from(m, r.M);
+			if (Array.isArray(l)) {
+				if (l.length > 1) return y(l, T);
+				if (l.length === 0) return 1;
+				v = l[0];
+			} else v = l;
+			return u(v.mode, v.getLength(), T);
+		}, i.getEncodedBits = function(l) {
+			if (!e.isValid(l) || l < 7) throw Error("Invalid QR Code version");
+			let m = l << 12;
+			for (; s.getBCHDigit(m) - o >= 0;) m ^= n << s.getBCHDigit(m) - o;
+			return l << 12 | m;
+		};
+	})), ft = P.o(((i) => {
+		var s = _(), a = 1335, r = 21522, t = s.getBCHDigit(a);
+		i.getEncodedBits = function(e, n) {
+			let o = e.bit << 3 | n, u = o << 10;
+			for (; s.getBCHDigit(u) - t >= 0;) u ^= a << s.getBCHDigit(u) - t;
+			return (o << 10 | u) ^ r;
+		};
+	})), ct = P.o(((i, s) => {
+		var a = k();
+		function r(t) {
+			this.mode = a.NUMERIC, this.data = t.toString();
+		}
+		r.getBitsLength = function(t) {
+			return 10 * Math.floor(t / 3) + (t % 3 ? t % 3 * 3 + 1 : 0);
+		}, r.prototype.getLength = function() {
+			return this.data.length;
+		}, r.prototype.getBitsLength = function() {
+			return r.getBitsLength(this.data.length);
+		}, r.prototype.write = function(t) {
+			let e, n, o;
+			for (e = 0; e + 3 <= this.data.length; e += 3) n = this.data.substr(e, 3), o = parseInt(n, 10), t.put(o, 10);
+			let u = this.data.length - e;
+			u > 0 && (n = this.data.substr(e), o = parseInt(n, 10), t.put(o, u * 3 + 1));
+		}, s.exports = r;
+	})), ht = P.o(((i, s) => {
+		var a = k(), r = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:".split("");
+		function t(e) {
+			this.mode = a.ALPHANUMERIC, this.data = e;
+		}
+		t.getBitsLength = function(e) {
+			return 11 * Math.floor(e / 2) + e % 2 * 6;
+		}, t.prototype.getLength = function() {
+			return this.data.length;
+		}, t.prototype.getBitsLength = function() {
+			return t.getBitsLength(this.data.length);
+		}, t.prototype.write = function(e) {
+			let n;
+			for (n = 0; n + 2 <= this.data.length; n += 2) {
+				let o = r.indexOf(this.data[n]) * 45;
+				o += r.indexOf(this.data[n + 1]), e.put(o, 11);
+			}
+			this.data.length % 2 && e.put(r.indexOf(this.data[n]), 6);
+		}, s.exports = t;
+	})), dt = P.o(((i, s) => {
+		var a = k();
+		function r(t) {
+			this.mode = a.BYTE, this.data = typeof t == "string" ? new TextEncoder().encode(t) : new Uint8Array(t);
+		}
+		r.getBitsLength = function(t) {
+			return t * 8;
+		}, r.prototype.getLength = function() {
+			return this.data.length;
+		}, r.prototype.getBitsLength = function() {
+			return r.getBitsLength(this.data.length);
+		}, r.prototype.write = function(t) {
+			for (let e = 0, n = this.data.length; e < n; e++) t.put(this.data[e], 8);
+		}, s.exports = r;
+	})), gt = P.o(((i, s) => {
+		var a = k(), r = _();
+		function t(e) {
+			this.mode = a.KANJI, this.data = e;
+		}
+		t.getBitsLength = function(e) {
+			return e * 13;
+		}, t.prototype.getLength = function() {
+			return this.data.length;
+		}, t.prototype.getBitsLength = function() {
+			return t.getBitsLength(this.data.length);
+		}, t.prototype.write = function(e) {
+			let n;
+			for (n = 0; n < this.data.length; n++) {
+				let o = r.toSJIS(this.data[n]);
+				if (o >= 33088 && o <= 40956) o -= 33088;
+				else if (o >= 57408 && o <= 60351) o -= 49472;
+				else throw Error("Invalid SJIS character: " + this.data[n] + `
+Make sure your charset is UTF-8`);
+				o = (o >>> 8 & 255) * 192 + (o & 255), e.put(o, 13);
+			}
+		}, s.exports = t;
+	})), pt = P.o(((i, s) => {
+		var a = {
+			single_source_shortest_paths: function(r, t, e) {
+				var n = {}, o = {};
+				o[t] = 0;
+				var u = a.PriorityQueue.make();
+				u.push(t, 0);
+				for (var c, E, y, l, m, v, T, x, C; !u.empty();) for (y in c = u.pop(), E = c.value, l = c.cost, m = r[E] || {}, m) m.hasOwnProperty(y) && (v = m[y], T = l + v, x = o[y], C = o[y] === void 0, (C || x > T) && (o[y] = T, u.push(y, T), n[y] = E));
+				if (e !== void 0 && o[e] === void 0) {
+					var M = [
+						"Could not find a path from ",
+						t,
+						" to ",
+						e,
+						"."
+					].join("");
+					throw Error(M);
+				}
+				return n;
+			},
+			extract_shortest_path_from_predecessor_list: function(r, t) {
+				for (var e = [], n = t; n;) e.push(n), r[n], n = r[n];
+				return e.reverse(), e;
+			},
+			find_path: function(r, t, e) {
+				var n = a.single_source_shortest_paths(r, t, e);
+				return a.extract_shortest_path_from_predecessor_list(n, e);
+			},
+			PriorityQueue: {
+				make: function(r) {
+					var t = a.PriorityQueue, e = {}, n;
+					for (n in r ||= {}, t) t.hasOwnProperty(n) && (e[n] = t[n]);
+					return e.queue = [], e.sorter = r.sorter || t.default_sorter, e;
+				},
+				default_sorter: function(r, t) {
+					return r.cost - t.cost;
+				},
+				push: function(r, t) {
+					var e = {
+						value: r,
+						cost: t
+					};
+					this.queue.push(e), this.queue.sort(this.sorter);
+				},
+				pop: function() {
+					return this.queue.shift();
+				},
+				empty: function() {
+					return this.queue.length === 0;
+				}
+			}
+		};
+		s !== void 0 && (s.exports = a);
+	})), mt = P.o(((i) => {
+		var s = k(), a = ct(), r = ht(), t = dt(), e = gt(), n = Q(), o = _(), u = pt();
+		function c(C) {
+			return unescape(encodeURIComponent(C)).length;
+		}
+		function E(C, M, B) {
+			let I = [], L;
+			for (; (L = C.exec(B)) !== null;) I.push({
+				data: L[0],
+				index: L.index,
+				mode: M,
+				length: L[0].length
+			});
+			return I;
+		}
+		function y(C) {
+			let M = E(n.NUMERIC, s.NUMERIC, C), B = E(n.ALPHANUMERIC, s.ALPHANUMERIC, C), I, L;
+			return o.isKanjiModeEnabled() ? (I = E(n.BYTE, s.BYTE, C), L = E(n.KANJI, s.KANJI, C)) : (I = E(n.BYTE_KANJI, s.BYTE, C), L = []), M.concat(B, I, L).sort(function(R, g) {
+				return R.index - g.index;
+			}).map(function(R) {
+				return {
+					data: R.data,
+					mode: R.mode,
+					length: R.length
+				};
+			});
+		}
+		function l(C, M) {
+			switch (M) {
+				case s.NUMERIC: return a.getBitsLength(C);
+				case s.ALPHANUMERIC: return r.getBitsLength(C);
+				case s.KANJI: return e.getBitsLength(C);
+				case s.BYTE: return t.getBitsLength(C);
+			}
+		}
+		function m(C) {
+			return C.reduce(function(M, B) {
+				let I = M.length - 1 >= 0 ? M[M.length - 1] : null;
+				return I && I.mode === B.mode ? (M[M.length - 1].data += B.data, M) : (M.push(B), M);
+			}, []);
+		}
+		function v(C) {
+			let M = [];
+			for (let B = 0; B < C.length; B++) {
+				let I = C[B];
+				switch (I.mode) {
+					case s.NUMERIC:
+						M.push([
+							I,
+							{
+								data: I.data,
+								mode: s.ALPHANUMERIC,
+								length: I.length
+							},
+							{
+								data: I.data,
+								mode: s.BYTE,
+								length: I.length
+							}
+						]);
+						break;
+					case s.ALPHANUMERIC:
+						M.push([I, {
+							data: I.data,
+							mode: s.BYTE,
+							length: I.length
+						}]);
+						break;
+					case s.KANJI:
+						M.push([I, {
+							data: I.data,
+							mode: s.BYTE,
+							length: c(I.data)
+						}]);
+						break;
+					case s.BYTE: M.push([{
+						data: I.data,
+						mode: s.BYTE,
+						length: c(I.data)
+					}]);
+				}
+			}
+			return M;
+		}
+		function T(C, M) {
+			let B = {}, I = { start: {} }, L = ["start"];
+			for (let R = 0; R < C.length; R++) {
+				let g = C[R], w = [];
+				for (let A = 0; A < g.length; A++) {
+					let f = g[A], N = "" + R + A;
+					w.push(N), B[N] = {
+						node: f,
+						lastCount: 0
+					}, I[N] = {};
+					for (let h = 0; h < L.length; h++) {
+						let d = L[h];
+						B[d] && B[d].node.mode === f.mode ? (I[d][N] = l(B[d].lastCount + f.length, f.mode) - l(B[d].lastCount, f.mode), B[d].lastCount += f.length) : (B[d] && (B[d].lastCount = f.length), I[d][N] = l(f.length, f.mode) + 4 + s.getCharCountIndicator(f.mode, M));
+					}
+				}
+				L = w;
+			}
+			for (let R = 0; R < L.length; R++) I[L[R]].end = 0;
+			return {
+				map: I,
+				table: B
+			};
+		}
+		function x(C, M) {
+			let B, I = s.getBestModeForData(C);
+			if (B = s.from(M, I), B !== s.BYTE && B.bit < I.bit) throw Error("\"" + C + "\" cannot be encoded with mode " + s.toString(B) + `.
+ Suggested mode is: ` + s.toString(I));
+			switch (B === s.KANJI && !o.isKanjiModeEnabled() && (B = s.BYTE), B) {
+				case s.NUMERIC: return new a(C);
+				case s.ALPHANUMERIC: return new r(C);
+				case s.KANJI: return new e(C);
+				case s.BYTE: return new t(C);
+			}
+		}
+		i.fromArray = function(C) {
+			return C.reduce(function(M, B) {
+				return typeof B == "string" ? M.push(x(B, null)) : B.data && M.push(x(B.data, B.mode)), M;
+			}, []);
+		}, i.fromString = function(C, M) {
+			let B = T(v(y(C, o.isKanjiModeEnabled())), M), I = u.find_path(B.map, "start", "end"), L = [];
+			for (let R = 1; R < I.length - 1; R++) L.push(B.table[I[R]].node);
+			return i.fromArray(m(L));
+		}, i.rawSplit = function(C) {
+			return i.fromArray(y(C, o.isKanjiModeEnabled()));
+		};
+	})), vt = P.o(((i) => {
+		var s = _(), a = H(), r = rt(), t = et(), e = nt(), n = ot(), o = it(), u = V(), c = ut(), E = lt(), y = ft(), l = k(), m = mt();
+		function v(g, w) {
+			let A = g.size, f = n.getPositions(w);
+			for (let N = 0; N < f.length; N++) {
+				let h = f[N][0], d = f[N][1];
+				for (let p = -1; p <= 7; p++) if (!(h + p <= -1 || A <= h + p)) for (let b = -1; b <= 7; b++) d + b <= -1 || A <= d + b || (p >= 0 && p <= 6 && (b === 0 || b === 6) || b >= 0 && b <= 6 && (p === 0 || p === 6) || p >= 2 && p <= 4 && b >= 2 && b <= 4 ? g.set(h + p, d + b, !0, !0) : g.set(h + p, d + b, !1, !0));
+			}
+		}
+		function T(g) {
+			let w = g.size;
+			for (let A = 8; A < w - 8; A++) {
+				let f = A % 2 == 0;
+				g.set(A, 6, f, !0), g.set(6, A, f, !0);
+			}
+		}
+		function x(g, w) {
+			let A = e.getPositions(w);
+			for (let f = 0; f < A.length; f++) {
+				let N = A[f][0], h = A[f][1];
+				for (let d = -2; d <= 2; d++) for (let p = -2; p <= 2; p++) d === -2 || d === 2 || p === -2 || p === 2 || d === 0 && p === 0 ? g.set(N + d, h + p, !0, !0) : g.set(N + d, h + p, !1, !0);
+			}
+		}
+		function C(g, w) {
+			let A = g.size, f = E.getEncodedBits(w), N, h, d;
+			for (let p = 0; p < 18; p++) N = Math.floor(p / 3), h = p % 3 + A - 8 - 3, d = (f >> p & 1) == 1, g.set(N, h, d, !0), g.set(h, N, d, !0);
+		}
+		function M(g, w, A) {
+			let f = g.size, N = y.getEncodedBits(w, A), h, d;
+			for (h = 0; h < 15; h++) d = (N >> h & 1) == 1, h < 6 ? g.set(h, 8, d, !0) : h < 8 ? g.set(h + 1, 8, d, !0) : g.set(f - 15 + h, 8, d, !0), h < 8 ? g.set(8, f - h - 1, d, !0) : h < 9 ? g.set(8, 15 - h - 1 + 1, d, !0) : g.set(8, 15 - h - 1, d, !0);
+			g.set(f - 8, 8, 1, !0);
+		}
+		function B(g, w) {
+			let A = g.size, f = -1, N = A - 1, h = 7, d = 0;
+			for (let p = A - 1; p > 0; p -= 2) for (p === 6 && p--;;) {
+				for (let b = 0; b < 2; b++) if (!g.isReserved(N, p - b)) {
+					let D = !1;
+					d < w.length && (D = (w[d] >>> h & 1) == 1), g.set(N, p - b, D), h--, h === -1 && (d++, h = 7);
+				}
+				if (N += f, N < 0 || A <= N) {
+					N -= f, f = -f;
+					break;
+				}
+			}
+		}
+		function I(g, w, A) {
+			let f = new r();
+			A.forEach(function(d) {
+				f.put(d.mode.bit, 4), f.put(d.getLength(), l.getCharCountIndicator(d.mode, g)), d.write(f);
+			});
+			let N = (s.getSymbolTotalCodewords(g) - u.getTotalCodewordsCount(g, w)) * 8;
+			for (f.getLengthInBits() + 4 <= N && f.put(0, 4); f.getLengthInBits() % 8 != 0;) f.putBit(0);
+			let h = (N - f.getLengthInBits()) / 8;
+			for (let d = 0; d < h; d++) f.put(d % 2 ? 17 : 236, 8);
+			return L(f, g, w);
+		}
+		function L(g, w, A) {
+			let f = s.getSymbolTotalCodewords(w), N = f - u.getTotalCodewordsCount(w, A), h = u.getBlocksCount(w, A), d = h - f % h, p = Math.floor(f / h), b = Math.floor(N / h), D = b + 1, Z = p - b, Ct = new c(Z), K = 0, z = Array(h), X = Array(h), Y = 0, Bt = new Uint8Array(g.buffer);
+			for (let F = 0; F < h; F++) {
+				let j = F < d ? b : D;
+				z[F] = Bt.slice(K, K + j), X[F] = Ct.encode(z[F]), K += j, Y = Math.max(Y, j);
+			}
+			let J = new Uint8Array(f), W = 0, S, U;
+			for (S = 0; S < Y; S++) for (U = 0; U < h; U++) S < z[U].length && (J[W++] = z[U][S]);
+			for (S = 0; S < Z; S++) for (U = 0; U < h; U++) J[W++] = X[U][S];
+			return J;
+		}
+		function R(g, w, A, f) {
+			let N;
+			if (Array.isArray(g)) N = m.fromArray(g);
+			else if (typeof g == "string") {
+				let b = w;
+				if (!b) {
+					let D = m.rawSplit(g);
+					b = E.getBestVersionForData(D, A);
+				}
+				N = m.fromString(g, b || 40);
+			} else throw Error("Invalid data");
+			let h = E.getBestVersionForData(N, A);
+			if (!h) throw Error("The amount of data is too big to be stored in a QR Code");
+			if (!w) w = h;
+			else if (w < h) throw Error(`
+The chosen QR Code version cannot contain this amount of data.
+Minimum version required to store current data is: ` + h + `.
+`);
+			let d = I(w, A, N), p = new t(s.getSymbolSize(w));
+			return v(p, w), T(p), x(p, w), M(p, A, 0), w >= 7 && C(p, w), B(p, d), isNaN(f) && (f = o.getBestMask(p, M.bind(null, p, A))), o.applyMask(f, p), M(p, A, f), {
+				modules: p,
+				version: w,
+				errorCorrectionLevel: A,
+				maskPattern: f,
+				segments: N
+			};
+		}
+		i.create = function(g, w) {
+			if (g === void 0 || g === "") throw Error("No input text");
+			let A = a.M, f, N;
+			return w !== void 0 && (A = a.from(w.errorCorrectionLevel, a.M), f = E.from(w.version), N = o.from(w.maskPattern), w.toSJISFunc && s.setToSJISFunction(w.toSJISFunc)), R(g, f, A, N);
+		};
+	})), $ = P.o(((i) => {
+		function s(a) {
+			if (typeof a == "number" && (a = a.toString()), typeof a != "string") throw Error("Color should be defined as hex string");
+			let r = a.slice().replace("#", "").split("");
+			if (r.length < 3 || r.length === 5 || r.length > 8) throw Error("Invalid hex color: " + a);
+			(r.length === 3 || r.length === 4) && (r = Array.prototype.concat.apply([], r.map(function(e) {
+				return [e, e];
+			}))), r.length === 6 && r.push("F", "F");
+			let t = parseInt(r.join(""), 16);
+			return {
+				r: t >> 24 & 255,
+				g: t >> 16 & 255,
+				b: t >> 8 & 255,
+				a: t & 255,
+				hex: "#" + r.slice(0, 6).join("")
+			};
+		}
+		i.getOptions = function(a) {
+			a ||= {}, a.color || (a.color = {});
+			let r = a.margin === void 0 || a.margin === null || a.margin < 0 ? 4 : a.margin, t = a.width && a.width >= 21 ? a.width : void 0, e = a.scale || 4;
+			return {
+				width: t,
+				scale: t ? 4 : e,
+				margin: r,
+				color: {
+					dark: s(a.color.dark || "#000000ff"),
+					light: s(a.color.light || "#ffffffff")
+				},
+				type: a.type,
+				rendererOpts: a.rendererOpts || {}
+			};
+		}, i.getScale = function(a, r) {
+			return r.width && r.width >= a + r.margin * 2 ? r.width / (a + r.margin * 2) : r.scale;
+		}, i.getImageWidth = function(a, r) {
+			let t = i.getScale(a, r);
+			return Math.floor((a + r.margin * 2) * t);
+		}, i.qrToImageData = function(a, r, t) {
+			let e = r.modules.size, n = r.modules.data, o = i.getScale(e, t), u = Math.floor((e + t.margin * 2) * o), c = t.margin * o, E = [t.color.light, t.color.dark];
+			for (let y = 0; y < u; y++) for (let l = 0; l < u; l++) {
+				let m = (y * u + l) * 4, v = t.color.light;
+				if (y >= c && l >= c && y < u - c && l < u - c) {
+					let T = Math.floor((y - c) / o), x = Math.floor((l - c) / o);
+					v = E[+!!n[T * e + x]];
+				}
+				a[m++] = v.r, a[m++] = v.g, a[m++] = v.b, a[m] = v.a;
+			}
+		};
+	})), Et = P.o(((i) => {
+		var s = $();
+		function a(t, e, n) {
+			t.clearRect(0, 0, e.width, e.height), e.style ||= {}, e.height = n, e.width = n, e.style.height = n + "px", e.style.width = n + "px";
+		}
+		function r() {
+			try {
+				return document.createElement("canvas");
+			} catch {
+				throw Error("You need to specify a canvas element");
+			}
+		}
+		i.render = function(t, e, n) {
+			let o = n, u = e;
+			o === void 0 && (!e || !e.getContext) && (o = e, e = void 0), e || (u = r()), o = s.getOptions(o);
+			let c = s.getImageWidth(t.modules.size, o), E = u.getContext("2d"), y = E.createImageData(c, c);
+			return s.qrToImageData(y.data, t, o), a(E, u, c), E.putImageData(y, 0, 0), u;
+		}, i.renderToDataURL = function(t, e, n) {
+			let o = n;
+			o === void 0 && (!e || !e.getContext) && (o = e, e = void 0), o ||= {};
+			let u = i.render(t, e, o), c = o.type || "image/png", E = o.rendererOpts || {};
+			return u.toDataURL(c, E.quality);
+		};
+	})), yt = P.o(((i) => {
+		var s = $();
+		function a(e, n) {
+			let o = e.a / 255, u = n + "=\"" + e.hex + "\"";
+			return o < 1 ? u + " " + n + "-opacity=\"" + o.toFixed(2).slice(1) + "\"" : u;
+		}
+		function r(e, n, o) {
+			let u = e + n;
+			return o !== void 0 && (u += " " + o), u;
+		}
+		function t(e, n, o) {
+			let u = "", c = 0, E = !1, y = 0;
+			for (let l = 0; l < e.length; l++) {
+				let m = Math.floor(l % n), v = Math.floor(l / n);
+				!m && !E && (E = !0), e[l] ? (y++, l > 0 && m > 0 && e[l - 1] || (u += E ? r("M", m + o, .5 + v + o) : r("m", c, 0), c = 0, E = !1), m + 1 < n && e[l + 1] || (u += r("h", y), y = 0)) : c++;
+			}
+			return u;
+		}
+		i.render = function(e, n, o) {
+			let u = s.getOptions(n), c = e.modules.size, E = e.modules.data, y = c + u.margin * 2, l = u.color.light.a ? "<path " + a(u.color.light, "fill") + " d=\"M0 0h" + y + "v" + y + "H0z\"/>" : "", m = "<path " + a(u.color.dark, "stroke") + " d=\"" + t(E, c, u.margin) + "\"/>", v = "viewBox=\"0 0 " + y + " " + y + "\"", T = "<svg xmlns=\"http://www.w3.org/2000/svg\" " + (u.width ? "width=\"" + u.width + "\" height=\"" + u.width + "\" " : "") + v + " shape-rendering=\"crispEdges\">" + l + m + `</svg>
+`;
+			return typeof o == "function" && o(null, T), T;
+		};
+	}));
+	G.default = P.o(((i) => {
+		var s = tt(), a = vt(), r = Et(), t = yt();
+		function e(n, o, u, c, E) {
+			let y = [].slice.call(arguments, 1), l = y.length, m = typeof y[l - 1] == "function";
+			if (!m && !s()) throw Error("Callback required as last argument");
+			if (m) {
+				if (l < 2) throw Error("Too few arguments provided");
+				l === 2 ? (E = u, u = o, o = c = void 0) : l === 3 && (o.getContext && E === void 0 ? (E = c, c = void 0) : (E = c, c = u, u = o, o = void 0));
+			} else {
+				if (l < 1) throw Error("Too few arguments provided");
+				return l === 1 ? (u = o, o = c = void 0) : l === 2 && !o.getContext && (c = u, u = o, o = void 0), new Promise(function(v, T) {
+					try {
+						v(n(a.create(u, c), o, c));
+					} catch (x) {
+						T(x);
+					}
+				});
+			}
+			try {
+				let v = a.create(u, c);
+				E(null, n(v, o, c));
+			} catch (v) {
+				E(v);
+			}
+		}
+		i.create = a.create, i.toCanvas = e.bind(null, r.render), i.toDataURL = e.bind(null, r.renderToDataURL), i.toString = e.bind(null, function(n, o, u) {
+			return t.render(n, u);
+		});
+	}))();
+});