useblocks 1.1.72 → 1.1.84

package/static/core/cf26b064.js

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