useblocks 1.1.53 → 1.1.56

package/static/core/58c4b8d7.js

@@ -0,0 +1,3150 @@
+__useblocks__.define("static/core/58c4b8d7.js", [
+	"require",
+	"exports",
+	"module",
+	"static/core/bd36b180.js",
+	"static/core/b9bb2c5f.js",
+	"static/core/4dadf572.js",
+	"static/core/951903fb.js",
+	"static/core/bf446743.js",
+	"react"
+], function(Qe, le, Fn) {
+	const Ve = Qe("./bd36b180.js"), Ie = Qe("./b9bb2c5f.js"), kt = Qe("./4dadf572.js"), ft = Qe("./951903fb.js"), yt = Qe("./bf446743.js");
+	let Bt = Qe("react");
+	var Dt = Ve.__commonJSMin(((A, S) => {
+		S.exports = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";
+	})), Ht = Ve.__commonJSMin(((A, S) => {
+		var j = Dt();
+		function G() {}
+		function $() {}
+		$.resetWarningCache = G, S.exports = function() {
+			function Q(Z, z, ue, ee, Me, ye) {
+				if (ye !== j) {
+					var Ee = new Error("Calling PropTypes validators directly is not supported by the `prop-types` package. Use PropTypes.checkPropTypes() to call them. Read more at http://fb.me/use-check-prop-types");
+					throw Ee.name = "Invariant Violation", Ee;
+				}
+			}
+			Q.isRequired = Q;
+			function V() {
+				return Q;
+			}
+			var K = {
+				array: Q,
+				bigint: Q,
+				bool: Q,
+				func: Q,
+				number: Q,
+				object: Q,
+				string: Q,
+				symbol: Q,
+				any: Q,
+				arrayOf: V,
+				element: Q,
+				elementType: Q,
+				instanceOf: V,
+				node: Q,
+				objectOf: V,
+				oneOf: V,
+				oneOfType: V,
+				shape: V,
+				exact: V,
+				checkPropTypes: $,
+				resetWarningCache: G
+			};
+			return K.PropTypes = K, K;
+		};
+	})), jt = Ve.__commonJSMin(((A, S) => {
+		S.exports = Ht()();
+	}));
+	function wt({ limitsInPlugin: A, hostedAiActive: S }) {
+		return A && !S;
+	}
+	function Nt({ limitsInPlugin: A, hostedAiActive: S, counter: j, limit: G }) {
+		return wt({
+			limitsInPlugin: A,
+			hostedAiActive: S
+		}) ? G > 0 && j >= G : !1;
+	}
+	function ct(A, S) {
+		if (A) {
+			if (S === "preview") {
+				const j = A;
+				return j.preview ?? j.test_sends;
+			}
+			return A[S];
+		}
+	}
+	function lt(A, S) {
+		if (A?.flags) {
+			if (S === "preview") {
+				const j = A.flags;
+				return j.preview ?? j.test_sends;
+			}
+			return A.flags[S];
+		}
+	}
+	var Wt = [
+		10,
+		30,
+		300
+	], At = [
+		10,
+		50,
+		150
+	];
+	function ut(A, S) {
+		for (const j of S) if (j > A) return j;
+		return "infinity";
+	}
+	function zt(A) {
+		return A <= 10 ? "email_10_30" : A <= 30 ? "email_30_300" : "email_300_inf";
+	}
+	function _t(A) {
+		return A <= 10 ? "ai_10_50" : A <= 50 ? "ai_30_150" : "ai_150_inf";
+	}
+	function ht(A, S) {
+		return S?.limit_exceeded ? !0 : A.is_unlimited || A.total_limit <= 0 ? !1 : A.remaining <= 0 || A.used >= A.total_limit;
+	}
+	var Qt = [
+		"optimization",
+		"image_generate",
+		"preview",
+		"link_check",
+		"image_check",
+		"spam_check"
+	];
+	function Gt(A) {
+		return Qt.includes(A);
+	}
+	var qt = {
+		optimization: "optimization_exceeded",
+		image_generate: "image_generate_exceeded",
+		preview: "preview_exceeded",
+		link_check: "link_check_exceeded",
+		image_check: "image_check_exceeded",
+		spam_check: "spam_check_exceeded"
+	};
+	function Ge(A, S, j) {
+		if (Gt(A)) return null;
+		const G = ct(S, A), $ = lt(j, A);
+		if (!G || !ht(G, $)) return null;
+		const Q = G.total_limit;
+		return {
+			kind: A,
+			presetId: qt[A],
+			previousLimit: Q,
+			nextLimit: "infinity"
+		};
+	}
+	function $t(A, S) {
+		if (!A) return null;
+		const j = ct(A, "ai"), G = lt(S, "ai");
+		if (j && ht(j, G)) {
+			const ee = j.total_limit;
+			return {
+				kind: "ai",
+				presetId: _t(ee),
+				previousLimit: ee,
+				nextLimit: ut(ee, At)
+			};
+		}
+		const $ = ct(A, "email_generate"), Q = lt(S, "email_generate");
+		if ($ && ht($, Q)) {
+			const ee = $.total_limit;
+			return {
+				kind: "email_generate",
+				presetId: zt(ee),
+				previousLimit: ee,
+				nextLimit: ut(ee, Wt)
+			};
+		}
+		const V = Ge("image_generate", A, S);
+		if (V) return V;
+		const K = Ge("optimization", A, S);
+		if (K) return K;
+		const Z = Ge("preview", A, S);
+		if (Z) return Z;
+		const z = Ge("link_check", A, S);
+		if (z) return z;
+		return Ge("image_check", A, S) || Ge("spam_check", A, S);
+	}
+	function Xt(A) {
+		return {
+			presetId: _t(A),
+			previousLimit: A,
+			nextLimit: ut(A, At)
+		};
+	}
+	function Kt(A) {
+		const S = String(A ?? "").split(";")[0].trim();
+		if (!S) return "";
+		const j = S.toLowerCase(), G = j.indexOf("/");
+		if (G === -1) return j;
+		const $ = j.slice(G + 1);
+		return $ === "svg+xml" ? "svg" : $;
+	}
+	async function Vt(A) {
+		if (typeof createImageBitmap == "function") try {
+			const S = await createImageBitmap(A);
+			try {
+				return {
+					width: S.width,
+					height: S.height
+				};
+			} finally {
+				S.close?.();
+			}
+		} catch {}
+		return new Promise((S, j) => {
+			const G = URL.createObjectURL(A), $ = new Image();
+			$.onload = () => {
+				URL.revokeObjectURL(G);
+				const Q = $.naturalWidth || $.width, V = $.naturalHeight || $.height;
+				Q > 0 && V > 0 ? S({
+					width: Q,
+					height: V
+				}) : j(new Error("Could not read image dimensions"));
+			}, $.onerror = () => {
+				URL.revokeObjectURL(G), j(new Error("Could not decode image"));
+			}, $.src = G;
+		});
+	}
+	function dt(A) {
+		return A.trim();
+	}
+	function Yt() {
+		const A = new Map(), S = new Map();
+		function j(V, K) {
+			return K ? new Promise((Z, z) => {
+				if (K.aborted) {
+					z(new DOMException("Aborted", "AbortError"));
+					return;
+				}
+				const ue = () => {
+					z(new DOMException("Aborted", "AbortError"));
+				};
+				K.addEventListener("abort", ue, { once: !0 }), V.then((ee) => {
+					K.removeEventListener("abort", ue), Z(ee);
+				}, (ee) => {
+					K.removeEventListener("abort", ue), z(ee);
+				});
+			}) : V;
+		}
+		async function G(V, K, Z) {
+			const z = dt(V);
+			if (!z) throw new Error("Empty image URL");
+			const ue = A.get(z);
+			if (ue) {
+				if (K?.aborted) throw new DOMException("Aborted", "AbortError");
+				return ue;
+			}
+			const ee = S.get(z);
+			if (ee) return j(ee.promise, K);
+			const Me = new AbortController(), ye = Z(z, Me.signal).then((Ee) => (S.delete(z), A.set(z, Ee), Ee)).catch((Ee) => {
+				throw S.delete(z), Ee;
+			});
+			return S.set(z, {
+				promise: ye,
+				controller: Me
+			}), j(ye, K);
+		}
+		function $(V) {
+			const K = dt(V);
+			if (!K) return;
+			const Z = S.get(K);
+			Z && (Z.controller.abort(), S.delete(K)), A.delete(K);
+		}
+		function Q() {
+			for (const [, V] of S) V.controller.abort();
+			S.clear(), A.clear();
+		}
+		return {
+			resolve: G,
+			abandonKey: $,
+			invalidateAll: Q
+		};
+	}
+	var Zt = Ve.__commonJSMin(((A, S) => {
+		(function(j, G) {
+			typeof A == "object" && typeof S < "u" ? S.exports = G() : typeof define == "function" && define.amd ? define(G) : (j = typeof globalThis < "u" ? globalThis : j || self).imageCompression = G();
+		})(A, (function() {
+			"use strict";
+			function j(T, P) {
+				return P.forEach((function(H) {
+					H && typeof H != "string" && !Array.isArray(H) && Object.keys(H).forEach((function(h) {
+						if (h !== "default" && !(h in T)) {
+							var e = Object.getOwnPropertyDescriptor(H, h);
+							Object.defineProperty(T, h, e.get ? e : {
+								enumerable: !0,
+								get: function() {
+									return H[h];
+								}
+							});
+						}
+					}));
+				})), Object.freeze(T);
+			}
+			function G(T, P) {
+				return new Promise((function(H, h) {
+					let e;
+					return $(T).then((function(t) {
+						try {
+							return e = t, H(new Blob([
+								P.slice(0, 2),
+								e,
+								P.slice(2)
+							], { type: "image/jpeg" }));
+						} catch (u) {
+							return h(u);
+						}
+					}), h);
+				}));
+			}
+			const $ = (T) => new Promise(((P, H) => {
+				const h = new FileReader();
+				h.addEventListener("load", (({ target: { result: e } }) => {
+					const t = new DataView(e);
+					let u = 0;
+					if (t.getUint16(u) !== 65496) return H("not a valid JPEG");
+					for (u += 2;;) {
+						const a = t.getUint16(u);
+						if (a === 65498) break;
+						const p = t.getUint16(u + 2);
+						if (a === 65505 && t.getUint32(u + 4) === 1165519206) {
+							const _ = u + 10;
+							let r;
+							switch (t.getUint16(_)) {
+								case 18761:
+									r = !0;
+									break;
+								case 19789:
+									r = !1;
+									break;
+								default: return H("TIFF header contains invalid endian");
+							}
+							if (t.getUint16(_ + 2, r) !== 42) return H("TIFF header contains invalid version");
+							const i = t.getUint32(_ + 4, r), n = _ + i + 2 + 12 * t.getUint16(_ + i, r);
+							for (let s = _ + i + 2; s < n; s += 12) if (t.getUint16(s, r) == 274) {
+								if (t.getUint16(s + 2, r) !== 3) return H("Orientation data type is invalid");
+								if (t.getUint32(s + 4, r) !== 1) return H("Orientation data count is invalid");
+								t.setUint16(s + 8, 1, r);
+								break;
+							}
+							return P(e.slice(u, u + 2 + p));
+						}
+						u += 2 + p;
+					}
+					return P(new Blob());
+				})), h.readAsArrayBuffer(T);
+			}));
+			var Q = {};
+			(function(T) {
+				var P, H, h = {};
+				T.exports = h, h.parse = function(e, t) {
+					for (var u = h.bin.readUshort, a = h.bin.readUint, p = 0, _ = {}, r = new Uint8Array(e), i = r.length - 4; a(r, i) != 101010256;) i--;
+					p = i, p += 4;
+					var n = u(r, p += 4);
+					u(r, p += 2);
+					var s = a(r, p += 2), d = a(r, p += 4);
+					p += 4, p = d;
+					for (var E = 0; E < n; E++) {
+						a(r, p), p += 4, p += 4, p += 4, a(r, p += 4), s = a(r, p += 4);
+						var x = a(r, p += 4), b = u(r, p += 4), D = u(r, p + 2), O = u(r, p + 4);
+						p += 6;
+						var M = a(r, p += 8);
+						p += 4, p += b + D + O, h._readLocal(r, M, _, s, x, t);
+					}
+					return _;
+				}, h._readLocal = function(e, t, u, a, p, _) {
+					var r = h.bin.readUshort, i = h.bin.readUint;
+					i(e, t), r(e, t += 4), r(e, t += 2);
+					var n = r(e, t += 2);
+					i(e, t += 2), i(e, t += 4), t += 4;
+					var s = r(e, t += 8), d = r(e, t += 2);
+					t += 2;
+					var E = h.bin.readUTF8(e, t, s);
+					if (t += s, t += d, _) u[E] = {
+						size: p,
+						csize: a
+					};
+					else {
+						var x = new Uint8Array(e.buffer, t);
+						if (n == 0) u[E] = new Uint8Array(x.buffer.slice(t, t + a));
+						else {
+							if (n != 8) throw "unknown compression method: " + n;
+							var b = new Uint8Array(p);
+							h.inflateRaw(x, b), u[E] = b;
+						}
+					}
+				}, h.inflateRaw = function(e, t) {
+					return h.F.inflate(e, t);
+				}, h.inflate = function(e, t) {
+					return e[0], e[1], h.inflateRaw(new Uint8Array(e.buffer, e.byteOffset + 2, e.length - 6), t);
+				}, h.deflate = function(e, t) {
+					t ??= { level: 6 };
+					var u = 0, a = new Uint8Array(50 + Math.floor(1.1 * e.length));
+					a[u] = 120, a[u + 1] = 156, u += 2, u = h.F.deflateRaw(e, a, u, t.level);
+					var p = h.adler(e, 0, e.length);
+					return a[u + 0] = p >>> 24 & 255, a[u + 1] = p >>> 16 & 255, a[u + 2] = p >>> 8 & 255, a[u + 3] = p >>> 0 & 255, new Uint8Array(a.buffer, 0, u + 4);
+				}, h.deflateRaw = function(e, t) {
+					t ??= { level: 6 };
+					var u = new Uint8Array(50 + Math.floor(1.1 * e.length)), a = h.F.deflateRaw(e, u, a, t.level);
+					return new Uint8Array(u.buffer, 0, a);
+				}, h.encode = function(e, t) {
+					t ??= !1;
+					var u = 0, a = h.bin.writeUint, p = h.bin.writeUshort, _ = {};
+					for (var r in e) {
+						var i = !h._noNeed(r) && !t, n = e[r], s = h.crc.crc(n, 0, n.length);
+						_[r] = {
+							cpr: i,
+							usize: n.length,
+							crc: s,
+							file: i ? h.deflateRaw(n) : n
+						};
+					}
+					for (var r in _) u += _[r].file.length + 30 + 46 + 2 * h.bin.sizeUTF8(r);
+					u += 22;
+					var d = new Uint8Array(u), E = 0, x = [];
+					for (var r in _) {
+						var b = _[r];
+						x.push(E), E = h._writeHeader(d, E, r, b, 0);
+					}
+					var D = 0, O = E;
+					for (var r in _) b = _[r], x.push(E), E = h._writeHeader(d, E, r, b, 1, x[D++]);
+					var M = E - O;
+					return a(d, E, 101010256), E += 4, p(d, E += 4, D), p(d, E += 2, D), a(d, E += 2, M), a(d, E += 4, O), E += 4, E += 2, d.buffer;
+				}, h._noNeed = function(e) {
+					var t = e.split(".").pop().toLowerCase();
+					return "png,jpg,jpeg,zip".indexOf(t) != -1;
+				}, h._writeHeader = function(e, t, u, a, p, _) {
+					var r = h.bin.writeUint, i = h.bin.writeUshort, n = a.file;
+					return r(e, t, p == 0 ? 67324752 : 33639248), t += 4, p == 1 && (t += 2), i(e, t, 20), i(e, t += 2, 0), i(e, t += 2, a.cpr ? 8 : 0), r(e, t += 2, 0), r(e, t += 4, a.crc), r(e, t += 4, n.length), r(e, t += 4, a.usize), i(e, t += 4, h.bin.sizeUTF8(u)), i(e, t += 2, 0), t += 2, p == 1 && (t += 2, t += 2, r(e, t += 6, _), t += 4), t += h.bin.writeUTF8(e, t, u), p == 0 && (e.set(n, t), t += n.length), t;
+				}, h.crc = {
+					table: (function() {
+						for (var e = new Uint32Array(256), t = 0; t < 256; t++) {
+							for (var u = t, a = 0; a < 8; a++) 1 & u ? u = 3988292384 ^ u >>> 1 : u >>>= 1;
+							e[t] = u;
+						}
+						return e;
+					})(),
+					update: function(e, t, u, a) {
+						for (var p = 0; p < a; p++) e = h.crc.table[255 & (e ^ t[u + p])] ^ e >>> 8;
+						return e;
+					},
+					crc: function(e, t, u) {
+						return 4294967295 ^ h.crc.update(4294967295, e, t, u);
+					}
+				}, h.adler = function(e, t, u) {
+					for (var a = 1, p = 0, _ = t, r = t + u; _ < r;) {
+						for (var i = Math.min(_ + 5552, r); _ < i;) p += a += e[_++];
+						a %= 65521, p %= 65521;
+					}
+					return p << 16 | a;
+				}, h.bin = {
+					readUshort: function(e, t) {
+						return e[t] | e[t + 1] << 8;
+					},
+					writeUshort: function(e, t, u) {
+						e[t] = 255 & u, e[t + 1] = u >> 8 & 255;
+					},
+					readUint: function(e, t) {
+						return 16777216 * e[t + 3] + (e[t + 2] << 16 | e[t + 1] << 8 | e[t]);
+					},
+					writeUint: function(e, t, u) {
+						e[t] = 255 & u, e[t + 1] = u >> 8 & 255, e[t + 2] = u >> 16 & 255, e[t + 3] = u >> 24 & 255;
+					},
+					readASCII: function(e, t, u) {
+						for (var a = "", p = 0; p < u; p++) a += String.fromCharCode(e[t + p]);
+						return a;
+					},
+					writeASCII: function(e, t, u) {
+						for (var a = 0; a < u.length; a++) e[t + a] = u.charCodeAt(a);
+					},
+					pad: function(e) {
+						return e.length < 2 ? "0" + e : e;
+					},
+					readUTF8: function(e, t, u) {
+						for (var a, p = "", _ = 0; _ < u; _++) p += "%" + h.bin.pad(e[t + _].toString(16));
+						try {
+							a = decodeURIComponent(p);
+						} catch {
+							return h.bin.readASCII(e, t, u);
+						}
+						return a;
+					},
+					writeUTF8: function(e, t, u) {
+						for (var a = u.length, p = 0, _ = 0; _ < a; _++) {
+							var r = u.charCodeAt(_);
+							if ((4294967168 & r) == 0) e[t + p] = r, p++;
+							else if ((4294965248 & r) == 0) e[t + p] = 192 | r >> 6, e[t + p + 1] = 128 | r >> 0 & 63, p += 2;
+							else if ((4294901760 & r) == 0) e[t + p] = 224 | r >> 12, e[t + p + 1] = 128 | r >> 6 & 63, e[t + p + 2] = 128 | r >> 0 & 63, p += 3;
+							else {
+								if ((4292870144 & r) != 0) throw "e";
+								e[t + p] = 240 | r >> 18, e[t + p + 1] = 128 | r >> 12 & 63, e[t + p + 2] = 128 | r >> 6 & 63, e[t + p + 3] = 128 | r >> 0 & 63, p += 4;
+							}
+						}
+						return p;
+					},
+					sizeUTF8: function(e) {
+						for (var t = e.length, u = 0, a = 0; a < t; a++) {
+							var p = e.charCodeAt(a);
+							if ((4294967168 & p) == 0) u++;
+							else if ((4294965248 & p) == 0) u += 2;
+							else if ((4294901760 & p) == 0) u += 3;
+							else {
+								if ((4292870144 & p) != 0) throw "e";
+								u += 4;
+							}
+						}
+						return u;
+					}
+				}, h.F = {}, h.F.deflateRaw = function(e, t, u, a) {
+					var p = [
+						[
+							0,
+							0,
+							0,
+							0,
+							0
+						],
+						[
+							4,
+							4,
+							8,
+							4,
+							0
+						],
+						[
+							4,
+							5,
+							16,
+							8,
+							0
+						],
+						[
+							4,
+							6,
+							16,
+							16,
+							0
+						],
+						[
+							4,
+							10,
+							16,
+							32,
+							0
+						],
+						[
+							8,
+							16,
+							32,
+							32,
+							0
+						],
+						[
+							8,
+							16,
+							128,
+							128,
+							0
+						],
+						[
+							8,
+							32,
+							128,
+							256,
+							0
+						],
+						[
+							32,
+							128,
+							258,
+							1024,
+							1
+						],
+						[
+							32,
+							258,
+							258,
+							4096,
+							1
+						]
+					][a], _ = h.F.U, r = h.F._goodIndex;
+					h.F._hash;
+					var i = h.F._putsE, n = 0, s = u << 3, d = 0, E = e.length;
+					if (a == 0) {
+						for (; n < E;) i(t, s, n + (w = Math.min(65535, E - n)) == E ? 1 : 0), s = h.F._copyExact(e, n, w, t, s + 8), n += w;
+						return s >>> 3;
+					}
+					var x = _.lits, b = _.strt, D = _.prev, O = 0, M = 0, B = 0, g = 0, R = 0, c = 0;
+					for (E > 2 && (b[c = h.F._hash(e, 0)] = 0), n = 0; n < E; n++) {
+						if (R = c, n + 1 < E - 2) {
+							c = h.F._hash(e, n + 1);
+							var f = n + 1 & 32767;
+							D[f] = b[c], b[c] = f;
+						}
+						if (d <= n) {
+							(O > 14e3 || M > 26697) && E - n > 100 && (d < n && (x[O] = n - d, O += 2, d = n), s = h.F._writeBlock(n == E - 1 || d == E ? 1 : 0, x, O, g, e, B, n - B, t, s), O = M = g = 0, B = n);
+							var v = 0;
+							n < E - 2 && (v = h.F._bestMatch(e, n, D, R, Math.min(p[2], E - n), p[3]));
+							var w = v >>> 16, y = 65535 & v;
+							if (v != 0) {
+								y = 65535 & v;
+								var U = r(w = v >>> 16, _.of0);
+								_.lhst[257 + U]++;
+								var m = r(y, _.df0);
+								_.dhst[m]++, g += _.exb[U] + _.dxb[m], x[O] = w << 23 | n - d, x[O + 1] = y << 16 | U << 8 | m, O += 2, d = n + w;
+							} else _.lhst[e[n]]++;
+							M++;
+						}
+					}
+					for (B == n && e.length != 0 || (d < n && (x[O] = n - d, O += 2, d = n), s = h.F._writeBlock(1, x, O, g, e, B, n - B, t, s), O = 0, M = 0, O = M = g = 0, B = n); (7 & s) != 0;) s++;
+					return s >>> 3;
+				}, h.F._bestMatch = function(e, t, u, a, p, _) {
+					var r = 32767 & t, i = u[r], n = r - i + 32768 & 32767;
+					if (i == r || a != h.F._hash(e, t - n)) return 0;
+					for (var s = 0, d = 0, E = Math.min(32767, t); n <= E && --_ != 0 && i != r;) {
+						if (s == 0 || e[t + s] == e[t + s - n]) {
+							var x = h.F._howLong(e, t, n);
+							if (x > s) {
+								if (d = n, (s = x) >= p) break;
+								n + 2 < x && (x = n + 2);
+								for (var b = 0, D = 0; D < x - 2; D++) {
+									var O = t - n + D + 32768 & 32767, M = O - u[O] + 32768 & 32767;
+									M > b && (b = M, i = O);
+								}
+							}
+						}
+						n += (r = i) - (i = u[r]) + 32768 & 32767;
+					}
+					return s << 16 | d;
+				}, h.F._howLong = function(e, t, u) {
+					if (e[t] != e[t - u] || e[t + 1] != e[t + 1 - u] || e[t + 2] != e[t + 2 - u]) return 0;
+					var a = t, p = Math.min(e.length, t + 258);
+					for (t += 3; t < p && e[t] == e[t - u];) t++;
+					return t - a;
+				}, h.F._hash = function(e, t) {
+					return (e[t] << 8 | e[t + 1]) + (e[t + 2] << 4) & 65535;
+				}, h.saved = 0, h.F._writeBlock = function(e, t, u, a, p, _, r, i, n) {
+					var s, d, E, x, b, D, O, M, B, g = h.F.U, R = h.F._putsF, c = h.F._putsE;
+					g.lhst[256]++, d = (s = h.F.getTrees())[0], E = s[1], x = s[2], b = s[3], D = s[4], O = s[5], M = s[6], B = s[7];
+					var f = 32 + ((n + 3 & 7) == 0 ? 0 : 8 - (n + 3 & 7)) + (r << 3), v = a + h.F.contSize(g.fltree, g.lhst) + h.F.contSize(g.fdtree, g.dhst), w = a + h.F.contSize(g.ltree, g.lhst) + h.F.contSize(g.dtree, g.dhst);
+					w += 14 + 3 * O + h.F.contSize(g.itree, g.ihst) + (2 * g.ihst[16] + 3 * g.ihst[17] + 7 * g.ihst[18]);
+					for (var y = 0; y < 286; y++) g.lhst[y] = 0;
+					for (y = 0; y < 30; y++) g.dhst[y] = 0;
+					for (y = 0; y < 19; y++) g.ihst[y] = 0;
+					var U = f < v && f < w ? 0 : v < w ? 1 : 2;
+					if (R(i, n, e), R(i, n + 1, U), n += 3, U == 0) {
+						for (; (7 & n) != 0;) n++;
+						n = h.F._copyExact(p, _, r, i, n);
+					} else {
+						var m, I;
+						if (U == 1 && (m = g.fltree, I = g.fdtree), U == 2) {
+							h.F.makeCodes(g.ltree, d), h.F.revCodes(g.ltree, d), h.F.makeCodes(g.dtree, E), h.F.revCodes(g.dtree, E), h.F.makeCodes(g.itree, x), h.F.revCodes(g.itree, x), m = g.ltree, I = g.dtree, c(i, n, b - 257), c(i, n += 5, D - 1), c(i, n += 5, O - 4), n += 4;
+							for (var l = 0; l < O; l++) c(i, n + 3 * l, g.itree[1 + (g.ordr[l] << 1)]);
+							n += 3 * O, n = h.F._codeTiny(M, g.itree, i, n), n = h.F._codeTiny(B, g.itree, i, n);
+						}
+						for (var o = _, L = 0; L < u; L += 2) {
+							for (var F = t[L], k = F >>> 23, X = o + (8388607 & F); o < X;) n = h.F._writeLit(p[o++], m, i, n);
+							if (k != 0) {
+								var W = t[L + 1], q = W >> 16, N = W >> 8 & 255, C = 255 & W;
+								c(i, n = h.F._writeLit(257 + N, m, i, n), k - g.of0[N]), n += g.exb[N], R(i, n = h.F._writeLit(C, I, i, n), q - g.df0[C]), n += g.dxb[C], o += k;
+							}
+						}
+						n = h.F._writeLit(256, m, i, n);
+					}
+					return n;
+				}, h.F._copyExact = function(e, t, u, a, p) {
+					var _ = p >>> 3;
+					return a[_] = u, a[_ + 1] = u >>> 8, a[_ + 2] = 255 - a[_], a[_ + 3] = 255 - a[_ + 1], _ += 4, a.set(new Uint8Array(e.buffer, t, u), _), p + (u + 4 << 3);
+				}, h.F.getTrees = function() {
+					for (var e = h.F.U, t = h.F._hufTree(e.lhst, e.ltree, 15), u = h.F._hufTree(e.dhst, e.dtree, 15), a = [], p = h.F._lenCodes(e.ltree, a), _ = [], r = h.F._lenCodes(e.dtree, _), i = 0; i < a.length; i += 2) e.ihst[a[i]]++;
+					for (i = 0; i < _.length; i += 2) e.ihst[_[i]]++;
+					for (var n = h.F._hufTree(e.ihst, e.itree, 7), s = 19; s > 4 && e.itree[1 + (e.ordr[s - 1] << 1)] == 0;) s--;
+					return [
+						t,
+						u,
+						n,
+						p,
+						r,
+						s,
+						a,
+						_
+					];
+				}, h.F.getSecond = function(e) {
+					for (var t = [], u = 0; u < e.length; u += 2) t.push(e[u + 1]);
+					return t;
+				}, h.F.nonZero = function(e) {
+					for (var t = "", u = 0; u < e.length; u += 2) e[u + 1] != 0 && (t += (u >> 1) + ",");
+					return t;
+				}, h.F.contSize = function(e, t) {
+					for (var u = 0, a = 0; a < t.length; a++) u += t[a] * e[1 + (a << 1)];
+					return u;
+				}, h.F._codeTiny = function(e, t, u, a) {
+					for (var p = 0; p < e.length; p += 2) {
+						var _ = e[p], r = e[p + 1];
+						a = h.F._writeLit(_, t, u, a);
+						var i = _ == 16 ? 2 : _ == 17 ? 3 : 7;
+						_ > 15 && (h.F._putsE(u, a, r, i), a += i);
+					}
+					return a;
+				}, h.F._lenCodes = function(e, t) {
+					for (var u = e.length; u != 2 && e[u - 1] == 0;) u -= 2;
+					for (var a = 0; a < u; a += 2) {
+						var p = e[a + 1], _ = a + 3 < u ? e[a + 3] : -1, r = a + 5 < u ? e[a + 5] : -1, i = a == 0 ? -1 : e[a - 1];
+						if (p == 0 && _ == p && r == p) {
+							for (var n = a + 5; n + 2 < u && e[n + 2] == p;) n += 2;
+							(s = Math.min(n + 1 - a >>> 1, 138)) < 11 ? t.push(17, s - 3) : t.push(18, s - 11), a += 2 * s - 2;
+						} else if (p == i && _ == p && r == p) {
+							for (n = a + 5; n + 2 < u && e[n + 2] == p;) n += 2;
+							var s = Math.min(n + 1 - a >>> 1, 6);
+							t.push(16, s - 3), a += 2 * s - 2;
+						} else t.push(p, 0);
+					}
+					return u >>> 1;
+				}, h.F._hufTree = function(e, t, u) {
+					var a = [], p = e.length, _ = t.length, r = 0;
+					for (r = 0; r < _; r += 2) t[r] = 0, t[r + 1] = 0;
+					for (r = 0; r < p; r++) e[r] != 0 && a.push({
+						lit: r,
+						f: e[r]
+					});
+					var i = a.length, n = a.slice(0);
+					if (i == 0) return 0;
+					if (i == 1) {
+						var s = a[0].lit;
+						return n = s == 0 ? 1 : 0, t[1 + (s << 1)] = 1, t[1 + (n << 1)] = 1, 1;
+					}
+					a.sort((function(M, B) {
+						return M.f - B.f;
+					}));
+					var d = a[0], E = a[1], x = 0, b = 1, D = 2;
+					for (a[0] = {
+						lit: -1,
+						f: d.f + E.f,
+						l: d,
+						r: E,
+						d: 0
+					}; b != i - 1;) d = x != b && (D == i || a[x].f < a[D].f) ? a[x++] : a[D++], E = x != b && (D == i || a[x].f < a[D].f) ? a[x++] : a[D++], a[b++] = {
+						lit: -1,
+						f: d.f + E.f,
+						l: d,
+						r: E
+					};
+					var O = h.F.setDepth(a[b - 1], 0);
+					for (O > u && (h.F.restrictDepth(n, u, O), O = u), r = 0; r < i; r++) t[1 + (n[r].lit << 1)] = n[r].d;
+					return O;
+				}, h.F.setDepth = function(e, t) {
+					return e.lit != -1 ? (e.d = t, t) : Math.max(h.F.setDepth(e.l, t + 1), h.F.setDepth(e.r, t + 1));
+				}, h.F.restrictDepth = function(e, t, u) {
+					var a = 0, p = 1 << u - t, _ = 0;
+					for (e.sort((function(i, n) {
+						return n.d == i.d ? i.f - n.f : n.d - i.d;
+					})), a = 0; a < e.length && e[a].d > t; a++) {
+						var r = e[a].d;
+						e[a].d = t, _ += p - (1 << u - r);
+					}
+					for (_ >>>= u - t; _ > 0;) (r = e[a].d) < t ? (e[a].d++, _ -= 1 << t - r - 1) : a++;
+					for (; a >= 0; a--) e[a].d == t && _ < 0 && (e[a].d--, _++);
+				}, h.F._goodIndex = function(e, t) {
+					var u = 0;
+					return t[16 | u] <= e && (u |= 16), t[8 | u] <= e && (u |= 8), t[4 | u] <= e && (u |= 4), t[2 | u] <= e && (u |= 2), t[1 | u] <= e && (u |= 1), u;
+				}, h.F._writeLit = function(e, t, u, a) {
+					return h.F._putsF(u, a, t[e << 1]), a + t[1 + (e << 1)];
+				}, h.F.inflate = function(e, t) {
+					var u = Uint8Array;
+					if (e[0] == 3 && e[1] == 0) return t || new u(0);
+					var a = h.F, p = a._bitsF, _ = a._bitsE, r = a._decodeTiny, i = a.makeCodes, n = a.codes2map, s = a._get17, d = a.U, E = t == null;
+					E && (t = new u(e.length >>> 2 << 3));
+					for (var x, b, D = 0, O = 0, M = 0, B = 0, g = 0, R = 0, c = 0, f = 0, v = 0; D == 0;) if (D = p(e, v, 1), O = p(e, v + 1, 2), v += 3, O != 0) {
+						if (E && (t = h.F._check(t, f + (1 << 17))), O == 1 && (x = d.flmap, b = d.fdmap, R = 511, c = 31), O == 2) {
+							M = _(e, v, 5) + 257, B = _(e, v + 5, 5) + 1, g = _(e, v + 10, 4) + 4, v += 14;
+							for (var w = 0; w < 38; w += 2) d.itree[w] = 0, d.itree[w + 1] = 0;
+							var y = 1;
+							for (w = 0; w < g; w++) {
+								var U = _(e, v + 3 * w, 3);
+								d.itree[1 + (d.ordr[w] << 1)] = U, U > y && (y = U);
+							}
+							v += 3 * g, i(d.itree, y), n(d.itree, y, d.imap), x = d.lmap, b = d.dmap, v = r(d.imap, (1 << y) - 1, M + B, e, v, d.ttree);
+							var m = a._copyOut(d.ttree, 0, M, d.ltree);
+							R = (1 << m) - 1;
+							var I = a._copyOut(d.ttree, M, B, d.dtree);
+							c = (1 << I) - 1, i(d.ltree, m), n(d.ltree, m, x), i(d.dtree, I), n(d.dtree, I, b);
+						}
+						for (;;) {
+							var l = x[s(e, v) & R];
+							v += 15 & l;
+							var o = l >>> 4;
+							if (!(o >>> 8)) t[f++] = o;
+							else {
+								if (o == 256) break;
+								var L = f + o - 254;
+								if (o > 264) {
+									var F = d.ldef[o - 257];
+									L = f + (F >>> 3) + _(e, v, 7 & F), v += 7 & F;
+								}
+								var k = b[s(e, v) & c];
+								v += 15 & k;
+								var X = k >>> 4, W = d.ddef[X], q = (W >>> 4) + p(e, v, 15 & W);
+								for (v += 15 & W, E && (t = h.F._check(t, f + (1 << 17))); f < L;) t[f] = t[f++ - q], t[f] = t[f++ - q], t[f] = t[f++ - q], t[f] = t[f++ - q];
+								f = L;
+							}
+						}
+					} else {
+						7 & v && (v += 8 - (7 & v));
+						var N = 4 + (v >>> 3), C = e[N - 4] | e[N - 3] << 8;
+						E && (t = h.F._check(t, f + C)), t.set(new u(e.buffer, e.byteOffset + N, C), f), v = N + C << 3, f += C;
+					}
+					return t.length == f ? t : t.slice(0, f);
+				}, h.F._check = function(e, t) {
+					var u = e.length;
+					if (t <= u) return e;
+					var a = new Uint8Array(Math.max(u << 1, t));
+					return a.set(e, 0), a;
+				}, h.F._decodeTiny = function(e, t, u, a, p, _) {
+					for (var r = h.F._bitsE, i = h.F._get17, n = 0; n < u;) {
+						var s = e[i(a, p) & t];
+						p += 15 & s;
+						var d = s >>> 4;
+						if (d <= 15) _[n] = d, n++;
+						else {
+							var E = 0, x = 0;
+							d == 16 ? (x = 3 + r(a, p, 2), p += 2, E = _[n - 1]) : d == 17 ? (x = 3 + r(a, p, 3), p += 3) : d == 18 && (x = 11 + r(a, p, 7), p += 7);
+							for (var b = n + x; n < b;) _[n] = E, n++;
+						}
+					}
+					return p;
+				}, h.F._copyOut = function(e, t, u, a) {
+					for (var p = 0, _ = 0, r = a.length >>> 1; _ < u;) {
+						var i = e[_ + t];
+						a[_ << 1] = 0, a[1 + (_ << 1)] = i, i > p && (p = i), _++;
+					}
+					for (; _ < r;) a[_ << 1] = 0, a[1 + (_ << 1)] = 0, _++;
+					return p;
+				}, h.F.makeCodes = function(e, t) {
+					for (var u, a, p, _, r = h.F.U, i = e.length, n = r.bl_count, s = 0; s <= t; s++) n[s] = 0;
+					for (s = 1; s < i; s += 2) n[e[s]]++;
+					var d = r.next_code;
+					for (u = 0, n[0] = 0, a = 1; a <= t; a++) u = u + n[a - 1] << 1, d[a] = u;
+					for (p = 0; p < i; p += 2) (_ = e[p + 1]) != 0 && (e[p] = d[_], d[_]++);
+				}, h.F.codes2map = function(e, t, u) {
+					for (var a = e.length, p = h.F.U.rev15, _ = 0; _ < a; _ += 2) if (e[_ + 1] != 0) for (var r = _ >> 1, i = e[_ + 1], n = r << 4 | i, s = t - i, d = e[_] << s, E = d + (1 << s); d != E;) u[p[d] >>> 15 - t] = n, d++;
+				}, h.F.revCodes = function(e, t) {
+					for (var u = h.F.U.rev15, a = 15 - t, p = 0; p < e.length; p += 2) e[p] = u[e[p] << t - e[p + 1]] >>> a;
+				}, h.F._putsE = function(e, t, u) {
+					u <<= 7 & t;
+					var a = t >>> 3;
+					e[a] |= u, e[a + 1] |= u >>> 8;
+				}, h.F._putsF = function(e, t, u) {
+					u <<= 7 & t;
+					var a = t >>> 3;
+					e[a] |= u, e[a + 1] |= u >>> 8, e[a + 2] |= u >>> 16;
+				}, h.F._bitsE = function(e, t, u) {
+					return (e[t >>> 3] | e[1 + (t >>> 3)] << 8) >>> (7 & t) & (1 << u) - 1;
+				}, h.F._bitsF = function(e, t, u) {
+					return (e[t >>> 3] | e[1 + (t >>> 3)] << 8 | e[2 + (t >>> 3)] << 16) >>> (7 & t) & (1 << u) - 1;
+				}, h.F._get17 = function(e, t) {
+					return (e[t >>> 3] | e[1 + (t >>> 3)] << 8 | e[2 + (t >>> 3)] << 16) >>> (7 & t);
+				}, h.F._get25 = function(e, t) {
+					return (e[t >>> 3] | e[1 + (t >>> 3)] << 8 | e[2 + (t >>> 3)] << 16 | e[3 + (t >>> 3)] << 24) >>> (7 & t);
+				}, h.F.U = (P = Uint16Array, H = Uint32Array, {
+					next_code: new P(16),
+					bl_count: new P(16),
+					ordr: [
+						16,
+						17,
+						18,
+						0,
+						8,
+						7,
+						9,
+						6,
+						10,
+						5,
+						11,
+						4,
+						12,
+						3,
+						13,
+						2,
+						14,
+						1,
+						15
+					],
+					of0: [
+						3,
+						4,
+						5,
+						6,
+						7,
+						8,
+						9,
+						10,
+						11,
+						13,
+						15,
+						17,
+						19,
+						23,
+						27,
+						31,
+						35,
+						43,
+						51,
+						59,
+						67,
+						83,
+						99,
+						115,
+						131,
+						163,
+						195,
+						227,
+						258,
+						999,
+						999,
+						999
+					],
+					exb: [
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						1,
+						1,
+						1,
+						1,
+						2,
+						2,
+						2,
+						2,
+						3,
+						3,
+						3,
+						3,
+						4,
+						4,
+						4,
+						4,
+						5,
+						5,
+						5,
+						5,
+						0,
+						0,
+						0,
+						0
+					],
+					ldef: new P(32),
+					df0: [
+						1,
+						2,
+						3,
+						4,
+						5,
+						7,
+						9,
+						13,
+						17,
+						25,
+						33,
+						49,
+						65,
+						97,
+						129,
+						193,
+						257,
+						385,
+						513,
+						769,
+						1025,
+						1537,
+						2049,
+						3073,
+						4097,
+						6145,
+						8193,
+						12289,
+						16385,
+						24577,
+						65535,
+						65535
+					],
+					dxb: [
+						0,
+						0,
+						0,
+						0,
+						1,
+						1,
+						2,
+						2,
+						3,
+						3,
+						4,
+						4,
+						5,
+						5,
+						6,
+						6,
+						7,
+						7,
+						8,
+						8,
+						9,
+						9,
+						10,
+						10,
+						11,
+						11,
+						12,
+						12,
+						13,
+						13,
+						0,
+						0
+					],
+					ddef: new H(32),
+					flmap: new P(512),
+					fltree: [],
+					fdmap: new P(32),
+					fdtree: [],
+					lmap: new P(32768),
+					ltree: [],
+					ttree: [],
+					dmap: new P(32768),
+					dtree: [],
+					imap: new P(512),
+					itree: [],
+					rev15: new P(32768),
+					lhst: new H(286),
+					dhst: new H(30),
+					ihst: new H(19),
+					lits: new H(15e3),
+					strt: new P(65536),
+					prev: new P(32768)
+				}), (function() {
+					for (var e = h.F.U, t = 0; t < 32768; t++) {
+						var u = t;
+						u = (4278255360 & (u = (4042322160 & (u = (3435973836 & (u = (2863311530 & u) >>> 1 | (1431655765 & u) << 1)) >>> 2 | (858993459 & u) << 2)) >>> 4 | (252645135 & u) << 4)) >>> 8 | (16711935 & u) << 8, e.rev15[t] = (u >>> 16 | u << 16) >>> 17;
+					}
+					function a(p, _, r) {
+						for (; _-- != 0;) p.push(0, r);
+					}
+					for (t = 0; t < 32; t++) e.ldef[t] = e.of0[t] << 3 | e.exb[t], e.ddef[t] = e.df0[t] << 4 | e.dxb[t];
+					a(e.fltree, 144, 8), a(e.fltree, 112, 9), a(e.fltree, 24, 7), a(e.fltree, 8, 8), h.F.makeCodes(e.fltree, 9), h.F.codes2map(e.fltree, 9, e.flmap), h.F.revCodes(e.fltree, 9), a(e.fdtree, 32, 5), h.F.makeCodes(e.fdtree, 5), h.F.codes2map(e.fdtree, 5, e.fdmap), h.F.revCodes(e.fdtree, 5), a(e.itree, 19, 0), a(e.ltree, 286, 0), a(e.dtree, 30, 0), a(e.ttree, 320, 0);
+				})();
+			})({
+				get exports() {
+					return Q;
+				},
+				set exports(T) {
+					Q = T;
+				}
+			});
+			var V = j({
+				__proto__: null,
+				default: Q
+			}, [Q]);
+			const K = (function() {
+				var T = {
+					nextZero(r, i) {
+						for (; r[i] != 0;) i++;
+						return i;
+					},
+					readUshort: (r, i) => r[i] << 8 | r[i + 1],
+					writeUshort(r, i, n) {
+						r[i] = n >> 8 & 255, r[i + 1] = 255 & n;
+					},
+					readUint: (r, i) => 16777216 * r[i] + (r[i + 1] << 16 | r[i + 2] << 8 | r[i + 3]),
+					writeUint(r, i, n) {
+						r[i] = n >> 24 & 255, r[i + 1] = n >> 16 & 255, r[i + 2] = n >> 8 & 255, r[i + 3] = 255 & n;
+					},
+					readASCII(r, i, n) {
+						let s = "";
+						for (let d = 0; d < n; d++) s += String.fromCharCode(r[i + d]);
+						return s;
+					},
+					writeASCII(r, i, n) {
+						for (let s = 0; s < n.length; s++) r[i + s] = n.charCodeAt(s);
+					},
+					readBytes(r, i, n) {
+						const s = [];
+						for (let d = 0; d < n; d++) s.push(r[i + d]);
+						return s;
+					},
+					pad: (r) => r.length < 2 ? `0${r}` : r,
+					readUTF8(r, i, n) {
+						let s, d = "";
+						for (let E = 0; E < n; E++) d += `%${T.pad(r[i + E].toString(16))}`;
+						try {
+							s = decodeURIComponent(d);
+						} catch {
+							return T.readASCII(r, i, n);
+						}
+						return s;
+					}
+				};
+				function P(r, i, n, s) {
+					const d = i * n, E = t(s), x = Math.ceil(i * E / 8), b = new Uint8Array(4 * d), D = new Uint32Array(b.buffer), { ctype: O } = s, { depth: M } = s, B = T.readUshort;
+					if (O == 6) {
+						const F = d << 2;
+						if (M == 8) for (var g = 0; g < F; g += 4) b[g] = r[g], b[g + 1] = r[g + 1], b[g + 2] = r[g + 2], b[g + 3] = r[g + 3];
+						if (M == 16) for (g = 0; g < F; g++) b[g] = r[g << 1];
+					} else if (O == 2) {
+						const F = s.tabs.tRNS;
+						if (F == null) {
+							if (M == 8) for (g = 0; g < d; g++) {
+								var R = 3 * g;
+								D[g] = 255 << 24 | r[R + 2] << 16 | r[R + 1] << 8 | r[R];
+							}
+							if (M == 16) for (g = 0; g < d; g++) R = 6 * g, D[g] = 255 << 24 | r[R + 4] << 16 | r[R + 2] << 8 | r[R];
+						} else {
+							var c = F[0];
+							const k = F[1], X = F[2];
+							if (M == 8) for (g = 0; g < d; g++) {
+								var f = g << 2;
+								R = 3 * g, D[g] = 255 << 24 | r[R + 2] << 16 | r[R + 1] << 8 | r[R], r[R] == c && r[R + 1] == k && r[R + 2] == X && (b[f + 3] = 0);
+							}
+							if (M == 16) for (g = 0; g < d; g++) f = g << 2, R = 6 * g, D[g] = 255 << 24 | r[R + 4] << 16 | r[R + 2] << 8 | r[R], B(r, R) == c && B(r, R + 2) == k && B(r, R + 4) == X && (b[f + 3] = 0);
+						}
+					} else if (O == 3) {
+						const F = s.tabs.PLTE, k = s.tabs.tRNS, X = k ? k.length : 0;
+						if (M == 1) for (var v = 0; v < n; v++) {
+							var w = v * x, y = v * i;
+							for (g = 0; g < i; g++) {
+								f = y + g << 2;
+								var U = 3 * (m = r[w + (g >> 3)] >> 7 - ((7 & g) << 0) & 1);
+								b[f] = F[U], b[f + 1] = F[U + 1], b[f + 2] = F[U + 2], b[f + 3] = m < X ? k[m] : 255;
+							}
+						}
+						if (M == 2) for (v = 0; v < n; v++) for (w = v * x, y = v * i, g = 0; g < i; g++) f = y + g << 2, U = 3 * (m = r[w + (g >> 2)] >> 6 - ((3 & g) << 1) & 3), b[f] = F[U], b[f + 1] = F[U + 1], b[f + 2] = F[U + 2], b[f + 3] = m < X ? k[m] : 255;
+						if (M == 4) for (v = 0; v < n; v++) for (w = v * x, y = v * i, g = 0; g < i; g++) f = y + g << 2, U = 3 * (m = r[w + (g >> 1)] >> 4 - ((1 & g) << 2) & 15), b[f] = F[U], b[f + 1] = F[U + 1], b[f + 2] = F[U + 2], b[f + 3] = m < X ? k[m] : 255;
+						if (M == 8) for (g = 0; g < d; g++) {
+							var m;
+							f = g << 2, U = 3 * (m = r[g]), b[f] = F[U], b[f + 1] = F[U + 1], b[f + 2] = F[U + 2], b[f + 3] = m < X ? k[m] : 255;
+						}
+					} else if (O == 4) {
+						if (M == 8) for (g = 0; g < d; g++) {
+							f = g << 2;
+							var I = r[l = g << 1];
+							b[f] = I, b[f + 1] = I, b[f + 2] = I, b[f + 3] = r[l + 1];
+						}
+						if (M == 16) for (g = 0; g < d; g++) {
+							var l;
+							f = g << 2, I = r[l = g << 2], b[f] = I, b[f + 1] = I, b[f + 2] = I, b[f + 3] = r[l + 2];
+						}
+					} else if (O == 0) for (c = s.tabs.tRNS ? s.tabs.tRNS : -1, v = 0; v < n; v++) {
+						const F = v * x, k = v * i;
+						if (M == 1) for (var o = 0; o < i; o++) {
+							var L = (I = 255 * (r[F + (o >>> 3)] >>> 7 - (7 & o) & 1)) == 255 * c ? 0 : 255;
+							D[k + o] = L << 24 | I << 16 | I << 8 | I;
+						}
+						else if (M == 2) for (o = 0; o < i; o++) L = (I = 85 * (r[F + (o >>> 2)] >>> 6 - ((3 & o) << 1) & 3)) == 85 * c ? 0 : 255, D[k + o] = L << 24 | I << 16 | I << 8 | I;
+						else if (M == 4) for (o = 0; o < i; o++) L = (I = 17 * (r[F + (o >>> 1)] >>> 4 - ((1 & o) << 2) & 15)) == 17 * c ? 0 : 255, D[k + o] = L << 24 | I << 16 | I << 8 | I;
+						else if (M == 8) for (o = 0; o < i; o++) L = (I = r[F + o]) == c ? 0 : 255, D[k + o] = L << 24 | I << 16 | I << 8 | I;
+						else if (M == 16) for (o = 0; o < i; o++) I = r[F + (o << 1)], L = B(r, F + (o << 1)) == c ? 0 : 255, D[k + o] = L << 24 | I << 16 | I << 8 | I;
+					}
+					return b;
+				}
+				function H(r, i, n, s) {
+					const d = t(r), E = Math.ceil(n * d / 8), x = new Uint8Array((E + 1 + r.interlace) * s);
+					return i = r.tabs.CgBI ? e(i, x) : h(i, x), r.interlace == 0 ? i = u(i, r, 0, n, s) : r.interlace == 1 && (i = (function(D, O) {
+						const M = O.width, B = O.height, g = t(O), R = g >> 3, c = Math.ceil(M * g / 8), f = new Uint8Array(B * c);
+						let v = 0;
+						const w = [
+							0,
+							0,
+							4,
+							0,
+							2,
+							0,
+							1
+						], y = [
+							0,
+							4,
+							0,
+							2,
+							0,
+							1,
+							0
+						], U = [
+							8,
+							8,
+							8,
+							4,
+							4,
+							2,
+							2
+						], m = [
+							8,
+							8,
+							4,
+							4,
+							2,
+							2,
+							1
+						];
+						let I = 0;
+						for (; I < 7;) {
+							const o = U[I], L = m[I];
+							let F = 0, k = 0, X = w[I];
+							for (; X < B;) X += o, k++;
+							let W = y[I];
+							for (; W < M;) W += L, F++;
+							const q = Math.ceil(F * g / 8);
+							u(D, O, v, F, k);
+							let N = 0, C = w[I];
+							for (; C < B;) {
+								let Y = y[I], oe = v + N * q << 3;
+								for (; Y < M;) {
+									var l;
+									if (g == 1 && (l = (l = D[oe >> 3]) >> 7 - (7 & oe) & 1, f[C * c + (Y >> 3)] |= l << 7 - ((7 & Y) << 0)), g == 2 && (l = (l = D[oe >> 3]) >> 6 - (7 & oe) & 3, f[C * c + (Y >> 2)] |= l << 6 - ((3 & Y) << 1)), g == 4 && (l = (l = D[oe >> 3]) >> 4 - (7 & oe) & 15, f[C * c + (Y >> 1)] |= l << 4 - ((1 & Y) << 2)), g >= 8) {
+										const te = C * c + Y * R;
+										for (let J = 0; J < R; J++) f[te + J] = D[(oe >> 3) + J];
+									}
+									oe += g, Y += L;
+								}
+								N++, C += o;
+							}
+							F * k != 0 && (v += k * (1 + q)), I += 1;
+						}
+						return f;
+					})(i, r)), i;
+				}
+				function h(r, i) {
+					return e(new Uint8Array(r.buffer, 2, r.length - 6), i);
+				}
+				var e = (function() {
+					const r = { H: {} };
+					return r.H.N = function(i, n) {
+						const s = Uint8Array;
+						let d, E, x = 0, b = 0, D = 0, O = 0, M = 0, B = 0, g = 0, R = 0, c = 0;
+						if (i[0] == 3 && i[1] == 0) return n || new s(0);
+						const f = r.H, v = f.b, w = f.e, y = f.R, U = f.n, m = f.A, I = f.Z, l = f.m, o = n == null;
+						for (o && (n = new s(i.length >>> 2 << 5)); x == 0;) if (x = v(i, c, 1), b = v(i, c + 1, 2), c += 3, b != 0) {
+							if (o && (n = r.H.W(n, R + (1 << 17))), b == 1 && (d = l.J, E = l.h, B = 511, g = 31), b == 2) {
+								D = w(i, c, 5) + 257, O = w(i, c + 5, 5) + 1, M = w(i, c + 10, 4) + 4, c += 14;
+								let F = 1;
+								for (var L = 0; L < 38; L += 2) l.Q[L] = 0, l.Q[L + 1] = 0;
+								for (L = 0; L < M; L++) {
+									const W = w(i, c + 3 * L, 3);
+									l.Q[1 + (l.X[L] << 1)] = W, W > F && (F = W);
+								}
+								c += 3 * M, U(l.Q, F), m(l.Q, F, l.u), d = l.w, E = l.d, c = y(l.u, (1 << F) - 1, D + O, i, c, l.v);
+								const k = f.V(l.v, 0, D, l.C);
+								B = (1 << k) - 1;
+								const X = f.V(l.v, D, O, l.D);
+								g = (1 << X) - 1, U(l.C, k), m(l.C, k, d), U(l.D, X), m(l.D, X, E);
+							}
+							for (;;) {
+								const F = d[I(i, c) & B];
+								c += 15 & F;
+								const k = F >>> 4;
+								if (!(k >>> 8)) n[R++] = k;
+								else {
+									if (k == 256) break;
+									{
+										let X = R + k - 254;
+										if (k > 264) {
+											const Y = l.q[k - 257];
+											X = R + (Y >>> 3) + w(i, c, 7 & Y), c += 7 & Y;
+										}
+										const W = E[I(i, c) & g];
+										c += 15 & W;
+										const q = W >>> 4, N = l.c[q], C = (N >>> 4) + v(i, c, 15 & N);
+										for (c += 15 & N; R < X;) n[R] = n[R++ - C], n[R] = n[R++ - C], n[R] = n[R++ - C], n[R] = n[R++ - C];
+										R = X;
+									}
+								}
+							}
+						} else {
+							7 & c && (c += 8 - (7 & c));
+							const F = 4 + (c >>> 3), k = i[F - 4] | i[F - 3] << 8;
+							o && (n = r.H.W(n, R + k)), n.set(new s(i.buffer, i.byteOffset + F, k), R), c = F + k << 3, R += k;
+						}
+						return n.length == R ? n : n.slice(0, R);
+					}, r.H.W = function(i, n) {
+						const s = i.length;
+						if (n <= s) return i;
+						const d = new Uint8Array(s << 1);
+						return d.set(i, 0), d;
+					}, r.H.R = function(i, n, s, d, E, x) {
+						const b = r.H.e, D = r.H.Z;
+						let O = 0;
+						for (; O < s;) {
+							const M = i[D(d, E) & n];
+							E += 15 & M;
+							const B = M >>> 4;
+							if (B <= 15) x[O] = B, O++;
+							else {
+								let g = 0, R = 0;
+								B == 16 ? (R = 3 + b(d, E, 2), E += 2, g = x[O - 1]) : B == 17 ? (R = 3 + b(d, E, 3), E += 3) : B == 18 && (R = 11 + b(d, E, 7), E += 7);
+								const c = O + R;
+								for (; O < c;) x[O] = g, O++;
+							}
+						}
+						return E;
+					}, r.H.V = function(i, n, s, d) {
+						let E = 0, x = 0;
+						const b = d.length >>> 1;
+						for (; x < s;) {
+							const D = i[x + n];
+							d[x << 1] = 0, d[1 + (x << 1)] = D, D > E && (E = D), x++;
+						}
+						for (; x < b;) d[x << 1] = 0, d[1 + (x << 1)] = 0, x++;
+						return E;
+					}, r.H.n = function(i, n) {
+						const s = r.H.m, d = i.length;
+						let E, x, b, D;
+						const O = s.j;
+						for (var M = 0; M <= n; M++) O[M] = 0;
+						for (M = 1; M < d; M += 2) O[i[M]]++;
+						const B = s.K;
+						for (E = 0, O[0] = 0, x = 1; x <= n; x++) E = E + O[x - 1] << 1, B[x] = E;
+						for (b = 0; b < d; b += 2) D = i[b + 1], D != 0 && (i[b] = B[D], B[D]++);
+					}, r.H.A = function(i, n, s) {
+						const d = i.length, E = r.H.m.r;
+						for (let x = 0; x < d; x += 2) if (i[x + 1] != 0) {
+							const b = x >> 1, D = i[x + 1], O = b << 4 | D, M = n - D;
+							let B = i[x] << M;
+							const g = B + (1 << M);
+							for (; B != g;) s[E[B] >>> 15 - n] = O, B++;
+						}
+					}, r.H.l = function(i, n) {
+						const s = r.H.m.r, d = 15 - n;
+						for (let E = 0; E < i.length; E += 2) i[E] = s[i[E] << n - i[E + 1]] >>> d;
+					}, r.H.M = function(i, n, s) {
+						s <<= 7 & n;
+						const d = n >>> 3;
+						i[d] |= s, i[d + 1] |= s >>> 8;
+					}, r.H.I = function(i, n, s) {
+						s <<= 7 & n;
+						const d = n >>> 3;
+						i[d] |= s, i[d + 1] |= s >>> 8, i[d + 2] |= s >>> 16;
+					}, r.H.e = function(i, n, s) {
+						return (i[n >>> 3] | i[1 + (n >>> 3)] << 8) >>> (7 & n) & (1 << s) - 1;
+					}, r.H.b = function(i, n, s) {
+						return (i[n >>> 3] | i[1 + (n >>> 3)] << 8 | i[2 + (n >>> 3)] << 16) >>> (7 & n) & (1 << s) - 1;
+					}, r.H.Z = function(i, n) {
+						return (i[n >>> 3] | i[1 + (n >>> 3)] << 8 | i[2 + (n >>> 3)] << 16) >>> (7 & n);
+					}, r.H.i = function(i, n) {
+						return (i[n >>> 3] | i[1 + (n >>> 3)] << 8 | i[2 + (n >>> 3)] << 16 | i[3 + (n >>> 3)] << 24) >>> (7 & n);
+					}, r.H.m = (function() {
+						const i = Uint16Array, n = Uint32Array;
+						return {
+							K: new i(16),
+							j: new i(16),
+							X: [
+								16,
+								17,
+								18,
+								0,
+								8,
+								7,
+								9,
+								6,
+								10,
+								5,
+								11,
+								4,
+								12,
+								3,
+								13,
+								2,
+								14,
+								1,
+								15
+							],
+							S: [
+								3,
+								4,
+								5,
+								6,
+								7,
+								8,
+								9,
+								10,
+								11,
+								13,
+								15,
+								17,
+								19,
+								23,
+								27,
+								31,
+								35,
+								43,
+								51,
+								59,
+								67,
+								83,
+								99,
+								115,
+								131,
+								163,
+								195,
+								227,
+								258,
+								999,
+								999,
+								999
+							],
+							T: [
+								0,
+								0,
+								0,
+								0,
+								0,
+								0,
+								0,
+								0,
+								1,
+								1,
+								1,
+								1,
+								2,
+								2,
+								2,
+								2,
+								3,
+								3,
+								3,
+								3,
+								4,
+								4,
+								4,
+								4,
+								5,
+								5,
+								5,
+								5,
+								0,
+								0,
+								0,
+								0
+							],
+							q: new i(32),
+							p: [
+								1,
+								2,
+								3,
+								4,
+								5,
+								7,
+								9,
+								13,
+								17,
+								25,
+								33,
+								49,
+								65,
+								97,
+								129,
+								193,
+								257,
+								385,
+								513,
+								769,
+								1025,
+								1537,
+								2049,
+								3073,
+								4097,
+								6145,
+								8193,
+								12289,
+								16385,
+								24577,
+								65535,
+								65535
+							],
+							z: [
+								0,
+								0,
+								0,
+								0,
+								1,
+								1,
+								2,
+								2,
+								3,
+								3,
+								4,
+								4,
+								5,
+								5,
+								6,
+								6,
+								7,
+								7,
+								8,
+								8,
+								9,
+								9,
+								10,
+								10,
+								11,
+								11,
+								12,
+								12,
+								13,
+								13,
+								0,
+								0
+							],
+							c: new n(32),
+							J: new i(512),
+							_: [],
+							h: new i(32),
+							$: [],
+							w: new i(32768),
+							C: [],
+							v: [],
+							d: new i(32768),
+							D: [],
+							u: new i(512),
+							Q: [],
+							r: new i(32768),
+							s: new n(286),
+							Y: new n(30),
+							a: new n(19),
+							t: new n(15e3),
+							k: new i(65536),
+							g: new i(32768)
+						};
+					})(), (function() {
+						const i = r.H.m;
+						for (var n = 0; n < 32768; n++) {
+							let d = n;
+							d = (2863311530 & d) >>> 1 | (1431655765 & d) << 1, d = (3435973836 & d) >>> 2 | (858993459 & d) << 2, d = (4042322160 & d) >>> 4 | (252645135 & d) << 4, d = (4278255360 & d) >>> 8 | (16711935 & d) << 8, i.r[n] = (d >>> 16 | d << 16) >>> 17;
+						}
+						function s(d, E, x) {
+							for (; E-- != 0;) d.push(0, x);
+						}
+						for (n = 0; n < 32; n++) i.q[n] = i.S[n] << 3 | i.T[n], i.c[n] = i.p[n] << 4 | i.z[n];
+						s(i._, 144, 8), s(i._, 112, 9), s(i._, 24, 7), s(i._, 8, 8), r.H.n(i._, 9), r.H.A(i._, 9, i.J), r.H.l(i._, 9), s(i.$, 32, 5), r.H.n(i.$, 5), r.H.A(i.$, 5, i.h), r.H.l(i.$, 5), s(i.Q, 19, 0), s(i.C, 286, 0), s(i.D, 30, 0), s(i.v, 320, 0);
+					})(), r.H.N;
+				})();
+				function t(r) {
+					return [
+						1,
+						null,
+						3,
+						1,
+						2,
+						null,
+						4
+					][r.ctype] * r.depth;
+				}
+				function u(r, i, n, s, d) {
+					let E = t(i);
+					const x = Math.ceil(s * E / 8);
+					let b, D;
+					E = Math.ceil(E / 8);
+					let O = r[n], M = 0;
+					if (O > 1 && (r[n] = [
+						0,
+						0,
+						1
+					][O - 2]), O == 3) for (M = E; M < x; M++) r[M + 1] = r[M + 1] + (r[M + 1 - E] >>> 1) & 255;
+					for (let B = 0; B < d; B++) if (b = n + B * x, D = b + B + 1, O = r[D - 1], M = 0, O == 0) for (; M < x; M++) r[b + M] = r[D + M];
+					else if (O == 1) {
+						for (; M < E; M++) r[b + M] = r[D + M];
+						for (; M < x; M++) r[b + M] = r[D + M] + r[b + M - E];
+					} else if (O == 2) for (; M < x; M++) r[b + M] = r[D + M] + r[b + M - x];
+					else if (O == 3) {
+						for (; M < E; M++) r[b + M] = r[D + M] + (r[b + M - x] >>> 1);
+						for (; M < x; M++) r[b + M] = r[D + M] + (r[b + M - x] + r[b + M - E] >>> 1);
+					} else {
+						for (; M < E; M++) r[b + M] = r[D + M] + a(0, r[b + M - x], 0);
+						for (; M < x; M++) r[b + M] = r[D + M] + a(r[b + M - E], r[b + M - x], r[b + M - E - x]);
+					}
+					return r;
+				}
+				function a(r, i, n) {
+					const s = r + i - n, d = s - r, E = s - i, x = s - n;
+					return d * d <= E * E && d * d <= x * x ? r : E * E <= x * x ? i : n;
+				}
+				function p(r, i, n) {
+					n.width = T.readUint(r, i), i += 4, n.height = T.readUint(r, i), i += 4, n.depth = r[i], i++, n.ctype = r[i], i++, n.compress = r[i], i++, n.filter = r[i], i++, n.interlace = r[i], i++;
+				}
+				function _(r, i, n, s, d, E, x, b, D) {
+					const O = Math.min(i, d), M = Math.min(n, E);
+					let B = 0, g = 0;
+					for (let I = 0; I < M; I++) for (let l = 0; l < O; l++) if (x >= 0 && b >= 0 ? (B = I * i + l << 2, g = (b + I) * d + x + l << 2) : (B = (-b + I) * i - x + l << 2, g = I * d + l << 2), D == 0) s[g] = r[B], s[g + 1] = r[B + 1], s[g + 2] = r[B + 2], s[g + 3] = r[B + 3];
+					else if (D == 1) {
+						var R = r[B + 3] * .00392156862745098, c = r[B] * R, f = r[B + 1] * R, v = r[B + 2] * R, w = s[g + 3] * (1 / 255), y = s[g] * w, U = s[g + 1] * w, m = s[g + 2] * w;
+						const o = 1 - R, L = R + w * o, F = L == 0 ? 0 : 1 / L;
+						s[g + 3] = 255 * L, s[g + 0] = (c + y * o) * F, s[g + 1] = (f + U * o) * F, s[g + 2] = (v + m * o) * F;
+					} else if (D == 2) R = r[B + 3], c = r[B], f = r[B + 1], v = r[B + 2], w = s[g + 3], y = s[g], U = s[g + 1], m = s[g + 2], R == w && c == y && f == U && v == m ? (s[g] = 0, s[g + 1] = 0, s[g + 2] = 0, s[g + 3] = 0) : (s[g] = c, s[g + 1] = f, s[g + 2] = v, s[g + 3] = R);
+					else if (D == 3) {
+						if (R = r[B + 3], c = r[B], f = r[B + 1], v = r[B + 2], w = s[g + 3], y = s[g], U = s[g + 1], m = s[g + 2], R == w && c == y && f == U && v == m) continue;
+						if (R < 220 && w > 20) return !1;
+					}
+					return !0;
+				}
+				return {
+					decode: function(i) {
+						const n = new Uint8Array(i);
+						let s = 8;
+						const d = T, E = d.readUshort, x = d.readUint, b = {
+							tabs: {},
+							frames: []
+						}, D = new Uint8Array(n.length);
+						let O, M = 0, B = 0;
+						const g = [
+							137,
+							80,
+							78,
+							71,
+							13,
+							10,
+							26,
+							10
+						];
+						for (var R = 0; R < 8; R++) if (n[R] != g[R]) throw "The input is not a PNG file!";
+						for (; s < n.length;) {
+							const I = d.readUint(n, s);
+							s += 4;
+							const l = d.readASCII(n, s, 4);
+							if (s += 4, l == "IHDR") p(n, s, b);
+							else if (l == "iCCP") {
+								for (var c = s; n[c] != 0;) c++;
+								d.readASCII(n, s, c - s), n[c + 1];
+								const o = n.slice(c + 2, s + I);
+								let L = null;
+								try {
+									L = h(o);
+								} catch {
+									L = e(o);
+								}
+								b.tabs[l] = L;
+							} else if (l == "CgBI") b.tabs[l] = n.slice(s, s + 4);
+							else if (l == "IDAT") {
+								for (R = 0; R < I; R++) D[M + R] = n[s + R];
+								M += I;
+							} else if (l == "acTL") b.tabs[l] = {
+								num_frames: x(n, s),
+								num_plays: x(n, s + 4)
+							}, O = new Uint8Array(n.length);
+							else if (l == "fcTL") {
+								B != 0 && ((m = b.frames[b.frames.length - 1]).data = H(b, O.slice(0, B), m.rect.width, m.rect.height), B = 0);
+								const o = {
+									x: x(n, s + 12),
+									y: x(n, s + 16),
+									width: x(n, s + 4),
+									height: x(n, s + 8)
+								};
+								let L = E(n, s + 22);
+								L = E(n, s + 20) / (L == 0 ? 100 : L);
+								const F = {
+									rect: o,
+									delay: Math.round(1e3 * L),
+									dispose: n[s + 24],
+									blend: n[s + 25]
+								};
+								b.frames.push(F);
+							} else if (l == "fdAT") {
+								for (R = 0; R < I - 4; R++) O[B + R] = n[s + R + 4];
+								B += I - 4;
+							} else if (l == "pHYs") b.tabs[l] = [
+								d.readUint(n, s),
+								d.readUint(n, s + 4),
+								n[s + 8]
+							];
+							else if (l == "cHRM") for (b.tabs[l] = [], R = 0; R < 8; R++) b.tabs[l].push(d.readUint(n, s + 4 * R));
+							else if (l == "tEXt" || l == "zTXt") {
+								b.tabs[l] ?? (b.tabs[l] = {});
+								var f = d.nextZero(n, s), v = d.readASCII(n, s, f - s), w = s + I - f - 1;
+								if (l == "tEXt") U = d.readASCII(n, f + 1, w);
+								else {
+									var y = h(n.slice(f + 2, f + 2 + w));
+									U = d.readUTF8(y, 0, y.length);
+								}
+								b.tabs[l][v] = U;
+							} else if (l == "iTXt") {
+								b.tabs[l] ?? (b.tabs[l] = {}), f = 0, c = s, f = d.nextZero(n, c), v = d.readASCII(n, c, f - c);
+								const o = n[c = f + 1];
+								var U;
+								n[c + 1], c += 2, f = d.nextZero(n, c), d.readASCII(n, c, f - c), c = f + 1, f = d.nextZero(n, c), d.readUTF8(n, c, f - c), w = I - ((c = f + 1) - s), o == 0 ? U = d.readUTF8(n, c, w) : (y = h(n.slice(c, c + w)), U = d.readUTF8(y, 0, y.length)), b.tabs[l][v] = U;
+							} else if (l == "PLTE") b.tabs[l] = d.readBytes(n, s, I);
+							else if (l == "hIST") {
+								const o = b.tabs.PLTE.length / 3;
+								for (b.tabs[l] = [], R = 0; R < o; R++) b.tabs[l].push(E(n, s + 2 * R));
+							} else if (l == "tRNS") b.ctype == 3 ? b.tabs[l] = d.readBytes(n, s, I) : b.ctype == 0 ? b.tabs[l] = E(n, s) : b.ctype == 2 && (b.tabs[l] = [
+								E(n, s),
+								E(n, s + 2),
+								E(n, s + 4)
+							]);
+							else if (l == "gAMA") b.tabs[l] = d.readUint(n, s) / 1e5;
+							else if (l == "sRGB") b.tabs[l] = n[s];
+							else if (l == "bKGD") b.ctype == 0 || b.ctype == 4 ? b.tabs[l] = [E(n, s)] : b.ctype == 2 || b.ctype == 6 ? b.tabs[l] = [
+								E(n, s),
+								E(n, s + 2),
+								E(n, s + 4)
+							] : b.ctype == 3 && (b.tabs[l] = n[s]);
+							else if (l == "IEND") break;
+							s += I, d.readUint(n, s), s += 4;
+						}
+						var m;
+						return B != 0 && ((m = b.frames[b.frames.length - 1]).data = H(b, O.slice(0, B), m.rect.width, m.rect.height)), b.data = H(b, D, b.width, b.height), delete b.compress, delete b.interlace, delete b.filter, b;
+					},
+					toRGBA8: function(i) {
+						const n = i.width, s = i.height;
+						if (i.tabs.acTL == null) return [P(i.data, n, s, i).buffer];
+						const d = [];
+						i.frames[0].data ?? (i.frames[0].data = i.data);
+						const E = n * s * 4, x = new Uint8Array(E), b = new Uint8Array(E), D = new Uint8Array(E);
+						for (let M = 0; M < i.frames.length; M++) {
+							const B = i.frames[M], g = B.rect.x, R = B.rect.y, c = B.rect.width, f = B.rect.height, v = P(B.data, c, f, i);
+							if (M != 0) for (var O = 0; O < E; O++) D[O] = x[O];
+							if (B.blend == 0 ? _(v, c, f, x, n, s, g, R, 0) : B.blend == 1 && _(v, c, f, x, n, s, g, R, 1), d.push(x.buffer.slice(0)), B.dispose != 0) {
+								if (B.dispose == 1) _(b, c, f, x, n, s, g, R, 0);
+								else if (B.dispose == 2) for (O = 0; O < E; O++) x[O] = D[O];
+							}
+						}
+						return d;
+					},
+					_paeth: a,
+					_copyTile: _,
+					_bin: T
+				};
+			})();
+			(function() {
+				const { _copyTile: T } = K, { _bin: P } = K, H = K._paeth;
+				var h = {
+					table: (function() {
+						const c = new Uint32Array(256);
+						for (let f = 0; f < 256; f++) {
+							let v = f;
+							for (let w = 0; w < 8; w++) 1 & v ? v = 3988292384 ^ v >>> 1 : v >>>= 1;
+							c[f] = v;
+						}
+						return c;
+					})(),
+					update(c, f, v, w) {
+						for (let y = 0; y < w; y++) c = h.table[255 & (c ^ f[v + y])] ^ c >>> 8;
+						return c;
+					},
+					crc: (c, f, v) => 4294967295 ^ h.update(4294967295, c, f, v)
+				};
+				function e(c, f, v, w) {
+					f[v] += c[0] * w >> 4, f[v + 1] += c[1] * w >> 4, f[v + 2] += c[2] * w >> 4, f[v + 3] += c[3] * w >> 4;
+				}
+				function t(c) {
+					return Math.max(0, Math.min(255, c));
+				}
+				function u(c, f) {
+					const v = c[0] - f[0], w = c[1] - f[1], y = c[2] - f[2], U = c[3] - f[3];
+					return v * v + w * w + y * y + U * U;
+				}
+				function a(c, f, v, w, y, U, m) {
+					m ??= 1;
+					const I = w.length, l = [];
+					for (var o = 0; o < I; o++) {
+						const C = w[o];
+						l.push([
+							C >>> 0 & 255,
+							C >>> 8 & 255,
+							C >>> 16 & 255,
+							C >>> 24 & 255
+						]);
+					}
+					for (o = 0; o < I; o++) {
+						let C = 4294967295;
+						for (var L = 0, F = 0; F < I; F++) {
+							var k = u(l[o], l[F]);
+							F != o && k < C && (C = k, L = F);
+						}
+					}
+					const X = new Uint32Array(y.buffer), W = new Int16Array(f * v * 4), q = [
+						0,
+						8,
+						2,
+						10,
+						12,
+						4,
+						14,
+						6,
+						3,
+						11,
+						1,
+						9,
+						15,
+						7,
+						13,
+						5
+					];
+					for (o = 0; o < q.length; o++) q[o] = 255 * ((q[o] + .5) / 16 - .5);
+					for (let C = 0; C < v; C++) for (let Y = 0; Y < f; Y++) {
+						var N;
+						o = 4 * (C * f + Y), m != 2 ? N = [
+							t(c[o] + W[o]),
+							t(c[o + 1] + W[o + 1]),
+							t(c[o + 2] + W[o + 2]),
+							t(c[o + 3] + W[o + 3])
+						] : (k = q[4 * (3 & C) + (3 & Y)], N = [
+							t(c[o] + k),
+							t(c[o + 1] + k),
+							t(c[o + 2] + k),
+							t(c[o + 3] + k)
+						]), L = 0;
+						let oe = 16777215;
+						for (F = 0; F < I; F++) {
+							const re = u(N, l[F]);
+							re < oe && (oe = re, L = F);
+						}
+						const te = l[L], J = [
+							N[0] - te[0],
+							N[1] - te[1],
+							N[2] - te[2],
+							N[3] - te[3]
+						];
+						m == 1 && (Y != f - 1 && e(J, W, o + 4, 7), C != v - 1 && (Y != 0 && e(J, W, o + 4 * f - 4, 3), e(J, W, o + 4 * f, 5), Y != f - 1 && e(J, W, o + 4 * f + 4, 1))), U[o >> 2] = L, X[o >> 2] = w[L];
+					}
+				}
+				function p(c, f, v, w, y) {
+					y ??= {};
+					const { crc: U } = h, m = P.writeUint, I = P.writeUshort, l = P.writeASCII;
+					let o = 8;
+					const L = c.frames.length > 1;
+					let F, k = !1, X = 33 + (L ? 20 : 0);
+					if (y.sRGB != null && (X += 13), y.pHYs != null && (X += 21), y.iCCP != null && (F = pako.deflate(y.iCCP), X += 21 + F.length + 4), c.ctype == 3) {
+						for (var W = c.plte.length, q = 0; q < W; q++) c.plte[q] >>> 24 != 255 && (k = !0);
+						X += 8 + 3 * W + 4 + (k ? 8 + 1 * W + 4 : 0);
+					}
+					for (var N = 0; N < c.frames.length; N++) L && (X += 38), X += (te = c.frames[N]).cimg.length + 12, N != 0 && (X += 4);
+					X += 12;
+					const C = new Uint8Array(X), Y = [
+						137,
+						80,
+						78,
+						71,
+						13,
+						10,
+						26,
+						10
+					];
+					for (q = 0; q < 8; q++) C[q] = Y[q];
+					if (m(C, o, 13), o += 4, l(C, o, "IHDR"), o += 4, m(C, o, f), o += 4, m(C, o, v), o += 4, C[o] = c.depth, o++, C[o] = c.ctype, o++, C[o] = 0, o++, C[o] = 0, o++, C[o] = 0, o++, m(C, o, U(C, o - 17, 17)), o += 4, y.sRGB != null && (m(C, o, 1), o += 4, l(C, o, "sRGB"), o += 4, C[o] = y.sRGB, o++, m(C, o, U(C, o - 5, 5)), o += 4), y.iCCP != null) {
+						const J = 13 + F.length;
+						m(C, o, J), o += 4, l(C, o, "iCCP"), o += 4, l(C, o, "ICC profile"), o += 11, o += 2, C.set(F, o), o += F.length, m(C, o, U(C, o - (J + 4), J + 4)), o += 4;
+					}
+					if (y.pHYs != null && (m(C, o, 9), o += 4, l(C, o, "pHYs"), o += 4, m(C, o, y.pHYs[0]), o += 4, m(C, o, y.pHYs[1]), o += 4, C[o] = y.pHYs[2], o++, m(C, o, U(C, o - 13, 13)), o += 4), L && (m(C, o, 8), o += 4, l(C, o, "acTL"), o += 4, m(C, o, c.frames.length), o += 4, m(C, o, y.loop != null ? y.loop : 0), o += 4, m(C, o, U(C, o - 12, 12)), o += 4), c.ctype == 3) {
+						for (m(C, o, 3 * (W = c.plte.length)), o += 4, l(C, o, "PLTE"), o += 4, q = 0; q < W; q++) {
+							const J = 3 * q, re = c.plte[q], fe = 255 & re, ce = re >>> 8 & 255, He = re >>> 16 & 255;
+							C[o + J + 0] = fe, C[o + J + 1] = ce, C[o + J + 2] = He;
+						}
+						if (o += 3 * W, m(C, o, U(C, o - 3 * W - 4, 3 * W + 4)), o += 4, k) {
+							for (m(C, o, W), o += 4, l(C, o, "tRNS"), o += 4, q = 0; q < W; q++) C[o + q] = c.plte[q] >>> 24 & 255;
+							o += W, m(C, o, U(C, o - W - 4, W + 4)), o += 4;
+						}
+					}
+					let oe = 0;
+					for (N = 0; N < c.frames.length; N++) {
+						var te = c.frames[N];
+						L && (m(C, o, 26), o += 4, l(C, o, "fcTL"), o += 4, m(C, o, oe++), o += 4, m(C, o, te.rect.width), o += 4, m(C, o, te.rect.height), o += 4, m(C, o, te.rect.x), o += 4, m(C, o, te.rect.y), o += 4, I(C, o, w[N]), o += 2, I(C, o, 1e3), o += 2, C[o] = te.dispose, o++, C[o] = te.blend, o++, m(C, o, U(C, o - 30, 30)), o += 4);
+						const J = te.cimg;
+						m(C, o, (W = J.length) + (N == 0 ? 0 : 4)), o += 4;
+						const re = o;
+						l(C, o, N == 0 ? "IDAT" : "fdAT"), o += 4, N != 0 && (m(C, o, oe++), o += 4), C.set(J, o), o += W, m(C, o, U(C, re, o - re)), o += 4;
+					}
+					return m(C, o, 0), o += 4, l(C, o, "IEND"), o += 4, m(C, o, U(C, o - 4, 4)), o += 4, C.buffer;
+				}
+				function _(c, f, v) {
+					for (let w = 0; w < c.frames.length; w++) {
+						const y = c.frames[w];
+						y.rect.width;
+						const U = y.rect.height, m = new Uint8Array(U * y.bpl + U);
+						y.cimg = s(y.img, U, y.bpp, y.bpl, m, f, v);
+					}
+				}
+				function r(c, f, v, w, y) {
+					const U = y[0], m = y[1], I = y[2], l = y[3], o = y[4], L = y[5];
+					let F = 6, k = 8, X = 255;
+					for (var W = 0; W < c.length; W++) {
+						const be = new Uint8Array(c[W]);
+						for (var q = be.length, N = 0; N < q; N += 4) X &= be[N + 3];
+					}
+					const C = X != 255, Y = (function(ne, ae, he, de, we, ge) {
+						const pe = [];
+						for (var ie = 0; ie < ne.length; ie++) {
+							const Ae = new Uint8Array(ne[ie]), Fe = new Uint32Array(Ae.buffer);
+							var _e;
+							let Te = 0, Pe = 0, Ce = ae, Ne = he, vt = de ? 1 : 0;
+							if (ie != 0) {
+								const Un = ge || de || ie == 1 || pe[ie - 2].dispose != 0 ? 1 : 2;
+								let bt = 0, Ot = 1e9;
+								for (let et = 0; et < Un; et++) {
+									var Je = new Uint8Array(ne[ie - 1 - et]);
+									const En = new Uint32Array(ne[ie - 1 - et]);
+									let Le = ae, ke = he, Ke = -1, tt = -1;
+									for (let We = 0; We < he; We++) for (let ze = 0; ze < ae; ze++) Fe[Oe = We * ae + ze] != En[Oe] && (ze < Le && (Le = ze), ze > Ke && (Ke = ze), We < ke && (ke = We), We > tt && (tt = We));
+									Ke == -1 && (Le = ke = Ke = tt = 0), we && ((1 & Le) == 1 && Le--, (1 & ke) == 1 && ke--);
+									const Lt = (Ke - Le + 1) * (tt - ke + 1);
+									Lt < Ot && (Ot = Lt, bt = et, Te = Le, Pe = ke, Ce = Ke - Le + 1, Ne = tt - ke + 1);
+								}
+								Je = new Uint8Array(ne[ie - 1 - bt]), bt == 1 && (pe[ie - 1].dispose = 2), _e = new Uint8Array(Ce * Ne * 4), T(Je, ae, he, _e, Ce, Ne, -Te, -Pe, 0), vt = T(Ae, ae, he, _e, Ce, Ne, -Te, -Pe, 3) ? 1 : 0, vt == 1 ? n(Ae, ae, he, _e, {
+									x: Te,
+									y: Pe,
+									width: Ce,
+									height: Ne
+								}) : T(Ae, ae, he, _e, Ce, Ne, -Te, -Pe, 0);
+							} else _e = Ae.slice(0);
+							pe.push({
+								rect: {
+									x: Te,
+									y: Pe,
+									width: Ce,
+									height: Ne
+								},
+								img: _e,
+								blend: vt,
+								dispose: 0
+							});
+						}
+						if (de) for (ie = 0; ie < pe.length; ie++) {
+							if ((je = pe[ie]).blend == 1) continue;
+							const Ae = je.rect, Fe = pe[ie - 1].rect, Te = Math.min(Ae.x, Fe.x), Pe = Math.min(Ae.y, Fe.y), Ce = {
+								x: Te,
+								y: Pe,
+								width: Math.max(Ae.x + Ae.width, Fe.x + Fe.width) - Te,
+								height: Math.max(Ae.y + Ae.height, Fe.y + Fe.height) - Pe
+							};
+							pe[ie - 1].dispose = 1, ie - 1 != 0 && i(ne, ae, he, pe, ie - 1, Ce, we), i(ne, ae, he, pe, ie, Ce, we);
+						}
+						let Ue = 0;
+						if (ne.length != 1) for (var Oe = 0; Oe < pe.length; Oe++) {
+							var je;
+							Ue += (je = pe[Oe]).rect.width * je.rect.height;
+						}
+						return pe;
+					})(c, f, v, U, m, I), oe = {}, te = [], J = [];
+					if (w != 0) {
+						const be = [];
+						for (N = 0; N < Y.length; N++) be.push(Y[N].img.buffer);
+						const ne = E((function(de) {
+							let we = 0;
+							for (var ge = 0; ge < de.length; ge++) we += de[ge].byteLength;
+							const pe = new Uint8Array(we);
+							let ie = 0;
+							for (ge = 0; ge < de.length; ge++) {
+								const _e = new Uint8Array(de[ge]), Je = _e.length;
+								for (let Ue = 0; Ue < Je; Ue += 4) {
+									let Oe = _e[Ue], je = _e[Ue + 1], Ae = _e[Ue + 2];
+									const Fe = _e[Ue + 3];
+									Fe == 0 && (Oe = je = Ae = 0), pe[ie + Ue] = Oe, pe[ie + Ue + 1] = je, pe[ie + Ue + 2] = Ae, pe[ie + Ue + 3] = Fe;
+								}
+								ie += Je;
+							}
+							return pe.buffer;
+						})(be), w);
+						for (N = 0; N < ne.plte.length; N++) te.push(ne.plte[N].est.rgba);
+						let ae = 0;
+						for (N = 0; N < Y.length; N++) {
+							const he = (fe = Y[N]).img.length;
+							var re = new Uint8Array(ne.inds.buffer, ae >> 2, he >> 2);
+							J.push(re);
+							const de = new Uint8Array(ne.abuf, ae, he);
+							L && a(fe.img, fe.rect.width, fe.rect.height, te, de, re), fe.img.set(de), ae += he;
+						}
+					} else for (W = 0; W < Y.length; W++) {
+						var fe = Y[W];
+						const be = new Uint32Array(fe.img.buffer);
+						var ce = fe.rect.width;
+						for (q = be.length, re = new Uint8Array(q), J.push(re), N = 0; N < q; N++) {
+							const ne = be[N];
+							if (N != 0 && ne == be[N - 1]) re[N] = re[N - 1];
+							else if (N > ce && ne == be[N - ce]) re[N] = re[N - ce];
+							else {
+								let ae = oe[ne];
+								if (ae == null && (oe[ne] = ae = te.length, te.push(ne), te.length >= 300)) break;
+								re[N] = ae;
+							}
+						}
+					}
+					const He = te.length;
+					for (He <= 256 && o == 0 && (k = He <= 2 ? 1 : He <= 4 ? 2 : He <= 16 ? 4 : 8, k = Math.max(k, l)), W = 0; W < Y.length; W++) {
+						(fe = Y[W]).rect.x, fe.rect.y, ce = fe.rect.width;
+						const be = fe.rect.height;
+						let ne = fe.img;
+						new Uint32Array(ne.buffer);
+						let ae = 4 * ce, he = 4;
+						if (He <= 256 && o == 0) {
+							ae = Math.ceil(k * ce / 8);
+							var Se = new Uint8Array(ae * be);
+							const de = J[W];
+							for (let we = 0; we < be; we++) {
+								N = we * ae;
+								const ge = we * ce;
+								if (k == 8) for (var se = 0; se < ce; se++) Se[N + se] = de[ge + se];
+								else if (k == 4) for (se = 0; se < ce; se++) Se[N + (se >> 1)] |= de[ge + se] << 4 - 4 * (1 & se);
+								else if (k == 2) for (se = 0; se < ce; se++) Se[N + (se >> 2)] |= de[ge + se] << 6 - 2 * (3 & se);
+								else if (k == 1) for (se = 0; se < ce; se++) Se[N + (se >> 3)] |= de[ge + se] << 7 - 1 * (7 & se);
+							}
+							ne = Se, F = 3, he = 1;
+						} else if (C == 0 && Y.length == 1) {
+							Se = new Uint8Array(ce * be * 3);
+							const de = ce * be;
+							for (N = 0; N < de; N++) {
+								const we = 3 * N, ge = 4 * N;
+								Se[we] = ne[ge], Se[we + 1] = ne[ge + 1], Se[we + 2] = ne[ge + 2];
+							}
+							ne = Se, F = 2, he = 3, ae = 3 * ce;
+						}
+						fe.img = ne, fe.bpl = ae, fe.bpp = he;
+					}
+					return {
+						ctype: F,
+						depth: k,
+						plte: te,
+						frames: Y
+					};
+				}
+				function i(c, f, v, w, y, U, m) {
+					const I = Uint8Array, l = Uint32Array, o = new I(c[y - 1]), L = new l(c[y - 1]), F = y + 1 < c.length ? new I(c[y + 1]) : null, k = new I(c[y]), X = new l(k.buffer);
+					let W = f, q = v, N = -1, C = -1;
+					for (let oe = 0; oe < U.height; oe++) for (let te = 0; te < U.width; te++) {
+						const J = U.x + te, re = U.y + oe, fe = re * f + J, ce = X[fe];
+						ce == 0 || w[y - 1].dispose == 0 && L[fe] == ce && (F == null || F[4 * fe + 3] != 0) || (J < W && (W = J), J > N && (N = J), re < q && (q = re), re > C && (C = re));
+					}
+					N == -1 && (W = q = N = C = 0), m && ((1 & W) == 1 && W--, (1 & q) == 1 && q--), U = {
+						x: W,
+						y: q,
+						width: N - W + 1,
+						height: C - q + 1
+					};
+					const Y = w[y];
+					Y.rect = U, Y.blend = 1, Y.img = new Uint8Array(U.width * U.height * 4), w[y - 1].dispose == 0 ? (T(o, f, v, Y.img, U.width, U.height, -U.x, -U.y, 0), n(k, f, v, Y.img, U)) : T(k, f, v, Y.img, U.width, U.height, -U.x, -U.y, 0);
+				}
+				function n(c, f, v, w, y) {
+					T(c, f, v, w, y.width, y.height, -y.x, -y.y, 2);
+				}
+				function s(c, f, v, w, y, U, m) {
+					const I = [];
+					let l, o = [
+						0,
+						1,
+						2,
+						3,
+						4
+					];
+					U != -1 ? o = [U] : (f * w > 5e5 || v == 1) && (o = [0]), m && (l = { level: 0 });
+					const L = V;
+					for (var F = 0; F < o.length; F++) {
+						for (let W = 0; W < f; W++) d(y, c, W, w, v, o[F]);
+						I.push(L.deflate(y, l));
+					}
+					let k, X = 1e9;
+					for (F = 0; F < I.length; F++) I[F].length < X && (k = F, X = I[F].length);
+					return I[k];
+				}
+				function d(c, f, v, w, y, U) {
+					const m = v * w;
+					let I = m + v;
+					if (c[I] = U, I++, U == 0) if (w < 500) for (var l = 0; l < w; l++) c[I + l] = f[m + l];
+					else c.set(new Uint8Array(f.buffer, m, w), I);
+					else if (U == 1) {
+						for (l = 0; l < y; l++) c[I + l] = f[m + l];
+						for (l = y; l < w; l++) c[I + l] = f[m + l] - f[m + l - y] + 256 & 255;
+					} else if (v == 0) {
+						for (l = 0; l < y; l++) c[I + l] = f[m + l];
+						if (U == 2) for (l = y; l < w; l++) c[I + l] = f[m + l];
+						if (U == 3) for (l = y; l < w; l++) c[I + l] = f[m + l] - (f[m + l - y] >> 1) + 256 & 255;
+						if (U == 4) for (l = y; l < w; l++) c[I + l] = f[m + l] - H(f[m + l - y], 0, 0) + 256 & 255;
+					} else {
+						if (U == 2) for (l = 0; l < w; l++) c[I + l] = f[m + l] + 256 - f[m + l - w] & 255;
+						if (U == 3) {
+							for (l = 0; l < y; l++) c[I + l] = f[m + l] + 256 - (f[m + l - w] >> 1) & 255;
+							for (l = y; l < w; l++) c[I + l] = f[m + l] + 256 - (f[m + l - w] + f[m + l - y] >> 1) & 255;
+						}
+						if (U == 4) {
+							for (l = 0; l < y; l++) c[I + l] = f[m + l] + 256 - H(0, f[m + l - w], 0) & 255;
+							for (l = y; l < w; l++) c[I + l] = f[m + l] + 256 - H(f[m + l - y], f[m + l - w], f[m + l - y - w]) & 255;
+						}
+					}
+				}
+				function E(c, f) {
+					const v = new Uint8Array(c), w = v.slice(0), y = new Uint32Array(w.buffer), U = x(w, f), m = U[0], I = U[1], l = v.length, o = new Uint8Array(l >> 2);
+					let L;
+					if (v.length < 2e7) for (var F = 0; F < l; F += 4) L = b(m, k = v[F] * (1 / 255), X = v[F + 1] * (1 / 255), W = v[F + 2] * (1 / 255), q = v[F + 3] * (1 / 255)), o[F >> 2] = L.ind, y[F >> 2] = L.est.rgba;
+					else for (F = 0; F < l; F += 4) {
+						var k = v[F] * .00392156862745098, X = v[F + 1] * (1 / 255), W = v[F + 2] * (1 / 255), q = v[F + 3] * (1 / 255);
+						for (L = m; L.left;) L = D(L.est, k, X, W, q) <= 0 ? L.left : L.right;
+						o[F >> 2] = L.ind, y[F >> 2] = L.est.rgba;
+					}
+					return {
+						abuf: w.buffer,
+						inds: o,
+						plte: I
+					};
+				}
+				function x(c, f, v) {
+					v ??= 1e-4;
+					const w = new Uint32Array(c.buffer), y = {
+						i0: 0,
+						i1: c.length,
+						bst: null,
+						est: null,
+						tdst: 0,
+						left: null,
+						right: null
+					};
+					y.bst = B(c, y.i0, y.i1), y.est = g(y.bst);
+					const U = [y];
+					for (; U.length < f;) {
+						let I = 0, l = 0;
+						for (var m = 0; m < U.length; m++) U[m].est.L > I && (I = U[m].est.L, l = m);
+						if (I < v) break;
+						const o = U[l], L = O(c, w, o.i0, o.i1, o.est.e, o.est.eMq255);
+						if (o.i0 >= L || o.i1 <= L) {
+							o.est.L = 0;
+							continue;
+						}
+						const F = {
+							i0: o.i0,
+							i1: L,
+							bst: null,
+							est: null,
+							tdst: 0,
+							left: null,
+							right: null
+						};
+						F.bst = B(c, F.i0, F.i1), F.est = g(F.bst);
+						const k = {
+							i0: L,
+							i1: o.i1,
+							bst: null,
+							est: null,
+							tdst: 0,
+							left: null,
+							right: null
+						};
+						for (k.bst = {
+							R: [],
+							m: [],
+							N: o.bst.N - F.bst.N
+						}, m = 0; m < 16; m++) k.bst.R[m] = o.bst.R[m] - F.bst.R[m];
+						for (m = 0; m < 4; m++) k.bst.m[m] = o.bst.m[m] - F.bst.m[m];
+						k.est = g(k.bst), o.left = F, o.right = k, U[l] = F, U.push(k);
+					}
+					for (U.sort(((I, l) => l.bst.N - I.bst.N)), m = 0; m < U.length; m++) U[m].ind = m;
+					return [y, U];
+				}
+				function b(c, f, v, w, y) {
+					if (c.left == null) return c.tdst = (function(F, k, X, W, q) {
+						const N = k - F[0], C = X - F[1], Y = W - F[2], oe = q - F[3];
+						return N * N + C * C + Y * Y + oe * oe;
+					})(c.est.q, f, v, w, y), c;
+					const U = D(c.est, f, v, w, y);
+					let m = c.left, I = c.right;
+					U > 0 && (m = c.right, I = c.left);
+					const l = b(m, f, v, w, y);
+					if (l.tdst <= U * U) return l;
+					const o = b(I, f, v, w, y);
+					return o.tdst < l.tdst ? o : l;
+				}
+				function D(c, f, v, w, y) {
+					const { e: U } = c;
+					return U[0] * f + U[1] * v + U[2] * w + U[3] * y - c.eMq;
+				}
+				function O(c, f, v, w, y, U) {
+					for (w -= 4; v < w;) {
+						for (; M(c, v, y) <= U;) v += 4;
+						for (; M(c, w, y) > U;) w -= 4;
+						if (v >= w) break;
+						const m = f[v >> 2];
+						f[v >> 2] = f[w >> 2], f[w >> 2] = m, v += 4, w -= 4;
+					}
+					for (; M(c, v, y) > U;) v -= 4;
+					return v + 4;
+				}
+				function M(c, f, v) {
+					return c[f] * v[0] + c[f + 1] * v[1] + c[f + 2] * v[2] + c[f + 3] * v[3];
+				}
+				function B(c, f, v) {
+					const w = [
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0,
+						0
+					], y = [
+						0,
+						0,
+						0,
+						0
+					], U = v - f >> 2;
+					for (let m = f; m < v; m += 4) {
+						const I = c[m] * .00392156862745098, l = c[m + 1] * (1 / 255), o = c[m + 2] * (1 / 255), L = c[m + 3] * (1 / 255);
+						y[0] += I, y[1] += l, y[2] += o, y[3] += L, w[0] += I * I, w[1] += I * l, w[2] += I * o, w[3] += I * L, w[5] += l * l, w[6] += l * o, w[7] += l * L, w[10] += o * o, w[11] += o * L, w[15] += L * L;
+					}
+					return w[4] = w[1], w[8] = w[2], w[9] = w[6], w[12] = w[3], w[13] = w[7], w[14] = w[11], {
+						R: w,
+						m: y,
+						N: U
+					};
+				}
+				function g(c) {
+					const { R: f } = c, { m: v } = c, { N: w } = c, y = v[0], U = v[1], m = v[2], I = v[3], l = w == 0 ? 0 : 1 / w, o = [
+						f[0] - y * y * l,
+						f[1] - y * U * l,
+						f[2] - y * m * l,
+						f[3] - y * I * l,
+						f[4] - U * y * l,
+						f[5] - U * U * l,
+						f[6] - U * m * l,
+						f[7] - U * I * l,
+						f[8] - m * y * l,
+						f[9] - m * U * l,
+						f[10] - m * m * l,
+						f[11] - m * I * l,
+						f[12] - I * y * l,
+						f[13] - I * U * l,
+						f[14] - I * m * l,
+						f[15] - I * I * l
+					], L = o, F = R;
+					let k = [
+						Math.random(),
+						Math.random(),
+						Math.random(),
+						Math.random()
+					], X = 0, W = 0;
+					if (w != 0) for (let N = 0; N < 16 && (k = F.multVec(L, k), W = Math.sqrt(F.dot(k, k)), k = F.sml(1 / W, k), !(N != 0 && Math.abs(W - X) < 1e-9)); N++) X = W;
+					const q = [
+						y * l,
+						U * l,
+						m * l,
+						I * l
+					];
+					return {
+						Cov: o,
+						q,
+						e: k,
+						L: X,
+						eMq255: F.dot(F.sml(255, q), k),
+						eMq: F.dot(k, q),
+						rgba: (Math.round(255 * q[3]) << 24 | Math.round(255 * q[2]) << 16 | Math.round(255 * q[1]) << 8 | Math.round(255 * q[0]) << 0) >>> 0
+					};
+				}
+				var R = {
+					multVec: (c, f) => [
+						c[0] * f[0] + c[1] * f[1] + c[2] * f[2] + c[3] * f[3],
+						c[4] * f[0] + c[5] * f[1] + c[6] * f[2] + c[7] * f[3],
+						c[8] * f[0] + c[9] * f[1] + c[10] * f[2] + c[11] * f[3],
+						c[12] * f[0] + c[13] * f[1] + c[14] * f[2] + c[15] * f[3]
+					],
+					dot: (c, f) => c[0] * f[0] + c[1] * f[1] + c[2] * f[2] + c[3] * f[3],
+					sml: (c, f) => [
+						c * f[0],
+						c * f[1],
+						c * f[2],
+						c * f[3]
+					]
+				};
+				K.encode = function(f, v, w, y, U, m, I) {
+					y ??= 0, I ??= !1;
+					const l = r(f, v, w, y, [
+						!1,
+						!1,
+						!1,
+						0,
+						I,
+						!1
+					]);
+					return _(l, -1), p(l, v, w, U, m);
+				}, K.encodeLL = function(f, v, w, y, U, m, I, l) {
+					const o = {
+						ctype: 0 + (y == 1 ? 0 : 2) + (U == 0 ? 0 : 4),
+						depth: m,
+						frames: []
+					}, L = (y + U) * m, F = L * v;
+					for (let k = 0; k < f.length; k++) o.frames.push({
+						rect: {
+							x: 0,
+							y: 0,
+							width: v,
+							height: w
+						},
+						img: new Uint8Array(f[k]),
+						blend: 0,
+						dispose: 1,
+						bpp: Math.ceil(L / 8),
+						bpl: Math.ceil(F / 8)
+					});
+					return _(o, 0, !0), p(o, v, w, I, l);
+				}, K.encode.compress = r, K.encode.dither = a, K.quantize = E, K.quantize.getKDtree = x, K.quantize.getNearest = b;
+			})();
+			const Z = {
+				toArrayBuffer(T, P) {
+					const H = T.width, h = T.height, e = H << 2, t = T.getContext("2d").getImageData(0, 0, H, h), u = new Uint32Array(t.data.buffer), a = (32 * H + 31) / 32 << 2, p = a * h, _ = 122 + p, r = new ArrayBuffer(_), i = new DataView(r), n = 1 << 20;
+					let s, d, E, x, b = n, D = 0, O = 0, M = 0;
+					function B(c) {
+						i.setUint16(O, c, !0), O += 2;
+					}
+					function g(c) {
+						i.setUint32(O, c, !0), O += 4;
+					}
+					function R(c) {
+						O += c;
+					}
+					B(19778), g(_), R(4), g(122), g(108), g(H), g(-h >>> 0), B(1), B(32), g(3), g(p), g(2835), g(2835), R(8), g(16711680), g(65280), g(255), g(4278190080), g(1466527264), (function c() {
+						for (; D < h && b > 0;) {
+							for (x = 122 + D * a, s = 0; s < e;) b--, d = u[M++], E = d >>> 24, i.setUint32(x + s, d << 8 | E), s += 4;
+							D++;
+						}
+						M < u.length ? (b = n, setTimeout(c, Z._dly)) : P(r);
+					})();
+				},
+				toBlob(T, P) {
+					this.toArrayBuffer(T, ((H) => {
+						P(new Blob([H], { type: "image/bmp" }));
+					}));
+				},
+				_dly: 9
+			};
+			var z = {
+				CHROME: "CHROME",
+				FIREFOX: "FIREFOX",
+				DESKTOP_SAFARI: "DESKTOP_SAFARI",
+				IE: "IE",
+				IOS: "IOS",
+				ETC: "ETC"
+			}, ue = {
+				[z.CHROME]: 16384,
+				[z.FIREFOX]: 11180,
+				[z.DESKTOP_SAFARI]: 16384,
+				[z.IE]: 8192,
+				[z.IOS]: 4096,
+				[z.ETC]: 8192
+			};
+			const ee = typeof window < "u", Me = typeof WorkerGlobalScope < "u" && self instanceof WorkerGlobalScope, ye = ee && window.cordova && window.cordova.require && window.cordova.require("cordova/modulemapper"), Ee = (ee || Me) && (ye && ye.getOriginalSymbol(window, "File") || typeof File < "u" && File), ot = (ee || Me) && (ye && ye.getOriginalSymbol(window, "FileReader") || typeof FileReader < "u" && FileReader);
+			function Be(T, P, H = Date.now()) {
+				return new Promise(((h) => {
+					const e = T.split(","), t = e[0].match(/:(.*?);/)[1], u = globalThis.atob(e[1]);
+					let a = u.length;
+					const p = new Uint8Array(a);
+					for (; a--;) p[a] = u.charCodeAt(a);
+					const _ = new Blob([p], { type: t });
+					_.name = P, _.lastModified = H, h(_);
+				}));
+			}
+			function Ye(T) {
+				return new Promise(((P, H) => {
+					const h = new ot();
+					h.onload = () => P(h.result), h.onerror = (e) => H(e), h.readAsDataURL(T);
+				}));
+			}
+			function qe(T) {
+				return new Promise(((P, H) => {
+					const h = new Image();
+					h.onload = () => P(h), h.onerror = (e) => H(e), h.src = T;
+				}));
+			}
+			function me() {
+				if (me.cachedResult !== void 0) return me.cachedResult;
+				let T = z.ETC;
+				const { userAgent: P } = navigator;
+				return /Chrom(e|ium)/i.test(P) ? T = z.CHROME : /iP(ad|od|hone)/i.test(P) && /WebKit/i.test(P) ? T = z.IOS : /Safari/i.test(P) ? T = z.DESKTOP_SAFARI : /Firefox/i.test(P) ? T = z.FIREFOX : (/MSIE/i.test(P) || document.documentMode) && (T = z.IE), me.cachedResult = T, me.cachedResult;
+			}
+			function Re(T, P) {
+				const H = ue[me()];
+				let h = T, e = P, t = h * e;
+				const u = h > e ? e / h : h / e;
+				for (; t > H * H;) {
+					const a = (H + h) / 2, p = (H + e) / 2;
+					a < p ? (e = p, h = p * u) : (e = a * u, h = a), t = h * e;
+				}
+				return {
+					width: h,
+					height: e
+				};
+			}
+			function De(T, P) {
+				let H, h;
+				try {
+					if (H = new OffscreenCanvas(T, P), h = H.getContext("2d"), h === null) throw new Error("getContext of OffscreenCanvas returns null");
+				} catch {
+					H = document.createElement("canvas"), h = H.getContext("2d");
+				}
+				return H.width = T, H.height = P, [H, h];
+			}
+			function $e(T, P) {
+				const { width: H, height: h } = Re(T.width, T.height), [e, t] = De(H, h);
+				return P && /jpe?g/.test(P) && (t.fillStyle = "white", t.fillRect(0, 0, e.width, e.height)), t.drawImage(T, 0, 0, e.width, e.height), e;
+			}
+			function Ze() {
+				return Ze.cachedResult !== void 0 || (Ze.cachedResult = [
+					"iPad Simulator",
+					"iPhone Simulator",
+					"iPod Simulator",
+					"iPad",
+					"iPhone",
+					"iPod"
+				].includes(navigator.platform) || navigator.userAgent.includes("Mac") && typeof document < "u" && "ontouchend" in document), Ze.cachedResult;
+			}
+			function at(T, P = {}) {
+				return new Promise((function(H, h) {
+					let e, t;
+					var u = function() {
+						try {
+							return t = $e(e, P.fileType || T.type), H([e, t]);
+						} catch (p) {
+							return h(p);
+						}
+					}, a = function(p) {
+						try {
+							var _ = function(r) {
+								try {
+									throw r;
+								} catch (i) {
+									return h(i);
+								}
+							};
+							try {
+								let r;
+								return Ye(T).then((function(i) {
+									try {
+										return r = i, qe(r).then((function(n) {
+											try {
+												return e = n, (function() {
+													try {
+														return u();
+													} catch (s) {
+														return h(s);
+													}
+												})();
+											} catch (s) {
+												return _(s);
+											}
+										}), _);
+									} catch (n) {
+										return _(n);
+									}
+								}), _);
+							} catch (r) {
+								_(r);
+							}
+						} catch (r) {
+							return h(r);
+						}
+					};
+					try {
+						if (Ze() || [z.DESKTOP_SAFARI, z.MOBILE_SAFARI].includes(me())) throw new Error("Skip createImageBitmap on IOS and Safari");
+						return createImageBitmap(T).then((function(p) {
+							try {
+								return e = p, u();
+							} catch {
+								return a();
+							}
+						}), a);
+					} catch {
+						a();
+					}
+				}));
+			}
+			function st(T, P, H, h, e = 1) {
+				return new Promise((function(t, u) {
+					let a;
+					if (P === "image/png") {
+						let _, r, i;
+						return _ = T.getContext("2d"), {data: r} = _.getImageData(0, 0, T.width, T.height), i = K.encode([r.buffer], T.width, T.height, 4096 * e), a = new Blob([i], { type: P }), a.name = H, a.lastModified = h, p.call(this);
+					}
+					{
+						let _ = function() {
+							return p.call(this);
+						};
+						if (P === "image/bmp") return new Promise(((r) => Z.toBlob(T, r))).then(function(r) {
+							try {
+								return a = r, a.name = H, a.lastModified = h, _.call(this);
+							} catch (i) {
+								return u(i);
+							}
+						}.bind(this), u);
+						{
+							let r = function() {
+								return _.call(this);
+							};
+							if (typeof OffscreenCanvas == "function" && T instanceof OffscreenCanvas) return T.convertToBlob({
+								type: P,
+								quality: e
+							}).then(function(i) {
+								try {
+									return a = i, a.name = H, a.lastModified = h, r.call(this);
+								} catch (n) {
+									return u(n);
+								}
+							}.bind(this), u);
+							{
+								let i;
+								return i = T.toDataURL(P, e), Be(i, H, h).then(function(n) {
+									try {
+										return a = n, r.call(this);
+									} catch (s) {
+										return u(s);
+									}
+								}.bind(this), u);
+							}
+						}
+					}
+					function p() {
+						return t(a);
+					}
+				}));
+			}
+			function xe(T) {
+				T.width = 0, T.height = 0;
+			}
+			function Xe() {
+				return new Promise((function(T, P) {
+					let H, h, e, t;
+					return Xe.cachedResult !== void 0 ? T(Xe.cachedResult) : Be("data:image/jpeg;base64,/9j/4QAiRXhpZgAATU0AKgAAAAgAAQESAAMAAAABAAYAAAAAAAD/2wCEAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAf/AABEIAAEAAgMBEQACEQEDEQH/xABKAAEAAAAAAAAAAAAAAAAAAAALEAEAAAAAAAAAAAAAAAAAAAAAAQEAAAAAAAAAAAAAAAAAAAAAEQEAAAAAAAAAAAAAAAAAAAAA/9oADAMBAAIRAxEAPwA/8H//2Q==", "test.jpg", Date.now()).then((function(u) {
+						try {
+							return H = u, at(H).then((function(a) {
+								try {
+									return h = a[1], st(h, H.type, H.name, H.lastModified).then((function(p) {
+										try {
+											return e = p, xe(h), at(e).then((function(_) {
+												try {
+													return t = _[0], Xe.cachedResult = t.width === 1 && t.height === 2, T(Xe.cachedResult);
+												} catch (r) {
+													return P(r);
+												}
+											}), P);
+										} catch (_) {
+											return P(_);
+										}
+									}), P);
+								} catch (p) {
+									return P(p);
+								}
+							}), P);
+						} catch (a) {
+							return P(a);
+						}
+					}), P);
+				}));
+			}
+			function Ct(T) {
+				return new Promise(((P, H) => {
+					const h = new ot();
+					h.onload = (e) => {
+						const t = new DataView(e.target.result);
+						if (t.getUint16(0, !1) != 65496) return P(-2);
+						const u = t.byteLength;
+						let a = 2;
+						for (; a < u;) {
+							if (t.getUint16(a + 2, !1) <= 8) return P(-1);
+							const p = t.getUint16(a, !1);
+							if (a += 2, p == 65505) {
+								if (t.getUint32(a += 2, !1) != 1165519206) return P(-1);
+								const _ = t.getUint16(a += 6, !1) == 18761;
+								a += t.getUint32(a + 4, _);
+								const r = t.getUint16(a, _);
+								a += 2;
+								for (let i = 0; i < r; i++) if (t.getUint16(a + 12 * i, _) == 274) return P(t.getUint16(a + 12 * i + 8, _));
+							} else {
+								if ((65280 & p) != 65280) break;
+								a += t.getUint16(a, !1);
+							}
+						}
+						return P(-1);
+					}, h.onerror = (e) => H(e), h.readAsArrayBuffer(T);
+				}));
+			}
+			function Rt(T, P) {
+				const { width: H } = T, { height: h } = T, { maxWidthOrHeight: e } = P;
+				let t, u = T;
+				return isFinite(e) && (H > e || h > e) && ([u, t] = De(H, h), H > h ? (u.width = e, u.height = h / H * e) : (u.width = H / h * e, u.height = e), t.drawImage(T, 0, 0, u.width, u.height), xe(T)), u;
+			}
+			function Tt(T, P) {
+				const { width: H } = T, { height: h } = T, [e, t] = De(H, h);
+				switch (P > 4 && P < 9 ? (e.width = h, e.height = H) : (e.width = H, e.height = h), P) {
+					case 2:
+						t.transform(-1, 0, 0, 1, H, 0);
+						break;
+					case 3:
+						t.transform(-1, 0, 0, -1, H, h);
+						break;
+					case 4:
+						t.transform(1, 0, 0, -1, 0, h);
+						break;
+					case 5:
+						t.transform(0, 1, 1, 0, 0, 0);
+						break;
+					case 6:
+						t.transform(0, 1, -1, 0, h, 0);
+						break;
+					case 7:
+						t.transform(0, -1, -1, 0, h, H);
+						break;
+					case 8: t.transform(0, -1, 1, 0, 0, H);
+				}
+				return t.drawImage(T, 0, 0, H, h), xe(T), e;
+			}
+			function Pt(T, P, H = 0) {
+				return new Promise((function(h, e) {
+					let t, u, a, p, _, r, i, n, s, d, E, x, b, D, O, M, B, g, R, c;
+					function f(w = 5) {
+						if (P.signal && P.signal.aborted) throw P.signal.reason;
+						t += w, P.onProgress(Math.min(t, 100));
+					}
+					function v(w) {
+						if (P.signal && P.signal.aborted) throw P.signal.reason;
+						t = Math.min(Math.max(w, t), 100), P.onProgress(t);
+					}
+					return t = H, u = P.maxIteration || 10, a = 1024 * P.maxSizeMB * 1024, f(), at(T, P).then(function(w) {
+						try {
+							return [, p] = w, f(), _ = Rt(p, P), f(), new Promise((function(y, U) {
+								var m;
+								if (!(m = P.exifOrientation)) return Ct(T).then(function(l) {
+									try {
+										return m = l, I.call(this);
+									} catch (o) {
+										return U(o);
+									}
+								}.bind(this), U);
+								function I() {
+									return y(m);
+								}
+								return I.call(this);
+							})).then(function(y) {
+								try {
+									return r = y, f(), Xe().then(function(U) {
+										try {
+											return i = U ? _ : Tt(_, r), f(), n = P.initialQuality || 1, s = P.fileType || T.type, st(i, s, T.name, T.lastModified, n).then(function(m) {
+												try {
+													{
+														let l = function() {
+															if (u-- && (O > a || O > b)) {
+																let L, F;
+																return L = c ? .95 * R.width : R.width, F = c ? .95 * R.height : R.height, [B, g] = De(L, F), g.drawImage(R, 0, 0, L, F), n *= s === "image/png" ? .85 : .95, st(B, s, T.name, T.lastModified, n).then((function(k) {
+																	try {
+																		return M = k, xe(R), R = B, O = M.size, v(Math.min(99, Math.floor((D - O) / (D - a) * 100))), l;
+																	} catch (X) {
+																		return e(X);
+																	}
+																}), e);
+															}
+															return [1];
+														}, o = function() {
+															return xe(R), xe(B), xe(_), xe(i), xe(p), v(100), h(M);
+														};
+														if (d = m, f(), E = d.size > a, x = d.size > T.size, !E && !x) return v(100), h(d);
+														var I;
+														return b = T.size, D = d.size, O = D, R = i, c = !P.alwaysKeepResolution && E, (I = function(L) {
+															for (; L;) {
+																if (L.then) return void L.then(I, e);
+																try {
+																	if (L.pop) {
+																		if (L.length) return L.pop() ? o.call(this) : L;
+																		L = l;
+																	} else L = L.call(this);
+																} catch (F) {
+																	return e(F);
+																}
+															}
+														}.bind(this))(l);
+													}
+												} catch (l) {
+													return e(l);
+												}
+											}.bind(this), e);
+										} catch (m) {
+											return e(m);
+										}
+									}.bind(this), e);
+								} catch (U) {
+									return e(U);
+								}
+							}.bind(this), e);
+						} catch (y) {
+							return e(y);
+						}
+					}.bind(this), e);
+				}));
+			}
+			const An = `
+let scriptImported = false
+self.addEventListener('message', async (e) => {
+  const { file, id, imageCompressionLibUrl, options } = e.data
+  options.onProgress = (progress) => self.postMessage({ progress, id })
+  try {
+    if (!scriptImported) {
+      // console.log('[worker] importScripts', imageCompressionLibUrl)
+      self.importScripts(imageCompressionLibUrl)
+      scriptImported = true
+    }
+    // console.log('[worker] self', self)
+    const compressedFile = await imageCompression(file, options)
+    self.postMessage({ file: compressedFile, id })
+  } catch (e) {
+    // console.error('[worker] error', e)
+    self.postMessage({ error: e.message + '\\n' + e.stack, id })
+  }
+})
+`;
+			let mt;
+			function _n(T, P) {
+				return new Promise(((H, h) => {
+					mt || (mt = (function(u) {
+						const a = [];
+						return typeof u == "function" ? a.push(`(${u})()`) : a.push(u), URL.createObjectURL(new Blob(a));
+					})(An));
+					const e = new Worker(mt);
+					e.addEventListener("message", (function(u) {
+						if (P.signal && P.signal.aborted) e.terminate();
+						else if (u.data.progress === void 0) {
+							if (u.data.error) return h(new Error(u.data.error)), void e.terminate();
+							H(u.data.file), e.terminate();
+						} else P.onProgress(u.data.progress);
+					})), e.addEventListener("error", h), P.signal && P.signal.addEventListener("abort", (() => {
+						h(P.signal.reason), e.terminate();
+					})), e.postMessage({
+						file: T,
+						imageCompressionLibUrl: P.libURL,
+						options: {
+							...P,
+							onProgress: void 0,
+							signal: void 0
+						}
+					});
+				}));
+			}
+			function ve(T, P) {
+				return new Promise((function(H, h) {
+					let e, t, u, a, p, _;
+					if (e = { ...P }, u = 0, {onProgress: a} = e, e.maxSizeMB = e.maxSizeMB || Number.POSITIVE_INFINITY, p = typeof e.useWebWorker != "boolean" || e.useWebWorker, delete e.useWebWorker, e.onProgress = (s) => {
+						u = s, typeof a == "function" && a(u);
+					}, !(T instanceof Blob || T instanceof Ee)) return h(new Error("The file given is not an instance of Blob or File"));
+					if (!/^image/.test(T.type)) return h(new Error("The file given is not an image"));
+					if (_ = typeof WorkerGlobalScope < "u" && self instanceof WorkerGlobalScope, !p || typeof Worker != "function" || _) return Pt(T, e).then(function(s) {
+						try {
+							return t = s, n.call(this);
+						} catch (d) {
+							return h(d);
+						}
+					}.bind(this), h);
+					var r = function() {
+						try {
+							return n.call(this);
+						} catch (s) {
+							return h(s);
+						}
+					}.bind(this), i = function(s) {
+						try {
+							return Pt(T, e).then((function(d) {
+								try {
+									return t = d, r();
+								} catch (E) {
+									return h(E);
+								}
+							}), h);
+						} catch (d) {
+							return h(d);
+						}
+					};
+					try {
+						return e.libURL = e.libURL || "https://cdn.jsdelivr.net/npm/browser-image-compression@2.0.2/dist/browser-image-compression.js", _n(T, e).then((function(s) {
+							try {
+								return t = s, r();
+							} catch {
+								return i();
+							}
+						}), i);
+					} catch {
+						i();
+					}
+					function n() {
+						try {
+							t.name = T.name, t.lastModified = T.lastModified;
+						} catch {}
+						try {
+							e.preserveExif && T.type === "image/jpeg" && (!e.fileType || e.fileType && e.fileType === T.type) && (t = G(T, t));
+						} catch {}
+						return H(t);
+					}
+				}));
+			}
+			return ve.getDataUrlFromFile = Ye, ve.getFilefromDataUrl = Be, ve.loadImage = qe, ve.drawImageInCanvas = $e, ve.drawFileInCanvas = at, ve.canvasToFile = st, ve.getExifOrientation = Ct, ve.handleMaxWidthOrHeight = Rt, ve.followExifOrientation = Tt, ve.cleanupCanvasMemory = xe, ve.isAutoOrientationInBrowser = Xe, ve.approximateBelowMaximumCanvasSizeOfBrowser = Re, ve.copyExifWithoutOrientation = G, ve.getBrowserName = me, ve.version = "2.0.2", ve;
+		}));
+	})), Jt = Ve.__toESM(Zt()), gt = (A) => {
+		if (!A) return "image/png";
+		const S = A.toLowerCase();
+		return S.includes("jpeg") || S.includes("jpg") || S.includes("pjpeg") ? "image/jpeg" : S.includes("png") ? "image/png" : S.includes("gif") ? "image/gif" : S.includes("webp") ? "image/webp" : S.includes("svg") ? "image/svg+xml" : "image/png";
+	}, Ut = (A) => {
+		const S = gt(A).split("/")[1];
+		return S === "svg+xml" ? "svg" : S || "png";
+	};
+	function nt(A) {
+		switch (A.trim().split(".").pop()?.toLowerCase()) {
+			case "svg": return "image/svg+xml";
+			case "png": return "image/png";
+			case "jpg":
+			case "jpeg": return "image/jpeg";
+			case "gif": return "image/gif";
+			case "webp": return "image/webp";
+			default: return;
+		}
+	}
+	function Et(A) {
+		if (A.type?.startsWith?.("image/")) return !0;
+		const S = (A.name ?? "").trim();
+		if (nt(S)) return !0;
+		const j = (A.type ?? "").toLowerCase();
+		return j.includes("svg") ? !0 : j === "text/xml" || j === "application/xml" || j === "text/plain" ? S.toLowerCase().endsWith(".svg") : !1;
+	}
+	var rt = {
+		MAX_SIZE_MB: .48,
+		MAX_WIDTH_OR_HEIGHT: 2e3,
+		QUALITY: .8
+	}, en = ["gif", "svg"];
+	function tn(A) {
+		return !en.includes(A);
+	}
+	function Ft(A, S) {
+		if (A?.compressMaxSize === 0 || A?.compressMaxWidthOrHeight === 0) return !1;
+		const j = S?.trim() ?? "";
+		return j.startsWith("image/") && j !== "image/gif";
+	}
+	function It(A) {
+		return {
+			maxSizeMB: A?.compressMaxSize ?? rt.MAX_SIZE_MB,
+			maxWidthOrHeight: A?.compressMaxWidthOrHeight ?? rt.MAX_WIDTH_OR_HEIGHT
+		};
+	}
+	function Mt(A) {
+		if (!A) return null;
+		const S = A.trim();
+		if (S.endsWith("%")) return null;
+		const j = parseFloat(S.replace(/px$/i, ""));
+		return Number.isFinite(j) && j > 0 ? j : null;
+	}
+	function nn(A) {
+		const S = A.match(/<\s*svg\b[\s\S]*?>/i)?.[0] ?? "", j = S.match(/\bwidth\s*=\s*["']([^"']*)["']/i)?.[1], G = S.match(/\bheight\s*=\s*["']([^"']*)["']/i)?.[1], $ = Mt(j), Q = Mt(G);
+		if ($ != null && Q != null) return {
+			width: $,
+			height: Q
+		};
+		const V = A.match(/viewBox\s*=\s*["']([^"']+)["']/i)?.[1];
+		if (V) {
+			const K = V.trim().split(/[\s,]+/);
+			if (K.length === 4) {
+				const Z = parseFloat(K[2]), z = parseFloat(K[3]);
+				if (Number.isFinite(Z) && Number.isFinite(z) && Z > 0 && z > 0) return {
+					width: Z,
+					height: z
+				};
+			}
+		}
+		return $ != null ? {
+			width: $,
+			height: $
+		} : Q != null ? {
+			width: Q,
+			height: Q
+		} : {
+			width: 300,
+			height: 300
+		};
+	}
+	function rn(A, S = 2, j = 4096) {
+		const { width: G, height: $ } = nn(A);
+		let Q = Math.max(1, Math.round(G * S)), V = Math.max(1, Math.round($ * S));
+		const K = Math.max(64, j), Z = Math.max(Q, V);
+		if (Z > K) {
+			const z = K / Z;
+			Q = Math.max(1, Math.round(Q * z)), V = Math.max(1, Math.round(V * z));
+		}
+		return {
+			width: Q,
+			height: V
+		};
+	}
+	function on(A) {
+		return new Promise((S, j) => {
+			A.toBlob((G) => {
+				G ? S(G) : j(new Error("canvas.toBlob returned null"));
+			}, "image/png");
+		});
+	}
+	async function an(A, S, j) {
+		const G = new Blob([A], { type: "image/svg+xml;charset=utf-8" }), $ = URL.createObjectURL(G);
+		try {
+			const Q = new Image();
+			await new Promise((ue, ee) => {
+				Q.onload = () => ue(), Q.onerror = () => ee(new Error("Failed to load SVG image")), Q.src = $;
+			});
+			const V = document.createElement("canvas"), K = Math.max(1, Math.round(S)), Z = Math.max(1, Math.round(j));
+			V.width = K, V.height = Z;
+			const z = V.getContext("2d");
+			if (!z) throw new Error("Canvas 2D context is not available");
+			return z.clearRect(0, 0, K, Z), z.drawImage(Q, 0, 0, K, Z), on(V);
+		} finally {
+			URL.revokeObjectURL($);
+		}
+	}
+	var sn = 24e3;
+	async function fn(A, S = sn) {
+		const j = Math.min(S, Math.max(0, A.size));
+		return A.slice(0, j).text();
+	}
+	function cn(A) {
+		const S = A.trimStart().replace(/^\uFEFF/, "");
+		return S.startsWith("<") ? /<\s*svg[\s>/]/i.test(S) : !1;
+	}
+	async function ln(A, S = {}) {
+		const j = S.pixelScale ?? 2, G = S.maxLongEdge ?? 4096, $ = await A.text(), { width: Q, height: V } = rn($, j, G), K = await an($, Q, V), Z = S.outputFileName ?? A.name, z = /\.svg$/i.test(Z) ? Z.replace(/\.svg$/i, ".png") : `${Z}.png`;
+		return new File([K], z, {
+			type: "image/png",
+			lastModified: A.lastModified
+		});
+	}
+	function it(A, S, j, G) {
+		return new File([A], S, {
+			type: j,
+			lastModified: G
+		});
+	}
+	function pt(A, S) {
+		return !S || S === A.name ? A : it(A, S, A.type, A.lastModified);
+	}
+	function un(A, S, j, G) {
+		const $ = G ?? S.name;
+		return A instanceof File ? A.type !== j || A.lastModified !== S.lastModified || A.name !== $ ? it(A, $, j, S.lastModified) : A : it(A, $, j, S.lastModified);
+	}
+	function hn(A, S) {
+		const j = S.startsWith(".") ? S.slice(1) : S, G = A.lastIndexOf(".");
+		return G > 0 ? `${A.substring(0, G)}.${j}` : `${A}.${j}`;
+	}
+	function dn(A) {
+		return A === "image/webp" ? "image/jpeg" : A;
+	}
+	async function xt(A, S = {}) {
+		const { maxSizeMB: j = rt.MAX_SIZE_MB, maxWidthOrHeight: G = rt.MAX_WIDTH_OR_HEIGHT, mimeType: $, fileName: Q, libURL: V, enableCompression: K = !0, convertSvgToPng: Z = !1 } = S;
+		if (!A || !(A instanceof File)) return A;
+		let z = A, ue = !1;
+		if (Z) {
+			const me = (z.type || "").toLowerCase(), Re = /\.svg$/i.test(z.name.trim()), De = me.includes("svg");
+			let $e = !1;
+			if (!De && !Re) try {
+				$e = cn(await fn(z));
+			} catch {
+				$e = !1;
+			}
+			if (De || Re || $e) try {
+				z = await ln(z, {
+					maxLongEdge: G,
+					outputFileName: Q ?? z.name
+				}), ue = !0;
+			} catch {
+				z = A;
+			}
+		}
+		const ee = gt((z.type && z.type.trim() !== "" ? z.type : nt(z.name)) || (ue ? "image/png" : $) || "image/jpeg"), Me = ue ? z.name : Q ?? z.name;
+		if (!ee.startsWith("image/")) return pt(z, Me);
+		const ye = dn(ee), Ee = Ut(ee), ot = Ut(ye), Be = ye !== ee ? hn(Me, ot) : Me, Ye = K && tn(Ee);
+		if (!Ye && ye === ee) return pt(z, Be);
+		const qe = z.type === ee ? z : it(z, z.name, ee, z.lastModified);
+		try {
+			const me = {
+				libURL: V,
+				useWebWorker: !0,
+				fileType: ye
+			};
+			Ye ? (me.maxSizeMB = j, me.maxWidthOrHeight = G) : (me.maxSizeMB = Math.max(qe.size / (1024 * 1024) + 1, 1), me.initialQuality = 1, me.alwaysKeepResolution = !0);
+			const Re = await (0, Jt.default)(qe, me);
+			return un(Re, qe, gt(Re.type || ye), Be);
+		} catch {
+			try {
+				return pt(z, Be);
+			} catch {
+				return z;
+			}
+		}
+	}
+	var gn = "js/browser-image-compression.js";
+	function St() {
+		return kt.getBundledHostAssetUrl(gn);
+	}
+	async function pn(A, S, j = St()) {
+		if (!Et(A)) return A;
+		const { maxSizeMB: G, maxWidthOrHeight: $ } = It(S), Q = A.type?.trim() || nt(A.name) || A.type || "";
+		return xt(A, {
+			maxSizeMB: G,
+			maxWidthOrHeight: $,
+			mimeType: Q || void 0,
+			fileName: A.name,
+			libURL: j,
+			enableCompression: Ft(S, Q),
+			convertSvgToPng: !0
+		});
+	}
+	async function mn(A, S) {
+		if (!A || typeof A.findFileByUrl != "function") return null;
+		const j = await A.findFileByUrl(S);
+		if (!j) return null;
+		const G = typeof A.getFileById == "function" && j.id && await A.getFileById(j.id) || j, $ = G.url || S, Q = G.thumbnailUrl || G.thumbnail || $ || (typeof A.getThumbnailUrl == "function" ? await A.getThumbnailUrl(G) : "") || "";
+		return Q ? {
+			file: G,
+			previewUrl: Q
+		} : null;
+	}
+	function vn(A) {
+		if (!(A instanceof Blob) || A.size === 0) throw new ft.Yn("Failed to download file from the URL.", "UploadUrlDownloadFailed");
+		const S = A.type?.split(";")[0]?.trim() || "image/png";
+		if (!S.startsWith("image/")) throw new ft.Yn("Content type at the URL is not allowed.", "UploadUrlContentTypeNotAllowed");
+		return {
+			blob: A,
+			mimeType: S
+		};
+	}
+	async function bn(A, S) {
+		const j = await fetch(A, S);
+		if (!j.ok) throw new Error(`Server returned ${j.status}`);
+		return j.blob();
+	}
+	async function yn(A, S, j) {
+		const G = j ? { signal: j } : void 0, { blob: $ } = await ft.yi(A, {
+			handleFileProxy: async (Q) => yt.pickFileProxyBlobFromFireResults(await S.fireFileProxy(Q)) ?? null,
+			handleProxyUrl: async (Q) => yt.pickProxyUrlOverrideFromFireResults(await S.fireProxyUrl(Q), Q),
+			fetchWithProxy: (Q, V, K) => Ie.fetchWithResourceProxy(Q, {
+				config: S.appConfig,
+				standalone: S.isStandalone,
+				intent: K?.intent || "downloadBlob",
+				validateBlob: async (Z) => !Z.type || Z.type.startsWith("image/"),
+				init: V
+			})
+		}, (Q) => bn(Q, G), vn, { fetchInit: G });
+		return $;
+	}
+	function wn() {
+		const A = Ie.useAppConfig(), S = Ie.useIsStandalone(), j = Ie.useSelector(Ie.selectProject), { projectId: G } = Ie.useParams(), $ = j?.id !== void 0 ? String(j.id) : G || "", Q = Ie.useEventEmitter(Ie.events.FILE_PROXY_EVENT_ID), V = Ie.useEventEmitter(Ie.events.PROXY_URL_EVENT_ID);
+		return (0, Bt.useCallback)(async (K, Z) => yn(K, {
+			appConfig: A,
+			isStandalone: S,
+			fireFileProxy: (z) => Q.fire({
+				url: z,
+				project: $
+			}),
+			fireProxyUrl: (z) => V.fire({
+				url: z,
+				project: $
+			})
+		}, Z), [
+			A,
+			$,
+			S,
+			Q,
+			V
+		]);
+	}
+	Object.defineProperty(le, "canonicalImageUrlKey", {
+		enumerable: !0,
+		get: function() {
+			return dt;
+		}
+	}), Object.defineProperty(le, "createImageUrlBlobResolver", {
+		enumerable: !0,
+		get: function() {
+			return Yt;
+		}
+	}), Object.defineProperty(le, "getAiTariffUpgradeStep", {
+		enumerable: !0,
+		get: function() {
+			return Xt;
+		}
+	}), Object.defineProperty(le, "getBrowserImageCompressionLibUrl", {
+		enumerable: !0,
+		get: function() {
+			return St;
+		}
+	}), Object.defineProperty(le, "getImageDimensionsFromBlob", {
+		enumerable: !0,
+		get: function() {
+			return Vt;
+		}
+	}), Object.defineProperty(le, "inferImageMimeFromFileName", {
+		enumerable: !0,
+		get: function() {
+			return nt;
+		}
+	}), Object.defineProperty(le, "isAiLimitReached", {
+		enumerable: !0,
+		get: function() {
+			return Nt;
+		}
+	}), Object.defineProperty(le, "isAllowedImageUploadFile", {
+		enumerable: !0,
+		get: function() {
+			return Et;
+		}
+	}), Object.defineProperty(le, "normalizeImageFormatForDisplay", {
+		enumerable: !0,
+		get: function() {
+			return Kt;
+		}
+	}), Object.defineProperty(le, "prepareImageForEditorUpload", {
+		enumerable: !0,
+		get: function() {
+			return pn;
+		}
+	}), Object.defineProperty(le, "prepareImageForUpload", {
+		enumerable: !0,
+		get: function() {
+			return xt;
+		}
+	}), Object.defineProperty(le, "require_prop_types", {
+		enumerable: !0,
+		get: function() {
+			return jt;
+		}
+	}), Object.defineProperty(le, "resolveAutoLimitUpgrade", {
+		enumerable: !0,
+		get: function() {
+			return $t;
+		}
+	}), Object.defineProperty(le, "resolveDataProviderPreview", {
+		enumerable: !0,
+		get: function() {
+			return mn;
+		}
+	}), Object.defineProperty(le, "resolveImageCompressionLimits", {
+		enumerable: !0,
+		get: function() {
+			return It;
+		}
+	}), Object.defineProperty(le, "shouldCountAiUsage", {
+		enumerable: !0,
+		get: function() {
+			return wt;
+		}
+	}), Object.defineProperty(le, "shouldEnableImageCompression", {
+		enumerable: !0,
+		get: function() {
+			return Ft;
+		}
+	}), Object.defineProperty(le, "useImageBlobFetch", {
+		enumerable: !0,
+		get: function() {
+			return wn;
+		}
+	});
+});