@keystrokehq/keystroke 0.0.0-staging-20260714181321

package/dist/chunk-WVRWIZF5-B5z8SbAq.cjs

@@ -0,0 +1,4225 @@
+const require_chunk_BZUGFHVS = require("./chunk-BZUGFHVS-7RRM7Jpb.cjs");
+const require_chunk_QAYAQNCG = require("./chunk-QAYAQNCG-ROQh1hrZ.cjs");
+let node_module = require("node:module");
+let node_fs_promises = require("node:fs/promises");
+//#region ../../node_modules/.pnpm/just-bash@3.0.1/node_modules/just-bash/dist/bundle/chunks/chunk-WVRWIZF5.js
+(0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
+var _e = require_chunk_BZUGFHVS.o((ye) => {
+	ye.read = function(i, e, t, r, n) {
+		var o, s, a = n * 8 - r - 1, m = (1 << a) - 1, f = m >> 1, c = -7, p = t ? n - 1 : 0, u = t ? -1 : 1, d = i[e + p];
+		for (p += u, o = d & (1 << -c) - 1, d >>= -c, c += a; c > 0; o = o * 256 + i[e + p], p += u, c -= 8);
+		for (s = o & (1 << -c) - 1, o >>= -c, c += r; c > 0; s = s * 256 + i[e + p], p += u, c -= 8);
+		if (o === 0) o = 1 - f;
+		else {
+			if (o === m) return s ? NaN : (d ? -1 : 1) * Infinity;
+			s = s + Math.pow(2, r), o = o - f;
+		}
+		return (d ? -1 : 1) * s * Math.pow(2, o - r);
+	};
+	ye.write = function(i, e, t, r, n, o) {
+		var s, a, m, f = o * 8 - n - 1, c = (1 << f) - 1, p = c >> 1, u = n === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, d = r ? 0 : o - 1, B = r ? 1 : -1, k = e < 0 || e === 0 && 1 / e < 0 ? 1 : 0;
+		for (e = Math.abs(e), isNaN(e) || e === Infinity ? (a = isNaN(e) ? 1 : 0, s = c) : (s = Math.floor(Math.log(e) / Math.LN2), e * (m = Math.pow(2, -s)) < 1 && (s--, m *= 2), s + p >= 1 ? e += u / m : e += u * Math.pow(2, 1 - p), e * m >= 2 && (s++, m /= 2), s + p >= c ? (a = 0, s = c) : s + p >= 1 ? (a = (e * m - 1) * Math.pow(2, n), s = s + p) : (a = e * Math.pow(2, p - 1) * Math.pow(2, n), s = 0)); n >= 8; i[t + d] = a & 255, d += B, a /= 256, n -= 8);
+		for (s = s << n | a, f += n; f > 0; i[t + d] = s & 255, d += B, s /= 256, f -= 8);
+		i[t + d - B] |= k * 128;
+	};
+});
+var Je = require_chunk_BZUGFHVS.o((cn, He) => {
+	var H = 1e3, J = H * 60, X = J * 60, $ = X * 24, qt = $ * 7, Ht = $ * 365.25;
+	He.exports = function(i, e) {
+		e = e || {};
+		var t = typeof i;
+		if (t === "string" && i.length > 0) return Jt(i);
+		if (t === "number" && isFinite(i)) return e.long ? Qt(i) : Xt(i);
+		throw new Error("val is not a non-empty string or a valid number. val=" + JSON.stringify(i));
+	};
+	function Jt(i) {
+		if (i = String(i), !(i.length > 100)) {
+			var e = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(i);
+			if (e) {
+				var t = parseFloat(e[1]);
+				switch ((e[2] || "ms").toLowerCase()) {
+					case "years":
+					case "year":
+					case "yrs":
+					case "yr":
+					case "y": return t * Ht;
+					case "weeks":
+					case "week":
+					case "w": return t * qt;
+					case "days":
+					case "day":
+					case "d": return t * $;
+					case "hours":
+					case "hour":
+					case "hrs":
+					case "hr":
+					case "h": return t * X;
+					case "minutes":
+					case "minute":
+					case "mins":
+					case "min":
+					case "m": return t * J;
+					case "seconds":
+					case "second":
+					case "secs":
+					case "sec":
+					case "s": return t * H;
+					case "milliseconds":
+					case "millisecond":
+					case "msecs":
+					case "msec":
+					case "ms": return t;
+					default: return;
+				}
+			}
+		}
+	}
+	function Xt(i) {
+		var e = Math.abs(i);
+		return e >= $ ? Math.round(i / $) + "d" : e >= X ? Math.round(i / X) + "h" : e >= J ? Math.round(i / J) + "m" : e >= H ? Math.round(i / H) + "s" : i + "ms";
+	}
+	function Qt(i) {
+		var e = Math.abs(i);
+		return e >= $ ? fe(i, e, $, "day") : e >= X ? fe(i, e, X, "hour") : e >= J ? fe(i, e, J, "minute") : e >= H ? fe(i, e, H, "second") : i + " ms";
+	}
+	function fe(i, e, t, r) {
+		var n = e >= t * 1.5;
+		return Math.round(i / t) + " " + r + (n ? "s" : "");
+	}
+});
+var Ce = require_chunk_BZUGFHVS.o((fn, Xe) => {
+	function Yt(i) {
+		t.debug = t, t.default = t, t.coerce = m, t.disable = s, t.enable = n, t.enabled = a, t.humanize = Je(), t.destroy = f, Object.keys(i).forEach((c) => {
+			t[c] = i[c];
+		}), t.names = [], t.skips = [], t.formatters = {};
+		function e(c) {
+			let p = 0;
+			for (let u = 0; u < c.length; u++) p = (p << 5) - p + c.charCodeAt(u), p |= 0;
+			return t.colors[Math.abs(p) % t.colors.length];
+		}
+		t.selectColor = e;
+		function t(c) {
+			let p, u = null, d, B;
+			function k(...E) {
+				if (!k.enabled) return;
+				let P = k, te = Number(/* @__PURE__ */ new Date());
+				P.diff = te - (p || te), P.prev = p, P.curr = te, p = te, E[0] = t.coerce(E[0]), typeof E[0] != "string" && E.unshift("%O");
+				let ie = 0;
+				E[0] = E[0].replace(/%([a-zA-Z%])/g, (he, Bt) => {
+					if (he === "%%") return "%";
+					ie++;
+					let Me = t.formatters[Bt];
+					if (typeof Me == "function") {
+						let Dt = E[ie];
+						he = Me.call(P, Dt), E.splice(ie, 1), ie--;
+					}
+					return he;
+				}), t.formatArgs.call(P, E), (P.log || t.log).apply(P, E);
+			}
+			return k.namespace = c, k.useColors = t.useColors(), k.color = t.selectColor(c), k.extend = r, k.destroy = t.destroy, Object.defineProperty(k, "enabled", {
+				enumerable: !0,
+				configurable: !1,
+				get: () => u !== null ? u : (d !== t.namespaces && (d = t.namespaces, B = t.enabled(c)), B),
+				set: (E) => {
+					u = E;
+				}
+			}), typeof t.init == "function" && t.init(k), k;
+		}
+		function r(c, p) {
+			let u = t(this.namespace + (typeof p > "u" ? ":" : p) + c);
+			return u.log = this.log, u;
+		}
+		function n(c) {
+			t.save(c), t.namespaces = c, t.names = [], t.skips = [];
+			let p = (typeof c == "string" ? c : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
+			for (let u of p) u[0] === "-" ? t.skips.push(u.slice(1)) : t.names.push(u);
+		}
+		function o(c, p) {
+			let u = 0, d = 0, B = -1, k = 0;
+			for (; u < c.length;) if (d < p.length && (p[d] === c[u] || p[d] === "*")) p[d] === "*" ? (B = d, k = u, d++) : (u++, d++);
+			else if (B !== -1) d = B + 1, k++, u = k;
+			else return !1;
+			for (; d < p.length && p[d] === "*";) d++;
+			return d === p.length;
+		}
+		function s() {
+			let c = [...t.names, ...t.skips.map((p) => "-" + p)].join(",");
+			return t.enable(""), c;
+		}
+		function a(c) {
+			for (let p of t.skips) if (o(c, p)) return !1;
+			for (let p of t.names) if (o(c, p)) return !0;
+			return !1;
+		}
+		function m(c) {
+			return c instanceof Error ? c.stack || c.message : c;
+		}
+		function f() {
+			console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+		}
+		return t.enable(t.load()), t;
+	}
+	Xe.exports = Yt;
+});
+var Qe = require_chunk_BZUGFHVS.o((F, pe) => {
+	F.formatArgs = ei;
+	F.save = ti;
+	F.load = ii;
+	F.useColors = Kt;
+	F.storage = ri();
+	F.destroy = (() => {
+		let i = !1;
+		return () => {
+			i || (i = !0, console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."));
+		};
+	})();
+	F.colors = [
+		"#0000CC",
+		"#0000FF",
+		"#0033CC",
+		"#0033FF",
+		"#0066CC",
+		"#0066FF",
+		"#0099CC",
+		"#0099FF",
+		"#00CC00",
+		"#00CC33",
+		"#00CC66",
+		"#00CC99",
+		"#00CCCC",
+		"#00CCFF",
+		"#3300CC",
+		"#3300FF",
+		"#3333CC",
+		"#3333FF",
+		"#3366CC",
+		"#3366FF",
+		"#3399CC",
+		"#3399FF",
+		"#33CC00",
+		"#33CC33",
+		"#33CC66",
+		"#33CC99",
+		"#33CCCC",
+		"#33CCFF",
+		"#6600CC",
+		"#6600FF",
+		"#6633CC",
+		"#6633FF",
+		"#66CC00",
+		"#66CC33",
+		"#9900CC",
+		"#9900FF",
+		"#9933CC",
+		"#9933FF",
+		"#99CC00",
+		"#99CC33",
+		"#CC0000",
+		"#CC0033",
+		"#CC0066",
+		"#CC0099",
+		"#CC00CC",
+		"#CC00FF",
+		"#CC3300",
+		"#CC3333",
+		"#CC3366",
+		"#CC3399",
+		"#CC33CC",
+		"#CC33FF",
+		"#CC6600",
+		"#CC6633",
+		"#CC9900",
+		"#CC9933",
+		"#CCCC00",
+		"#CCCC33",
+		"#FF0000",
+		"#FF0033",
+		"#FF0066",
+		"#FF0099",
+		"#FF00CC",
+		"#FF00FF",
+		"#FF3300",
+		"#FF3333",
+		"#FF3366",
+		"#FF3399",
+		"#FF33CC",
+		"#FF33FF",
+		"#FF6600",
+		"#FF6633",
+		"#FF9900",
+		"#FF9933",
+		"#FFCC00",
+		"#FFCC33"
+	];
+	function Kt() {
+		if (typeof window < "u" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) return !0;
+		if (typeof navigator < "u" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) return !1;
+		let i;
+		return typeof document < "u" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || typeof window < "u" && window.console && (window.console.firebug || window.console.exception && window.console.table) || typeof navigator < "u" && navigator.userAgent && (i = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(i[1], 10) >= 31 || typeof navigator < "u" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+	}
+	function ei(i) {
+		if (i[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + i[0] + (this.useColors ? "%c " : " ") + "+" + pe.exports.humanize(this.diff), !this.useColors) return;
+		let e = "color: " + this.color;
+		i.splice(1, 0, e, "color: inherit");
+		let t = 0, r = 0;
+		i[0].replace(/%[a-zA-Z%]/g, (n) => {
+			n !== "%%" && (t++, n === "%c" && (r = t));
+		}), i.splice(r, 0, e);
+	}
+	F.log = console.debug || console.log || (() => {});
+	function ti(i) {
+		try {
+			i ? F.storage.setItem("debug", i) : F.storage.removeItem("debug");
+		} catch {}
+	}
+	function ii() {
+		let i;
+		try {
+			i = F.storage.getItem("debug") || F.storage.getItem("DEBUG");
+		} catch {}
+		return !i && typeof process < "u" && "env" in process && (i = process.env.DEBUG), i;
+	}
+	function ri() {
+		try {
+			return localStorage;
+		} catch {}
+	}
+	pe.exports = Ce()(F);
+	var { formatters: ni } = pe.exports;
+	ni.j = function(i) {
+		try {
+			return JSON.stringify(i);
+		} catch (e) {
+			return "[UnexpectedJSONParseError]: " + e.message;
+		}
+	};
+});
+var Ke = require_chunk_BZUGFHVS.o((pn, Ye) => {
+	"use strict";
+	Ye.exports = (i, e = process.argv) => {
+		let t = i.startsWith("-") ? "" : i.length === 1 ? "-" : "--", r = e.indexOf(t + i), n = e.indexOf("--");
+		return r !== -1 && (n === -1 || r < n);
+	};
+});
+var it = require_chunk_BZUGFHVS.o((mn, tt) => {
+	"use strict";
+	var oi = require_chunk_BZUGFHVS.m("os"), et = require_chunk_BZUGFHVS.m("tty"), T = Ke(), { env: w } = process, U;
+	T("no-color") || T("no-colors") || T("color=false") || T("color=never") ? U = 0 : (T("color") || T("colors") || T("color=true") || T("color=always")) && (U = 1);
+	"FORCE_COLOR" in w && (w.FORCE_COLOR === "true" ? U = 1 : w.FORCE_COLOR === "false" ? U = 0 : U = w.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(w.FORCE_COLOR, 10), 3));
+	function Se(i) {
+		return i === 0 ? !1 : {
+			level: i,
+			hasBasic: !0,
+			has256: i >= 2,
+			has16m: i >= 3
+		};
+	}
+	function Fe(i, e) {
+		if (U === 0) return 0;
+		if (T("color=16m") || T("color=full") || T("color=truecolor")) return 3;
+		if (T("color=256")) return 2;
+		if (i && !e && U === void 0) return 0;
+		let t = U || 0;
+		if (w.TERM === "dumb") return t;
+		if (process.platform === "win32") {
+			let r = oi.release().split(".");
+			return Number(r[0]) >= 10 && Number(r[2]) >= 10586 ? Number(r[2]) >= 14931 ? 3 : 2 : 1;
+		}
+		if ("CI" in w) return [
+			"TRAVIS",
+			"CIRCLECI",
+			"APPVEYOR",
+			"GITLAB_CI",
+			"GITHUB_ACTIONS",
+			"BUILDKITE"
+		].some((r) => r in w) || w.CI_NAME === "codeship" ? 1 : t;
+		if ("TEAMCITY_VERSION" in w) return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(w.TEAMCITY_VERSION) ? 1 : 0;
+		if (w.COLORTERM === "truecolor") return 3;
+		if ("TERM_PROGRAM" in w) {
+			let r = parseInt((w.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+			switch (w.TERM_PROGRAM) {
+				case "iTerm.app": return r >= 3 ? 3 : 2;
+				case "Apple_Terminal": return 2;
+			}
+		}
+		return /-256(color)?$/i.test(w.TERM) ? 2 : /^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(w.TERM) || "COLORTERM" in w ? 1 : t;
+	}
+	function si(i) {
+		return Se(Fe(i, i && i.isTTY));
+	}
+	tt.exports = {
+		supportsColor: si,
+		stdout: Se(Fe(!0, et.isatty(1))),
+		stderr: Se(Fe(!0, et.isatty(2)))
+	};
+});
+var nt = require_chunk_BZUGFHVS.o((y, ue) => {
+	var ai = require_chunk_BZUGFHVS.m("tty"), me = require_chunk_BZUGFHVS.m("util");
+	y.init = di;
+	y.log = mi;
+	y.formatArgs = fi;
+	y.save = ui;
+	y.load = li;
+	y.useColors = ci;
+	y.destroy = me.deprecate(() => {}, "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+	y.colors = [
+		6,
+		2,
+		3,
+		4,
+		5,
+		1
+	];
+	try {
+		let i = it();
+		i && (i.stderr || i).level >= 2 && (y.colors = [
+			20,
+			21,
+			26,
+			27,
+			32,
+			33,
+			38,
+			39,
+			40,
+			41,
+			42,
+			43,
+			44,
+			45,
+			56,
+			57,
+			62,
+			63,
+			68,
+			69,
+			74,
+			75,
+			76,
+			77,
+			78,
+			79,
+			80,
+			81,
+			92,
+			93,
+			98,
+			99,
+			112,
+			113,
+			128,
+			129,
+			134,
+			135,
+			148,
+			149,
+			160,
+			161,
+			162,
+			163,
+			164,
+			165,
+			166,
+			167,
+			168,
+			169,
+			170,
+			171,
+			172,
+			173,
+			178,
+			179,
+			184,
+			185,
+			196,
+			197,
+			198,
+			199,
+			200,
+			201,
+			202,
+			203,
+			204,
+			205,
+			206,
+			207,
+			208,
+			209,
+			214,
+			215,
+			220,
+			221
+		]);
+	} catch {}
+	y.inspectOpts = Object.keys(process.env).filter((i) => /^debug_/i.test(i)).reduce((i, e) => {
+		let t = e.substring(6).toLowerCase().replace(/_([a-z])/g, (n, o) => o.toUpperCase()), r = process.env[e];
+		return /^(yes|on|true|enabled)$/i.test(r) ? r = !0 : /^(no|off|false|disabled)$/i.test(r) ? r = !1 : r === "null" ? r = null : r = Number(r), i[t] = r, i;
+	}, {});
+	function ci() {
+		return "colors" in y.inspectOpts ? !!y.inspectOpts.colors : ai.isatty(process.stderr.fd);
+	}
+	function fi(i) {
+		let { namespace: e, useColors: t } = this;
+		if (t) {
+			let r = this.color, n = "\x1B[3" + (r < 8 ? r : "8;5;" + r), o = `  ${n};1m${e} \x1B[0m`;
+			i[0] = o + i[0].split(`
+`).join(`
+` + o), i.push(n + "m+" + ue.exports.humanize(this.diff) + "\x1B[0m");
+		} else i[0] = pi() + e + " " + i[0];
+	}
+	function pi() {
+		return y.inspectOpts.hideDate ? "" : (/* @__PURE__ */ new Date()).toISOString() + " ";
+	}
+	function mi(...i) {
+		return process.stderr.write(me.formatWithOptions(y.inspectOpts, ...i) + `
+`);
+	}
+	function ui(i) {
+		i ? process.env.DEBUG = i : delete process.env.DEBUG;
+	}
+	function li() {
+		return process.env.DEBUG;
+	}
+	function di(i) {
+		i.inspectOpts = {};
+		let e = Object.keys(y.inspectOpts);
+		for (let t = 0; t < e.length; t++) i.inspectOpts[e[t]] = y.inspectOpts[e[t]];
+	}
+	ue.exports = Ce()(y);
+	var { formatters: rt } = ue.exports;
+	rt.o = function(i) {
+		return this.inspectOpts.colors = this.useColors, me.inspect(i, this.inspectOpts).split(`
+`).map((e) => e.trim()).join(" ");
+	};
+	rt.O = function(i) {
+		return this.inspectOpts.colors = this.useColors, me.inspect(i, this.inspectOpts);
+	};
+});
+var ot = require_chunk_BZUGFHVS.o((un, Ee) => {
+	typeof process > "u" || process.type === "renderer" || process.browser === !0 || process.__nwjs ? Ee.exports = Qe() : Ee.exports = nt();
+});
+var Ot = "End-Of-Stream", l = class extends Error {
+	constructor() {
+		super(Ot), this.name = "EndOfStreamError";
+	}
+}, N = class extends Error {
+	constructor(e = "The operation was aborted") {
+		super(e), this.name = "AbortError";
+	}
+};
+var j = class {
+	constructor() {
+		this.endOfStream = !1, this.interrupted = !1, this.peekQueue = [];
+	}
+	async peek(e, t = !1) {
+		let r = await this.read(e, t);
+		return this.peekQueue.push(e.subarray(0, r)), r;
+	}
+	async read(e, t = !1) {
+		if (e.length === 0) return 0;
+		let r = this.readFromPeekBuffer(e);
+		if (this.endOfStream || (r += await this.readRemainderFromStream(e.subarray(r), t)), r === 0 && !t) throw new l();
+		return r;
+	}
+	readFromPeekBuffer(e) {
+		let t = e.length, r = 0;
+		for (; this.peekQueue.length > 0 && t > 0;) {
+			let n = this.peekQueue.pop();
+			if (!n) throw new Error("peekData should be defined");
+			let o = Math.min(n.length, t);
+			e.set(n.subarray(0, o), r), r += o, t -= o, o < n.length && this.peekQueue.push(n.subarray(o));
+		}
+		return r;
+	}
+	async readRemainderFromStream(e, t) {
+		let r = 0;
+		for (; r < e.length && !this.endOfStream;) {
+			if (this.interrupted) throw new N();
+			let n = await this.readFromStream(e.subarray(r), t);
+			if (n === 0) break;
+			r += n;
+		}
+		if (!t && r < e.length) throw new l();
+		return r;
+	}
+};
+var ne = class extends j {
+	constructor(e) {
+		super(), this.reader = e;
+	}
+	async abort() {
+		return this.close();
+	}
+	async close() {
+		this.reader.releaseLock();
+	}
+};
+var Q = class extends ne {
+	async readFromStream(e, t) {
+		if (e.length === 0) return 0;
+		let r = await this.reader.read(new Uint8Array(e.length), { min: t ? void 0 : e.length });
+		return r.done && (this.endOfStream = r.done), r.value ? (e.set(r.value), r.value.length) : 0;
+	}
+};
+var Z = class extends j {
+	constructor(e) {
+		super(), this.reader = e, this.buffer = null;
+	}
+	writeChunk(e, t) {
+		let r = Math.min(t.length, e.length);
+		return e.set(t.subarray(0, r)), r < t.length ? this.buffer = t.subarray(r) : this.buffer = null, r;
+	}
+	async readFromStream(e, t) {
+		if (e.length === 0) return 0;
+		let r = 0;
+		for (this.buffer && (r += this.writeChunk(e, this.buffer)); r < e.length && !this.endOfStream;) {
+			let n = await this.reader.read();
+			if (n.done) {
+				this.endOfStream = !0;
+				break;
+			}
+			n.value && (r += this.writeChunk(e.subarray(r), n.value));
+		}
+		if (!t && r === 0 && this.endOfStream) throw new l();
+		return r;
+	}
+	abort() {
+		return this.interrupted = !0, this.reader.cancel();
+	}
+	async close() {
+		await this.abort(), this.reader.releaseLock();
+	}
+};
+function we(i) {
+	try {
+		let e = i.getReader({ mode: "byob" });
+		return e instanceof ReadableStreamDefaultReader ? new Z(e) : new Q(e);
+	} catch (e) {
+		if (e instanceof TypeError) return new Z(i.getReader());
+		throw e;
+	}
+}
+var A = class {
+	constructor(e) {
+		this.numBuffer = new Uint8Array(8), this.position = 0, this.onClose = e?.onClose, e?.abortSignal && e.abortSignal.addEventListener("abort", () => {
+			this.abort();
+		});
+	}
+	async readToken(e, t = this.position) {
+		let r = new Uint8Array(e.len);
+		if (await this.readBuffer(r, { position: t }) < e.len) throw new l();
+		return e.get(r, 0);
+	}
+	async peekToken(e, t = this.position) {
+		let r = new Uint8Array(e.len);
+		if (await this.peekBuffer(r, { position: t }) < e.len) throw new l();
+		return e.get(r, 0);
+	}
+	async readNumber(e) {
+		if (await this.readBuffer(this.numBuffer, { length: e.len }) < e.len) throw new l();
+		return e.get(this.numBuffer, 0);
+	}
+	async peekNumber(e) {
+		if (await this.peekBuffer(this.numBuffer, { length: e.len }) < e.len) throw new l();
+		return e.get(this.numBuffer, 0);
+	}
+	async ignore(e) {
+		if (e < 0) throw new RangeError("ignore length must be ≥ 0 bytes");
+		if (this.fileInfo.size !== void 0) {
+			let t = this.fileInfo.size - this.position;
+			if (e > t) return this.position += t, t;
+		}
+		return this.position += e, e;
+	}
+	async close() {
+		await this.abort(), await this.onClose?.();
+	}
+	normalizeOptions(e, t) {
+		if (!this.supportsRandomAccess() && t && t.position !== void 0 && t.position < this.position) throw new Error("`options.position` must be equal or greater than `tokenizer.position`");
+		return {
+			mayBeLess: !1,
+			offset: 0,
+			length: e.length,
+			position: this.position,
+			...t
+		};
+	}
+	abort() {
+		return Promise.resolve();
+	}
+};
+var Mt = 256e3, oe = class extends A {
+	constructor(e, t) {
+		super(t), this.streamReader = e, this.fileInfo = t?.fileInfo ?? {};
+	}
+	async readBuffer(e, t) {
+		let r = this.normalizeOptions(e, t), n = r.position - this.position;
+		if (n > 0) return await this.ignore(n), this.readBuffer(e, t);
+		if (n < 0) throw new Error("`options.position` must be equal or greater than `tokenizer.position`");
+		if (r.length === 0) return 0;
+		let o = await this.streamReader.read(e.subarray(0, r.length), r.mayBeLess);
+		if (this.position += o, (!t || !t.mayBeLess) && o < r.length) throw new l();
+		return o;
+	}
+	async peekBuffer(e, t) {
+		let r = this.normalizeOptions(e, t), n = 0;
+		if (r.position) {
+			let o = r.position - this.position;
+			if (o > 0) {
+				let s = new Uint8Array(r.length + o);
+				return n = await this.peekBuffer(s, { mayBeLess: r.mayBeLess }), e.set(s.subarray(o)), n - o;
+			}
+			if (o < 0) throw new Error("Cannot peek from a negative offset in a stream");
+		}
+		if (r.length > 0) {
+			try {
+				n = await this.streamReader.peek(e.subarray(0, r.length), r.mayBeLess);
+			} catch (o) {
+				if (t?.mayBeLess && o instanceof l) return 0;
+				throw o;
+			}
+			if (!r.mayBeLess && n < r.length) throw new l();
+		}
+		return n;
+	}
+	async ignore(e) {
+		if (e < 0) throw new RangeError("ignore length must be ≥ 0 bytes");
+		let t = Math.min(Mt, e), r = new Uint8Array(t), n = 0;
+		for (; n < e;) {
+			let o = e - n, s = await this.readBuffer(r, { length: Math.min(t, o) });
+			if (s < 0) return s;
+			n += s;
+		}
+		return n;
+	}
+	abort() {
+		return this.streamReader.abort();
+	}
+	async close() {
+		return this.streamReader.close();
+	}
+	supportsRandomAccess() {
+		return !1;
+	}
+};
+var se = class extends A {
+	constructor(e, t) {
+		super(t), this.uint8Array = e, this.fileInfo = {
+			...t?.fileInfo ?? {},
+			size: e.length
+		};
+	}
+	async readBuffer(e, t) {
+		t?.position && (this.position = t.position);
+		let r = await this.peekBuffer(e, t);
+		return this.position += r, r;
+	}
+	async peekBuffer(e, t) {
+		let r = this.normalizeOptions(e, t), n = Math.min(this.uint8Array.length - r.position, r.length);
+		if (!r.mayBeLess && n < r.length) throw new l();
+		return e.set(this.uint8Array.subarray(r.position, r.position + n)), n;
+	}
+	close() {
+		return super.close();
+	}
+	supportsRandomAccess() {
+		return !0;
+	}
+	setPosition(e) {
+		this.position = e;
+	}
+};
+var ae = class extends A {
+	constructor(e, t) {
+		super(t), this.blob = e, this.fileInfo = {
+			...t?.fileInfo ?? {},
+			size: e.size,
+			mimeType: e.type
+		};
+	}
+	async readBuffer(e, t) {
+		t?.position && (this.position = t.position);
+		let r = await this.peekBuffer(e, t);
+		return this.position += r, r;
+	}
+	async peekBuffer(e, t) {
+		let r = this.normalizeOptions(e, t), n = Math.min(this.blob.size - r.position, r.length);
+		if (!r.mayBeLess && n < r.length) throw new l();
+		let o = await this.blob.slice(r.position, r.position + n).arrayBuffer();
+		return e.set(new Uint8Array(o)), n;
+	}
+	close() {
+		return super.close();
+	}
+	supportsRandomAccess() {
+		return !0;
+	}
+	setPosition(e) {
+		this.position = e;
+	}
+};
+function Pe(i, e) {
+	let t = we(i), r = e ?? {}, n = r.onClose;
+	return r.onClose = async () => {
+		if (await t.close(), n) return n();
+	}, new oe(t, r);
+}
+function Ne(i, e) {
+	return new se(i, e);
+}
+function je(i, e) {
+	return new ae(i, e);
+}
+(class i extends A {
+	static async fromFile(e) {
+		let t = await (0, node_fs_promises.open)(e, "r");
+		return new i(t, { fileInfo: {
+			path: e,
+			size: (await t.stat()).size
+		} });
+	}
+	constructor(e, t) {
+		super(t), this.fileHandle = e, this.fileInfo = t.fileInfo;
+	}
+	async readBuffer(e, t) {
+		let r = this.normalizeOptions(e, t);
+		if (this.position = r.position, r.length === 0) return 0;
+		let n = await this.fileHandle.read(e, 0, r.length, r.position);
+		if (this.position += n.bytesRead, n.bytesRead < r.length && (!t || !t.mayBeLess)) throw new l();
+		return n.bytesRead;
+	}
+	async peekBuffer(e, t) {
+		let r = this.normalizeOptions(e, t), n = await this.fileHandle.read(e, 0, r.length, r.position);
+		if (!r.mayBeLess && n.bytesRead < r.length) throw new l();
+		return n.bytesRead;
+	}
+	async close() {
+		return await this.fileHandle.close(), super.close();
+	}
+	setPosition(e) {
+		this.position = e;
+	}
+	supportsRandomAccess() {
+		return !0;
+	}
+}).fromFile;
+require_chunk_BZUGFHVS.q(_e(), 1);
+var $e = {
+	128: "€",
+	130: "‚",
+	131: "ƒ",
+	132: "„",
+	133: "…",
+	134: "†",
+	135: "‡",
+	136: "ˆ",
+	137: "‰",
+	138: "Š",
+	139: "‹",
+	140: "Œ",
+	142: "Ž",
+	145: "‘",
+	146: "’",
+	147: "“",
+	148: "”",
+	149: "•",
+	150: "–",
+	151: "—",
+	152: "˜",
+	153: "™",
+	154: "š",
+	155: "›",
+	156: "œ",
+	158: "ž",
+	159: "Ÿ"
+}, Pt = {};
+for (let [i, e] of Object.entries($e)) Pt[e] = Number.parseInt(i, 10);
+var ce;
+function Nt() {
+	if (!(typeof globalThis.TextDecoder > "u")) return ce ?? (ce = new globalThis.TextDecoder("utf-8"));
+}
+var q = 32 * 1024, I = 65533;
+function We(i, e = "utf-8") {
+	switch (e.toLowerCase()) {
+		case "utf-8":
+		case "utf8": {
+			let t = Nt();
+			return t ? t.decode(i) : _t(i);
+		}
+		case "utf-16le": return $t(i);
+		case "us-ascii":
+		case "ascii": return Wt(i);
+		case "latin1":
+		case "iso-8859-1": return Gt(i);
+		case "windows-1252": return Zt(i);
+		default: throw new RangeError(`Encoding '${e}' not supported`);
+	}
+}
+function ke(i, e) {
+	e.length !== 0 && (i.push(String.fromCharCode.apply(null, e)), e.length = 0);
+}
+function g(i, e, t) {
+	e.push(t), e.length >= q && ke(i, e);
+}
+function jt(i, e, t) {
+	if (t <= 65535) {
+		g(i, e, t);
+		return;
+	}
+	t -= 65536, g(i, e, 55296 + (t >> 10)), g(i, e, 56320 + (t & 1023));
+}
+function _t(i) {
+	let e = [], t = [], r = 0;
+	for (i.length >= 3 && i[0] === 239 && i[1] === 187 && i[2] === 191 && (r = 3); r < i.length;) {
+		let n = i[r];
+		if (n <= 127) {
+			g(e, t, n), r++;
+			continue;
+		}
+		if (n < 194 || n > 244) {
+			g(e, t, I), r++;
+			continue;
+		}
+		if (n <= 223) {
+			if (r + 1 >= i.length) {
+				g(e, t, I), r++;
+				continue;
+			}
+			let c = i[r + 1];
+			if ((c & 192) !== 128) {
+				g(e, t, I), r++;
+				continue;
+			}
+			g(e, t, (n & 31) << 6 | c & 63), r += 2;
+			continue;
+		}
+		if (n <= 239) {
+			if (r + 2 >= i.length) {
+				g(e, t, I), r++;
+				continue;
+			}
+			let c = i[r + 1], p = i[r + 2];
+			if (!((c & 192) === 128 && (p & 192) === 128 && !(n === 224 && c < 160) && !(n === 237 && c >= 160))) {
+				g(e, t, I), r++;
+				continue;
+			}
+			g(e, t, (n & 15) << 12 | (c & 63) << 6 | p & 63), r += 3;
+			continue;
+		}
+		if (r + 3 >= i.length) {
+			g(e, t, I), r++;
+			continue;
+		}
+		let o = i[r + 1], s = i[r + 2], a = i[r + 3];
+		if (!((o & 192) === 128 && (s & 192) === 128 && (a & 192) === 128 && !(n === 240 && o < 144) && !(n === 244 && o > 143))) {
+			g(e, t, I), r++;
+			continue;
+		}
+		jt(e, t, (n & 7) << 18 | (o & 63) << 12 | (s & 63) << 6 | a & 63), r += 4;
+	}
+	return ke(e, t), e.join("");
+}
+function $t(i) {
+	let e = [], t = [], r = i.length, n = 0;
+	for (; n + 1 < r;) {
+		let o = i[n] | i[n + 1] << 8;
+		if (n += 2, o >= 55296 && o <= 56319) {
+			if (n + 1 < r) {
+				let s = i[n] | i[n + 1] << 8;
+				s >= 56320 && s <= 57343 ? (g(e, t, o), g(e, t, s), n += 2) : g(e, t, I);
+			} else g(e, t, I);
+			continue;
+		}
+		if (o >= 56320 && o <= 57343) {
+			g(e, t, I);
+			continue;
+		}
+		g(e, t, o);
+	}
+	return n < r && g(e, t, I), ke(e, t), e.join("");
+}
+function Wt(i) {
+	let e = [];
+	for (let t = 0; t < i.length; t += q) {
+		let r = Math.min(i.length, t + q), n = new Array(r - t);
+		for (let o = t, s = 0; o < r; o++, s++) n[s] = i[o] & 127;
+		e.push(String.fromCharCode.apply(null, n));
+	}
+	return e.join("");
+}
+function Gt(i) {
+	let e = [];
+	for (let t = 0; t < i.length; t += q) {
+		let r = Math.min(i.length, t + q), n = new Array(r - t);
+		for (let o = t, s = 0; o < r; o++, s++) n[s] = i[o];
+		e.push(String.fromCharCode.apply(null, n));
+	}
+	return e.join("");
+}
+function Zt(i) {
+	let e = [], t = "";
+	for (let r = 0; r < i.length; r++) {
+		let n = i[r], o = n >= 128 && n <= 159 ? $e[n] : void 0;
+		t += o ?? String.fromCharCode(n), t.length >= q && (e.push(t), t = "");
+	}
+	return t && e.push(t), e.join("");
+}
+function C(i) {
+	return new DataView(i.buffer, i.byteOffset);
+}
+var Ze = {
+	len: 1,
+	get(i, e) {
+		return C(i).getUint8(e);
+	},
+	put(i, e, t) {
+		return C(i).setUint8(e, t), e + 1;
+	}
+}, h = {
+	len: 2,
+	get(i, e) {
+		return C(i).getUint16(e, !0);
+	},
+	put(i, e, t) {
+		return C(i).setUint16(e, t, !0), e + 2;
+	}
+}, _ = {
+	len: 2,
+	get(i, e) {
+		return C(i).getUint16(e);
+	},
+	put(i, e, t) {
+		return C(i).setUint16(e, t), e + 2;
+	}
+};
+var x = {
+	len: 4,
+	get(i, e) {
+		return C(i).getUint32(e, !0);
+	},
+	put(i, e, t) {
+		return C(i).setUint32(e, t, !0), e + 4;
+	}
+}, be = {
+	len: 4,
+	get(i, e) {
+		return C(i).getUint32(e);
+	},
+	put(i, e, t) {
+		return C(i).setUint32(e, t), e + 4;
+	}
+};
+var Ve = {
+	len: 4,
+	get(i, e) {
+		return C(i).getInt32(e);
+	},
+	put(i, e, t) {
+		return C(i).setInt32(e, t), e + 4;
+	}
+};
+var qe = {
+	len: 8,
+	get(i, e) {
+		return C(i).getBigUint64(e, !0);
+	},
+	put(i, e, t) {
+		return C(i).setBigUint64(e, t, !0), e + 8;
+	}
+};
+var S = class {
+	constructor(e, t) {
+		this.len = e, this.encoding = t;
+	}
+	get(e, t = 0) {
+		return We(e.subarray(t, t + this.len), this.encoding);
+	}
+};
+var ft = require_chunk_BZUGFHVS.q(ot(), 1);
+var W = {
+	LocalFileHeader: 67324752,
+	DataDescriptor: 134695760,
+	CentralFileHeader: 33639248,
+	EndOfCentralDirectory: 101010256
+}, Te = {
+	get(i) {
+		return {
+			signature: x.get(i, 0),
+			compressedSize: x.get(i, 8),
+			uncompressedSize: x.get(i, 12)
+		};
+	},
+	len: 16
+}, st = {
+	get(i) {
+		let e = h.get(i, 6);
+		return {
+			signature: x.get(i, 0),
+			minVersion: h.get(i, 4),
+			dataDescriptor: !!(e & 8),
+			compressedMethod: h.get(i, 8),
+			compressedSize: x.get(i, 18),
+			uncompressedSize: x.get(i, 22),
+			filenameLength: h.get(i, 26),
+			extraFieldLength: h.get(i, 28),
+			filename: null
+		};
+	},
+	len: 30
+}, at = {
+	get(i) {
+		return {
+			signature: x.get(i, 0),
+			nrOfThisDisk: h.get(i, 4),
+			nrOfThisDiskWithTheStart: h.get(i, 6),
+			nrOfEntriesOnThisDisk: h.get(i, 8),
+			nrOfEntriesOfSize: h.get(i, 10),
+			sizeOfCd: x.get(i, 12),
+			offsetOfStartOfCd: x.get(i, 16),
+			zipFileCommentLength: h.get(i, 20)
+		};
+	},
+	len: 22
+}, ct = {
+	get(i) {
+		let e = h.get(i, 8);
+		return {
+			signature: x.get(i, 0),
+			minVersion: h.get(i, 6),
+			dataDescriptor: !!(e & 8),
+			compressedMethod: h.get(i, 10),
+			compressedSize: x.get(i, 20),
+			uncompressedSize: x.get(i, 24),
+			filenameLength: h.get(i, 28),
+			extraFieldLength: h.get(i, 30),
+			fileCommentLength: h.get(i, 32),
+			relativeOffsetOfLocalHeader: x.get(i, 42),
+			filename: null
+		};
+	},
+	len: 46
+};
+function pt(i) {
+	let e = new Uint8Array(x.len);
+	return x.put(e, 0, i), e;
+}
+var D = (0, ft.default)("tokenizer:inflate"), ve = 256 * 1024, xi = pt(W.DataDescriptor), le = pt(W.EndOfCentralDirectory), G = class i {
+	constructor(e) {
+		this.tokenizer = e, this.syncBuffer = new Uint8Array(ve);
+	}
+	async isZip() {
+		return await this.peekSignature() === W.LocalFileHeader;
+	}
+	peekSignature() {
+		return this.tokenizer.peekToken(x);
+	}
+	async findEndOfCentralDirectoryLocator() {
+		let e = this.tokenizer, t = Math.min(16 * 1024, e.fileInfo.size), r = this.syncBuffer.subarray(0, t);
+		await this.tokenizer.readBuffer(r, { position: e.fileInfo.size - t });
+		for (let n = r.length - 4; n >= 0; n--) if (r[n] === le[0] && r[n + 1] === le[1] && r[n + 2] === le[2] && r[n + 3] === le[3]) return e.fileInfo.size - t + n;
+		return -1;
+	}
+	async readCentralDirectory() {
+		if (!this.tokenizer.supportsRandomAccess()) {
+			D("Cannot reading central-directory without random-read support");
+			return;
+		}
+		D("Reading central-directory...");
+		let e = this.tokenizer.position, t = await this.findEndOfCentralDirectoryLocator();
+		if (t > 0) {
+			D("Central-directory 32-bit signature found");
+			let r = await this.tokenizer.readToken(at, t), n = [];
+			this.tokenizer.setPosition(r.offsetOfStartOfCd);
+			for (let o = 0; o < r.nrOfEntriesOfSize; ++o) {
+				let s = await this.tokenizer.readToken(ct);
+				if (s.signature !== W.CentralFileHeader) throw new Error("Expected Central-File-Header signature");
+				s.filename = await this.tokenizer.readToken(new S(s.filenameLength, "utf-8")), await this.tokenizer.ignore(s.extraFieldLength), await this.tokenizer.ignore(s.fileCommentLength), n.push(s), D(`Add central-directory file-entry: n=${o + 1}/${n.length}: filename=${n[o].filename}`);
+			}
+			return this.tokenizer.setPosition(e), n;
+		}
+		this.tokenizer.setPosition(e);
+	}
+	async unzip(e) {
+		let t = await this.readCentralDirectory();
+		if (t) return this.iterateOverCentralDirectory(t, e);
+		let r = !1;
+		do {
+			let n = await this.readLocalFileHeader();
+			if (!n) break;
+			let o = e(n);
+			r = !!o.stop;
+			let s;
+			if (await this.tokenizer.ignore(n.extraFieldLength), n.dataDescriptor && n.compressedSize === 0) {
+				let a = [], m = ve;
+				D("Compressed-file-size unknown, scanning for next data-descriptor-signature....");
+				let f = -1;
+				for (; f < 0 && m === ve;) {
+					m = await this.tokenizer.peekBuffer(this.syncBuffer, { mayBeLess: !0 }), f = hi(this.syncBuffer.subarray(0, m), xi);
+					let c = f >= 0 ? f : m;
+					if (o.handler) {
+						let p = new Uint8Array(c);
+						await this.tokenizer.readBuffer(p), a.push(p);
+					} else await this.tokenizer.ignore(c);
+				}
+				D(`Found data-descriptor-signature at pos=${this.tokenizer.position}`), o.handler && await this.inflate(n, gi(a), o.handler);
+			} else o.handler ? (D(`Reading compressed-file-data: ${n.compressedSize} bytes`), s = new Uint8Array(n.compressedSize), await this.tokenizer.readBuffer(s), await this.inflate(n, s, o.handler)) : (D(`Ignoring compressed-file-data: ${n.compressedSize} bytes`), await this.tokenizer.ignore(n.compressedSize));
+			if (D(`Reading data-descriptor at pos=${this.tokenizer.position}`), n.dataDescriptor && (await this.tokenizer.readToken(Te)).signature !== 134695760) throw new Error(`Expected data-descriptor-signature at position ${this.tokenizer.position - Te.len}`);
+		} while (!r);
+	}
+	async iterateOverCentralDirectory(e, t) {
+		for (let r of e) {
+			let n = t(r);
+			if (n.handler) {
+				this.tokenizer.setPosition(r.relativeOffsetOfLocalHeader);
+				let o = await this.readLocalFileHeader();
+				if (o) {
+					await this.tokenizer.ignore(o.extraFieldLength);
+					let s = new Uint8Array(r.compressedSize);
+					await this.tokenizer.readBuffer(s), await this.inflate(o, s, n.handler);
+				}
+			}
+			if (n.stop) break;
+		}
+	}
+	async inflate(e, t, r) {
+		if (e.compressedMethod === 0) return r(t);
+		if (e.compressedMethod !== 8) throw new Error(`Unsupported ZIP compression method: ${e.compressedMethod}`);
+		D(`Decompress filename=${e.filename}, compressed-size=${t.length}`);
+		return r(await i.decompressDeflateRaw(t));
+	}
+	static async decompressDeflateRaw(e) {
+		let t = new ReadableStream({ start(o) {
+			o.enqueue(e), o.close();
+		} }), r = new DecompressionStream("deflate-raw"), n = t.pipeThrough(r);
+		try {
+			let s = await new Response(n).arrayBuffer();
+			return new Uint8Array(s);
+		} catch (o) {
+			let s = o instanceof Error ? `Failed to deflate ZIP entry: ${o.message}` : "Unknown decompression error in ZIP entry";
+			throw new TypeError(s);
+		}
+	}
+	async readLocalFileHeader() {
+		let e = await this.tokenizer.peekToken(x);
+		if (e === W.LocalFileHeader) {
+			let t = await this.tokenizer.readToken(st);
+			return t.filename = await this.tokenizer.readToken(new S(t.filenameLength, "utf-8")), t;
+		}
+		if (e === W.CentralFileHeader) return !1;
+		throw e === 3759263696 ? /* @__PURE__ */ new Error("Encrypted ZIP") : /* @__PURE__ */ new Error("Unexpected signature");
+	}
+};
+function hi(i, e) {
+	let t = i.length, r = e.length;
+	if (r > t) return -1;
+	for (let n = 0; n <= t - r; n++) {
+		let o = !0;
+		for (let s = 0; s < r; s++) if (i[n + s] !== e[s]) {
+			o = !1;
+			break;
+		}
+		if (o) return n;
+	}
+	return -1;
+}
+function gi(i) {
+	let e = i.reduce((n, o) => n + o.length, 0), t = new Uint8Array(e), r = 0;
+	for (let n of i) t.set(n, r), r += n.length;
+	return t;
+}
+var Y = class {
+	constructor(e) {
+		this.tokenizer = e;
+	}
+	inflate() {
+		let e = this.tokenizer;
+		return new ReadableStream({ async pull(t) {
+			let r = new Uint8Array(1024), n = await e.readBuffer(r, { mayBeLess: !0 });
+			if (n === 0) {
+				t.close();
+				return;
+			}
+			t.enqueue(r.subarray(0, n));
+		} }).pipeThrough(new DecompressionStream("gzip"));
+	}
+};
+new globalThis.TextDecoder("utf8");
+new globalThis.TextEncoder();
+Array.from({ length: 256 }, (i, e) => e.toString(16).padStart(2, "0"));
+function Ae(i) {
+	let { byteLength: e } = i;
+	if (e === 6) return i.getUint16(0) * 2 ** 32 + i.getUint32(2);
+	if (e === 5) return i.getUint8(0) * 2 ** 32 + i.getUint32(1);
+	if (e === 4) return i.getUint32(0);
+	if (e === 3) return i.getUint8(0) * 2 ** 16 + i.getUint16(1);
+	if (e === 2) return i.getUint16(0);
+	if (e === 1) return i.getUint8(0);
+}
+function mt(i, e) {
+	if (e === "utf-16le") {
+		let t = [];
+		for (let r = 0; r < i.length; r++) {
+			let n = i.charCodeAt(r);
+			t.push(n & 255, n >> 8 & 255);
+		}
+		return t;
+	}
+	if (e === "utf-16be") {
+		let t = [];
+		for (let r = 0; r < i.length; r++) {
+			let n = i.charCodeAt(r);
+			t.push(n >> 8 & 255, n & 255);
+		}
+		return t;
+	}
+	return [...i].map((t) => t.charCodeAt(0));
+}
+function ut(i, e = 0) {
+	let t = Number.parseInt(new S(6).get(i, 148).replace(/\0.*$/, "").trim(), 8);
+	if (Number.isNaN(t)) return !1;
+	let r = 256;
+	for (let n = e; n < e + 148; n++) r += i[n];
+	for (let n = e + 156; n < e + 512; n++) r += i[n];
+	return t === r;
+}
+var lt = {
+	get: (i, e) => i[e + 3] & 127 | i[e + 2] << 7 | i[e + 1] << 14 | i[e] << 21,
+	len: 4
+};
+var dt = [
+	"jpg",
+	"png",
+	"apng",
+	"gif",
+	"webp",
+	"flif",
+	"xcf",
+	"cr2",
+	"cr3",
+	"orf",
+	"arw",
+	"dng",
+	"nef",
+	"rw2",
+	"raf",
+	"tif",
+	"bmp",
+	"icns",
+	"jxr",
+	"psd",
+	"indd",
+	"zip",
+	"tar",
+	"rar",
+	"gz",
+	"bz2",
+	"7z",
+	"dmg",
+	"mp4",
+	"mid",
+	"mkv",
+	"webm",
+	"mov",
+	"avi",
+	"mpg",
+	"mp2",
+	"mp3",
+	"m4a",
+	"oga",
+	"ogg",
+	"ogv",
+	"opus",
+	"flac",
+	"wav",
+	"spx",
+	"amr",
+	"pdf",
+	"epub",
+	"elf",
+	"macho",
+	"exe",
+	"swf",
+	"rtf",
+	"wasm",
+	"woff",
+	"woff2",
+	"eot",
+	"ttf",
+	"otf",
+	"ttc",
+	"ico",
+	"flv",
+	"ps",
+	"xz",
+	"sqlite",
+	"nes",
+	"crx",
+	"xpi",
+	"cab",
+	"deb",
+	"ar",
+	"rpm",
+	"Z",
+	"lz",
+	"cfb",
+	"mxf",
+	"mts",
+	"blend",
+	"bpg",
+	"docx",
+	"pptx",
+	"xlsx",
+	"3gp",
+	"3g2",
+	"j2c",
+	"jp2",
+	"jpm",
+	"jpx",
+	"mj2",
+	"aif",
+	"qcp",
+	"odt",
+	"ods",
+	"odp",
+	"xml",
+	"mobi",
+	"heic",
+	"cur",
+	"ktx",
+	"ape",
+	"wv",
+	"dcm",
+	"ics",
+	"glb",
+	"pcap",
+	"dsf",
+	"lnk",
+	"alias",
+	"voc",
+	"ac3",
+	"m4v",
+	"m4p",
+	"m4b",
+	"f4v",
+	"f4p",
+	"f4b",
+	"f4a",
+	"mie",
+	"asf",
+	"ogm",
+	"ogx",
+	"mpc",
+	"arrow",
+	"shp",
+	"aac",
+	"mp1",
+	"it",
+	"s3m",
+	"xm",
+	"skp",
+	"avif",
+	"eps",
+	"lzh",
+	"pgp",
+	"asar",
+	"stl",
+	"chm",
+	"3mf",
+	"zst",
+	"jxl",
+	"vcf",
+	"jls",
+	"pst",
+	"dwg",
+	"parquet",
+	"class",
+	"arj",
+	"cpio",
+	"ace",
+	"avro",
+	"icc",
+	"fbx",
+	"vsdx",
+	"vtt",
+	"apk",
+	"drc",
+	"lz4",
+	"potx",
+	"xltx",
+	"dotx",
+	"xltm",
+	"ott",
+	"ots",
+	"otp",
+	"odg",
+	"otg",
+	"xlsm",
+	"docm",
+	"dotm",
+	"potm",
+	"pptm",
+	"jar",
+	"jmp",
+	"rm",
+	"sav",
+	"ppsm",
+	"ppsx",
+	"tar.gz",
+	"reg",
+	"dat"
+], xt = [
+	"image/jpeg",
+	"image/png",
+	"image/gif",
+	"image/webp",
+	"image/flif",
+	"image/x-xcf",
+	"image/x-canon-cr2",
+	"image/x-canon-cr3",
+	"image/tiff",
+	"image/bmp",
+	"image/vnd.ms-photo",
+	"image/vnd.adobe.photoshop",
+	"application/x-indesign",
+	"application/epub+zip",
+	"application/x-xpinstall",
+	"application/vnd.ms-powerpoint.slideshow.macroenabled.12",
+	"application/vnd.oasis.opendocument.text",
+	"application/vnd.oasis.opendocument.spreadsheet",
+	"application/vnd.oasis.opendocument.presentation",
+	"application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+	"application/vnd.openxmlformats-officedocument.presentationml.presentation",
+	"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+	"application/vnd.openxmlformats-officedocument.presentationml.slideshow",
+	"application/zip",
+	"application/x-tar",
+	"application/x-rar-compressed",
+	"application/gzip",
+	"application/x-bzip2",
+	"application/x-7z-compressed",
+	"application/x-apple-diskimage",
+	"application/vnd.apache.arrow.file",
+	"video/mp4",
+	"audio/midi",
+	"video/matroska",
+	"video/webm",
+	"video/quicktime",
+	"video/vnd.avi",
+	"audio/wav",
+	"audio/qcelp",
+	"audio/x-ms-asf",
+	"video/x-ms-asf",
+	"application/vnd.ms-asf",
+	"video/mpeg",
+	"video/3gpp",
+	"audio/mpeg",
+	"audio/mp4",
+	"video/ogg",
+	"audio/ogg",
+	"audio/ogg; codecs=opus",
+	"application/ogg",
+	"audio/flac",
+	"audio/ape",
+	"audio/wavpack",
+	"audio/amr",
+	"application/pdf",
+	"application/x-elf",
+	"application/x-mach-binary",
+	"application/x-msdownload",
+	"application/x-shockwave-flash",
+	"application/rtf",
+	"application/wasm",
+	"font/woff",
+	"font/woff2",
+	"application/vnd.ms-fontobject",
+	"font/ttf",
+	"font/otf",
+	"font/collection",
+	"image/x-icon",
+	"video/x-flv",
+	"application/postscript",
+	"application/eps",
+	"application/x-xz",
+	"application/x-sqlite3",
+	"application/x-nintendo-nes-rom",
+	"application/x-google-chrome-extension",
+	"application/vnd.ms-cab-compressed",
+	"application/x-deb",
+	"application/x-unix-archive",
+	"application/x-rpm",
+	"application/x-compress",
+	"application/x-lzip",
+	"application/x-cfb",
+	"application/x-mie",
+	"application/mxf",
+	"video/mp2t",
+	"application/x-blender",
+	"image/bpg",
+	"image/j2c",
+	"image/jp2",
+	"image/jpx",
+	"image/jpm",
+	"image/mj2",
+	"audio/aiff",
+	"application/xml",
+	"application/x-mobipocket-ebook",
+	"image/heif",
+	"image/heif-sequence",
+	"image/heic",
+	"image/heic-sequence",
+	"image/icns",
+	"image/ktx",
+	"application/dicom",
+	"audio/x-musepack",
+	"text/calendar",
+	"text/vcard",
+	"text/vtt",
+	"model/gltf-binary",
+	"application/vnd.tcpdump.pcap",
+	"audio/x-dsf",
+	"application/x.ms.shortcut",
+	"application/x.apple.alias",
+	"audio/x-voc",
+	"audio/vnd.dolby.dd-raw",
+	"audio/x-m4a",
+	"image/apng",
+	"image/x-olympus-orf",
+	"image/x-sony-arw",
+	"image/x-adobe-dng",
+	"image/x-nikon-nef",
+	"image/x-panasonic-rw2",
+	"image/x-fujifilm-raf",
+	"video/x-m4v",
+	"video/3gpp2",
+	"application/x-esri-shape",
+	"audio/aac",
+	"audio/x-it",
+	"audio/x-s3m",
+	"audio/x-xm",
+	"video/MP1S",
+	"video/MP2P",
+	"application/vnd.sketchup.skp",
+	"image/avif",
+	"application/x-lzh-compressed",
+	"application/pgp-encrypted",
+	"application/x-asar",
+	"model/stl",
+	"application/vnd.ms-htmlhelp",
+	"model/3mf",
+	"image/jxl",
+	"application/zstd",
+	"image/jls",
+	"application/vnd.ms-outlook",
+	"image/vnd.dwg",
+	"application/vnd.apache.parquet",
+	"application/java-vm",
+	"application/x-arj",
+	"application/x-cpio",
+	"application/x-ace-compressed",
+	"application/avro",
+	"application/vnd.iccprofile",
+	"application/x.autodesk.fbx",
+	"application/vnd.visio",
+	"application/vnd.android.package-archive",
+	"application/vnd.google.draco",
+	"application/x-lz4",
+	"application/vnd.openxmlformats-officedocument.presentationml.template",
+	"application/vnd.openxmlformats-officedocument.spreadsheetml.template",
+	"application/vnd.openxmlformats-officedocument.wordprocessingml.template",
+	"application/vnd.ms-excel.template.macroenabled.12",
+	"application/vnd.oasis.opendocument.text-template",
+	"application/vnd.oasis.opendocument.spreadsheet-template",
+	"application/vnd.oasis.opendocument.presentation-template",
+	"application/vnd.oasis.opendocument.graphics",
+	"application/vnd.oasis.opendocument.graphics-template",
+	"application/vnd.ms-excel.sheet.macroenabled.12",
+	"application/vnd.ms-word.document.macroenabled.12",
+	"application/vnd.ms-word.template.macroenabled.12",
+	"application/vnd.ms-powerpoint.template.macroenabled.12",
+	"application/vnd.ms-powerpoint.presentation.macroenabled.12",
+	"application/java-archive",
+	"application/vnd.rn-realmedia",
+	"application/x-spss-sav",
+	"application/x-ms-regedit",
+	"application/x-ft-windows-registry-hive",
+	"application/x-jmp-data"
+];
+var K = 4100, wi = K - 2, z = 1024 * 1024, ht = 1024, yi = 2 ** 31 - 1, v = 16 * 1024 * 1024, xe = z, gt = z, ki = v, bi = 1, wt = 100, Ie = v, yt = 64, kt = xe, Ci = 256, Si = 512, Fi = v, Ei = 512, Ti = 512, bt = 256, Ct = xe, St = xe, vi = xe, Ft = v, Ai = new Set([
+	"Unexpected signature",
+	"Encrypted ZIP",
+	"Expected Central-File-Header signature"
+]), Ii = [
+	"ZIP entry count exceeds ",
+	"Unsupported ZIP compression method:",
+	"ZIP entry compressed data exceeds ",
+	"ZIP entry decompressed data exceeds ",
+	"Expected data-descriptor-signature at position "
+], Bi = new Set([
+	"Z_BUF_ERROR",
+	"Z_DATA_ERROR",
+	"ERR_INVALID_STATE"
+]), M = class extends Error {};
+function Di(i) {
+	let e = i?.streamReader;
+	if (e?.constructor?.name !== "WebStreamByobReader") return i;
+	let { reader: t } = e, r = async () => {
+		await t.cancel(), t.releaseLock();
+	};
+	return e.close = r, e.abort = async () => {
+		e.interrupted = !0, await r();
+	}, i;
+}
+function Oe(i, e, t) {
+	if (!Number.isFinite(i) || i < 0 || i > e) throw new M(`${t} has invalid size ${i} (maximum ${e} bytes)`);
+	return i;
+}
+async function R(i, e, { maximumLength: t = v, reason: r = "skip" } = {}) {
+	let n = Oe(e, t, r);
+	await i.ignore(n);
+}
+async function Be(i, e, t, { maximumLength: r = e.length, reason: n = "read" } = {}) {
+	let s = Oe(t?.length ?? e.length, r, n);
+	return i.readBuffer(e, {
+		...t,
+		length: s
+	});
+}
+async function Oi(i, { maximumLength: e = z } = {}) {
+	let n = new ReadableStream({ start(f) {
+		f.enqueue(i), f.close();
+	} }).pipeThrough(new DecompressionStream("deflate-raw")).getReader(), o = [], s = 0;
+	try {
+		for (;;) {
+			let { done: f, value: c } = await n.read();
+			if (f) break;
+			if (s += c.length, s > e) throw await n.cancel(), /* @__PURE__ */ new Error(`ZIP entry decompressed data exceeds ${e} bytes`);
+			o.push(c);
+		}
+	} finally {
+		n.releaseLock();
+	}
+	let a = new Uint8Array(s), m = 0;
+	for (let f of o) a.set(f, m), m += f.length;
+	return a;
+}
+var At = 134695760, de = 16, zi = de - 1;
+function Mi(i, e) {
+	if (i.length < de) return -1;
+	let t = i.length - de;
+	for (let r = 0; r <= t; r++) if (x.get(i, r) === At && x.get(i, r + 8) === e + r) return r;
+	return -1;
+}
+function Li(i) {
+	return (i.codePointAt(0) & 32) !== 0;
+}
+function Ui(i, e) {
+	let t = new Uint8Array(e), r = 0;
+	for (let n of i) t.set(n, r), r += n.length;
+	return t;
+}
+async function Ri(i, { shouldBuffer: e, maximumLength: t = z } = {}) {
+	let { syncBuffer: r } = i, { length: n } = r, o = [], s = 0;
+	for (;;) {
+		let a = await i.tokenizer.peekBuffer(r, { mayBeLess: !0 }), m = Mi(r.subarray(0, a), s), f = m >= 0 ? 0 : a === n ? Math.min(zi, a - 1) : 0, c = m >= 0 ? m : a - f;
+		if (c === 0) break;
+		if (s += c, s > t) throw new Error(`ZIP entry compressed data exceeds ${t} bytes`);
+		if (e) {
+			let p = new Uint8Array(c);
+			await i.tokenizer.readBuffer(p), o.push(p);
+		} else await i.tokenizer.ignore(c);
+		if (m >= 0) break;
+	}
+	if (b(i.tokenizer) || (i.knownSizeDescriptorScannedBytes += s), !!e) return Ui(o, s);
+}
+function Pi(i, e) {
+	return b(i.tokenizer) ? Math.max(0, v - (i.tokenizer.position - e)) : Math.max(0, z - i.knownSizeDescriptorScannedBytes);
+}
+async function Ni(i, e, { shouldBuffer: t, maximumDescriptorLength: r = z } = {}) {
+	if (e.dataDescriptor && e.compressedSize === 0) return Ri(i, {
+		shouldBuffer: t,
+		maximumLength: r
+	});
+	if (!t) {
+		await R(i.tokenizer, e.compressedSize, {
+			maximumLength: b(i.tokenizer) ? z : i.tokenizer.fileInfo.size,
+			reason: "ZIP entry compressed data"
+		});
+		return;
+	}
+	let n = Zi(i.tokenizer);
+	if (!Number.isFinite(e.compressedSize) || e.compressedSize < 0 || e.compressedSize > n) throw new Error(`ZIP entry compressed data exceeds ${n} bytes`);
+	let o = new Uint8Array(e.compressedSize);
+	return await i.tokenizer.readBuffer(o), o;
+}
+G.prototype.inflate = async function(i, e, t) {
+	if (i.compressedMethod === 0) return t(e);
+	if (i.compressedMethod !== 8) throw new Error(`Unsupported ZIP compression method: ${i.compressedMethod}`);
+	return t(await Oi(e, { maximumLength: z }));
+};
+G.prototype.unzip = async function(i) {
+	let e = !1, t = 0, r = this.tokenizer.position;
+	this.knownSizeDescriptorScannedBytes = 0;
+	do {
+		if (ee(this.tokenizer, r, v)) throw new M(`ZIP stream probing exceeds ${v} bytes`);
+		let n = await this.readLocalFileHeader();
+		if (!n) break;
+		if (t++, t > ht) throw new Error(`ZIP entry count exceeds ${ht}`);
+		let o = i(n);
+		e = !!o.stop, await this.tokenizer.ignore(n.extraFieldLength);
+		let s = await Ni(this, n, {
+			shouldBuffer: !!o.handler,
+			maximumDescriptorLength: Math.min(z, Pi(this, r))
+		});
+		if (o.handler && await this.inflate(n, s, o.handler), n.dataDescriptor) {
+			let a = new Uint8Array(de);
+			if (await this.tokenizer.readBuffer(a), x.get(a, 0) !== At) throw new Error(`Expected data-descriptor-signature at position ${this.tokenizer.position - a.length}`);
+		}
+		if (ee(this.tokenizer, r, v)) throw new M(`ZIP stream probing exceeds ${v} bytes`);
+	} while (!e);
+};
+function ji(i, e) {
+	let t = i.getReader(), r = 0, n = !1, o = !1, s = async (a) => {
+		n || o || (o = !0, await t.cancel(a));
+	};
+	return new ReadableStream({
+		async pull(a) {
+			if (r >= e) {
+				a.close(), await s();
+				return;
+			}
+			let { done: m, value: f } = await t.read();
+			if (m || !f) {
+				n = !0, a.close();
+				return;
+			}
+			let c = e - r;
+			if (f.length > c) {
+				a.enqueue(f.subarray(0, c)), r += c, a.close(), await s();
+				return;
+			}
+			a.enqueue(f), r += f.length;
+		},
+		async cancel(a) {
+			await s(a);
+		}
+	});
+}
+async function ze(i, e) {
+	return new De(e).fromBuffer(i);
+}
+function Et(i) {
+	switch (i = i.toLowerCase(), i) {
+		case "application/epub+zip": return {
+			ext: "epub",
+			mime: i
+		};
+		case "application/vnd.oasis.opendocument.text": return {
+			ext: "odt",
+			mime: i
+		};
+		case "application/vnd.oasis.opendocument.text-template": return {
+			ext: "ott",
+			mime: i
+		};
+		case "application/vnd.oasis.opendocument.spreadsheet": return {
+			ext: "ods",
+			mime: i
+		};
+		case "application/vnd.oasis.opendocument.spreadsheet-template": return {
+			ext: "ots",
+			mime: i
+		};
+		case "application/vnd.oasis.opendocument.presentation": return {
+			ext: "odp",
+			mime: i
+		};
+		case "application/vnd.oasis.opendocument.presentation-template": return {
+			ext: "otp",
+			mime: i
+		};
+		case "application/vnd.oasis.opendocument.graphics": return {
+			ext: "odg",
+			mime: i
+		};
+		case "application/vnd.oasis.opendocument.graphics-template": return {
+			ext: "otg",
+			mime: i
+		};
+		case "application/vnd.openxmlformats-officedocument.presentationml.slideshow": return {
+			ext: "ppsx",
+			mime: i
+		};
+		case "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": return {
+			ext: "xlsx",
+			mime: i
+		};
+		case "application/vnd.ms-excel.sheet.macroenabled": return {
+			ext: "xlsm",
+			mime: "application/vnd.ms-excel.sheet.macroenabled.12"
+		};
+		case "application/vnd.openxmlformats-officedocument.spreadsheetml.template": return {
+			ext: "xltx",
+			mime: i
+		};
+		case "application/vnd.ms-excel.template.macroenabled": return {
+			ext: "xltm",
+			mime: "application/vnd.ms-excel.template.macroenabled.12"
+		};
+		case "application/vnd.ms-powerpoint.slideshow.macroenabled": return {
+			ext: "ppsm",
+			mime: "application/vnd.ms-powerpoint.slideshow.macroenabled.12"
+		};
+		case "application/vnd.openxmlformats-officedocument.wordprocessingml.document": return {
+			ext: "docx",
+			mime: i
+		};
+		case "application/vnd.ms-word.document.macroenabled": return {
+			ext: "docm",
+			mime: "application/vnd.ms-word.document.macroenabled.12"
+		};
+		case "application/vnd.openxmlformats-officedocument.wordprocessingml.template": return {
+			ext: "dotx",
+			mime: i
+		};
+		case "application/vnd.ms-word.template.macroenabledtemplate": return {
+			ext: "dotm",
+			mime: "application/vnd.ms-word.template.macroenabled.12"
+		};
+		case "application/vnd.openxmlformats-officedocument.presentationml.template": return {
+			ext: "potx",
+			mime: i
+		};
+		case "application/vnd.ms-powerpoint.template.macroenabled": return {
+			ext: "potm",
+			mime: "application/vnd.ms-powerpoint.template.macroenabled.12"
+		};
+		case "application/vnd.openxmlformats-officedocument.presentationml.presentation": return {
+			ext: "pptx",
+			mime: i
+		};
+		case "application/vnd.ms-powerpoint.presentation.macroenabled": return {
+			ext: "pptm",
+			mime: "application/vnd.ms-powerpoint.presentation.macroenabled.12"
+		};
+		case "application/vnd.ms-visio.drawing": return {
+			ext: "vsdx",
+			mime: "application/vnd.visio"
+		};
+		case "application/vnd.ms-package.3dmanufacturing-3dmodel+xml": return {
+			ext: "3mf",
+			mime: "model/3mf"
+		};
+		default:
+	}
+}
+function O(i, e, t) {
+	t = {
+		offset: 0,
+		...t
+	};
+	for (let [r, n] of e.entries()) if (t.mask) {
+		if (n !== (t.mask[r] & i[r + t.offset])) return !1;
+	} else if (n !== i[r + t.offset]) return !1;
+	return !0;
+}
+function _i(i) {
+	return Number.isFinite(i) ? Math.max(1, Math.trunc(i)) : K;
+}
+function $i(i, e, t) {
+	return t === void 0 ? i.read(e) : (t.throwIfAborted(), new Promise((r, n) => {
+		let o = () => {
+			t.removeEventListener("abort", s);
+		}, s = () => {
+			let a = t.reason;
+			o(), (async () => {
+				try {
+					await i.cancel(a);
+				} catch {}
+			})(), n(a);
+		};
+		t.addEventListener("abort", s, { once: !0 }), (async () => {
+			try {
+				let a = await i.read(e);
+				o(), r(a);
+			} catch (a) {
+				o(), n(a);
+			}
+		})();
+	}));
+}
+function Wi(i) {
+	return Number.isFinite(i) ? Math.max(0, Math.min(wi, Math.trunc(i))) : 0;
+}
+function Gi(i) {
+	return Number.isFinite(i) ? Math.max(0, i) : Number.MAX_SAFE_INTEGER;
+}
+function b(i) {
+	let e = i.fileInfo.size;
+	return !Number.isFinite(e) || e === Number.MAX_SAFE_INTEGER;
+}
+function ee(i, e, t) {
+	return b(i) && i.position - e > t;
+}
+function Zi(i) {
+	let e = i.fileInfo.size, t = Number.isFinite(e) ? Math.max(0, e - i.position) : Number.MAX_SAFE_INTEGER;
+	return Math.min(t, yi);
+}
+function Vi(i) {
+	if (i instanceof l || i instanceof M) return !0;
+	if (!(i instanceof Error)) return !1;
+	if (Ai.has(i.message) || Bi.has(i.code)) return !0;
+	for (let e of Ii) if (i.message.startsWith(e)) return !0;
+	return !1;
+}
+function Tt(i, e = z) {
+	let t = [i.compressedSize, i.uncompressedSize];
+	for (let r of t) if (!Number.isFinite(r) || r < 0 || r > e) return !1;
+	return !0;
+}
+function qi() {
+	return {
+		hasContentTypesEntry: !1,
+		hasParsedContentTypesEntry: !1,
+		isParsingContentTypes: !1,
+		hasUnparseableContentTypes: !1,
+		hasWordDirectory: !1,
+		hasPresentationDirectory: !1,
+		hasSpreadsheetDirectory: !1,
+		hasThreeDimensionalModelEntry: !1
+	};
+}
+function Hi(i, e) {
+	e.startsWith("word/") && (i.hasWordDirectory = !0), e.startsWith("ppt/") && (i.hasPresentationDirectory = !0), e.startsWith("xl/") && (i.hasSpreadsheetDirectory = !0), e.startsWith("3D/") && e.endsWith(".model") && (i.hasThreeDimensionalModelEntry = !0);
+}
+function vt(i) {
+	if (!(!i.hasContentTypesEntry || i.hasUnparseableContentTypes || i.isParsingContentTypes || i.hasParsedContentTypesEntry)) {
+		if (i.hasWordDirectory) return {
+			ext: "docx",
+			mime: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+		};
+		if (i.hasPresentationDirectory) return {
+			ext: "pptx",
+			mime: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+		};
+		if (i.hasSpreadsheetDirectory) return {
+			ext: "xlsx",
+			mime: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+		};
+		if (i.hasThreeDimensionalModelEntry) return {
+			ext: "3mf",
+			mime: "model/3mf"
+		};
+	}
+}
+function Ji(i) {
+	let e = i.indexOf(".main+xml\"");
+	if (e === -1) {
+		let n = "application/vnd.ms-package.3dmanufacturing-3dmodel+xml";
+		return i.includes(`ContentType="${n}"`) ? n : void 0;
+	}
+	let t = i.slice(0, e), r = t.lastIndexOf("\"");
+	return t.slice(r + 1);
+}
+var De = class i {
+	constructor(e) {
+		let t = Wi(e?.mpegOffsetTolerance);
+		this.options = {
+			...e,
+			mpegOffsetTolerance: t
+		}, this.detectors = [
+			...this.options.customDetectors ?? [],
+			{
+				id: "core",
+				detect: this.detectConfident
+			},
+			{
+				id: "core.imprecise",
+				detect: this.detectImprecise
+			}
+		], this.tokenizerOptions = { abortSignal: this.options.signal }, this.gzipProbeDepth = 0;
+	}
+	getTokenizerOptions() {
+		return { ...this.tokenizerOptions };
+	}
+	createTokenizerFromWebStream(e) {
+		return Di(Pe(e, this.getTokenizerOptions()));
+	}
+	async parseTokenizer(e, t = 0) {
+		this.detectionReentryCount = t;
+		let r = e.position;
+		for (let n of this.detectors) {
+			let o;
+			try {
+				o = await n.detect(e);
+			} catch (s) {
+				if (s instanceof l || s instanceof M) return;
+				throw s;
+			}
+			if (o) return o;
+			if (r !== e.position) return;
+		}
+	}
+	async fromTokenizer(e) {
+		try {
+			return await this.parseTokenizer(e);
+		} finally {
+			await e.close();
+		}
+	}
+	async fromBuffer(e) {
+		if (!(e instanceof Uint8Array || e instanceof ArrayBuffer)) throw new TypeError(`Expected the \`input\` argument to be of type \`Uint8Array\` or \`ArrayBuffer\`, got \`${typeof e}\``);
+		let t = e instanceof Uint8Array ? e : new Uint8Array(e);
+		if (t?.length > 1) return this.fromTokenizer(Ne(t, this.getTokenizerOptions()));
+	}
+	async fromBlob(e) {
+		this.options.signal?.throwIfAborted();
+		let t = je(e, this.getTokenizerOptions());
+		return this.fromTokenizer(t);
+	}
+	async fromStream(e) {
+		this.options.signal?.throwIfAborted();
+		let t = this.createTokenizerFromWebStream(e);
+		return this.fromTokenizer(t);
+	}
+	async toDetectionStream(e, t) {
+		let r = _i(t?.sampleSize ?? K), n, o, s = e.getReader({ mode: "byob" });
+		try {
+			let { value: f, done: c } = await $i(s, new Uint8Array(r), this.options.signal);
+			if (o = f, !c && f) try {
+				n = await this.fromBuffer(f.subarray(0, r));
+			} catch (p) {
+				if (!(p instanceof l)) throw p;
+				n = void 0;
+			}
+			o = f;
+		} finally {
+			s.releaseLock();
+		}
+		let a = new TransformStream({
+			async start(f) {
+				f.enqueue(o);
+			},
+			transform(f, c) {
+				c.enqueue(f);
+			}
+		}), m = e.pipeThrough(a);
+		return m.fileType = n, m;
+	}
+	async detectGzip(e) {
+		if (this.gzipProbeDepth >= bi) return {
+			ext: "gz",
+			mime: "application/gzip"
+		};
+		let r = ji(new Y(e).inflate(), ki), n = b(e), o, s, a, m;
+		if (n) {
+			let f = new AbortController();
+			o = setTimeout(() => {
+				f.abort(new DOMException(`Operation timed out after ${wt} ms`, "TimeoutError"));
+			}, wt), s = this.options.signal === void 0 ? f.signal : AbortSignal.any([this.options.signal, f.signal]), a = new i({
+				...this.options,
+				signal: s
+			}), a.gzipProbeDepth = this.gzipProbeDepth + 1;
+		} else this.gzipProbeDepth++;
+		try {
+			m = await (a ?? this).fromStream(r);
+		} catch (f) {
+			if (f?.name === "AbortError" && s?.reason?.name !== "TimeoutError") throw f;
+		} finally {
+			clearTimeout(o), n || this.gzipProbeDepth--;
+		}
+		return m?.ext === "tar" ? {
+			ext: "tar.gz",
+			mime: "application/gzip"
+		} : {
+			ext: "gz",
+			mime: "application/gzip"
+		};
+	}
+	check(e, t) {
+		return O(this.buffer, e, t);
+	}
+	checkString(e, t) {
+		return this.check(mt(e, t?.encoding), t);
+	}
+	detectConfident = async (e) => {
+		if (this.buffer = new Uint8Array(K), e.fileInfo.size === void 0 && (e.fileInfo.size = Number.MAX_SAFE_INTEGER), this.tokenizer = e, b(e) && (await e.peekBuffer(this.buffer, {
+			length: 3,
+			mayBeLess: !0
+		}), this.check([
+			31,
+			139,
+			8
+		]))) return this.detectGzip(e);
+		if (await e.peekBuffer(this.buffer, {
+			length: 32,
+			mayBeLess: !0
+		}), this.check([66, 77])) return {
+			ext: "bmp",
+			mime: "image/bmp"
+		};
+		if (this.check([11, 119])) return {
+			ext: "ac3",
+			mime: "audio/vnd.dolby.dd-raw"
+		};
+		if (this.check([120, 1])) return {
+			ext: "dmg",
+			mime: "application/x-apple-diskimage"
+		};
+		if (this.check([77, 90])) return {
+			ext: "exe",
+			mime: "application/x-msdownload"
+		};
+		if (this.check([37, 33])) return await e.peekBuffer(this.buffer, {
+			length: 24,
+			mayBeLess: !0
+		}), this.checkString("PS-Adobe-", { offset: 2 }) && this.checkString(" EPSF-", { offset: 14 }) ? {
+			ext: "eps",
+			mime: "application/eps"
+		} : {
+			ext: "ps",
+			mime: "application/postscript"
+		};
+		if (this.check([31, 160]) || this.check([31, 157])) return {
+			ext: "Z",
+			mime: "application/x-compress"
+		};
+		if (this.check([199, 113])) return {
+			ext: "cpio",
+			mime: "application/x-cpio"
+		};
+		if (this.check([96, 234])) return {
+			ext: "arj",
+			mime: "application/x-arj"
+		};
+		if (this.check([
+			239,
+			187,
+			191
+		])) return this.detectionReentryCount >= bt ? void 0 : (this.detectionReentryCount++, await this.tokenizer.ignore(3), this.detectConfident(e));
+		if (this.check([
+			71,
+			73,
+			70
+		])) return {
+			ext: "gif",
+			mime: "image/gif"
+		};
+		if (this.check([
+			73,
+			73,
+			188
+		])) return {
+			ext: "jxr",
+			mime: "image/vnd.ms-photo"
+		};
+		if (this.check([
+			31,
+			139,
+			8
+		])) return this.detectGzip(e);
+		if (this.check([
+			66,
+			90,
+			104
+		])) return {
+			ext: "bz2",
+			mime: "application/x-bzip2"
+		};
+		if (this.checkString("ID3")) {
+			await R(e, 6, {
+				maximumLength: 6,
+				reason: "ID3 header prefix"
+			});
+			let t = await e.readToken(lt), r = b(e);
+			if (!Number.isFinite(t) || t < 0 || r && (t > Ie || e.position + t > Ie)) return;
+			if (e.position + t > e.fileInfo.size) return r ? void 0 : {
+				ext: "mp3",
+				mime: "audio/mpeg"
+			};
+			try {
+				await R(e, t, {
+					maximumLength: r ? Ie : e.fileInfo.size,
+					reason: "ID3 payload"
+				});
+			} catch (n) {
+				if (n instanceof l) return;
+				throw n;
+			}
+			return this.detectionReentryCount >= bt ? void 0 : (this.detectionReentryCount++, this.parseTokenizer(e, this.detectionReentryCount));
+		}
+		if (this.checkString("MP+")) return {
+			ext: "mpc",
+			mime: "audio/x-musepack"
+		};
+		if ((this.buffer[0] === 67 || this.buffer[0] === 70) && this.check([87, 83], { offset: 1 })) return {
+			ext: "swf",
+			mime: "application/x-shockwave-flash"
+		};
+		if (this.check([
+			255,
+			216,
+			255
+		])) return this.check([247], { offset: 3 }) ? {
+			ext: "jls",
+			mime: "image/jls"
+		} : {
+			ext: "jpg",
+			mime: "image/jpeg"
+		};
+		if (this.check([
+			79,
+			98,
+			106,
+			1
+		])) return {
+			ext: "avro",
+			mime: "application/avro"
+		};
+		if (this.checkString("FLIF")) return {
+			ext: "flif",
+			mime: "image/flif"
+		};
+		if (this.checkString("8BPS")) return {
+			ext: "psd",
+			mime: "image/vnd.adobe.photoshop"
+		};
+		if (this.checkString("MPCK")) return {
+			ext: "mpc",
+			mime: "audio/x-musepack"
+		};
+		if (this.checkString("FORM")) return {
+			ext: "aif",
+			mime: "audio/aiff"
+		};
+		if (this.checkString("icns", { offset: 0 })) return {
+			ext: "icns",
+			mime: "image/icns"
+		};
+		if (this.check([
+			80,
+			75,
+			3,
+			4
+		])) {
+			let t, r = qi();
+			try {
+				await new G(e).unzip((n) => {
+					Hi(r, n.filename);
+					let o = n.filename === "[Content_Types].xml", s = vt(r);
+					if (!o && s) return t = s, { stop: !0 };
+					switch (n.filename) {
+						case "META-INF/mozilla.rsa": return t = {
+							ext: "xpi",
+							mime: "application/x-xpinstall"
+						}, { stop: !0 };
+						case "META-INF/MANIFEST.MF": return t = {
+							ext: "jar",
+							mime: "application/java-archive"
+						}, { stop: !0 };
+						case "mimetype": return Tt(n, gt) ? {
+							async handler(a) {
+								t = Et(new TextDecoder("utf-8").decode(a).trim());
+							},
+							stop: !0
+						} : {};
+						case "[Content_Types].xml": return r.hasContentTypesEntry = !0, Tt(n, gt) ? (r.isParsingContentTypes = !0, {
+							async handler(a) {
+								let f = Ji(new TextDecoder("utf-8").decode(a));
+								f && (t = Et(f)), r.hasParsedContentTypesEntry = !0, r.isParsingContentTypes = !1;
+							},
+							stop: !0
+						}) : (r.hasUnparseableContentTypes = !0, {});
+						default: return /classes\d*\.dex/.test(n.filename) ? (t = {
+							ext: "apk",
+							mime: "application/vnd.android.package-archive"
+						}, { stop: !0 }) : {};
+					}
+				});
+			} catch (n) {
+				if (!Vi(n)) throw n;
+				r.isParsingContentTypes && (r.isParsingContentTypes = !1, r.hasUnparseableContentTypes = !0);
+			}
+			return t ?? vt(r) ?? {
+				ext: "zip",
+				mime: "application/zip"
+			};
+		}
+		if (this.checkString("OggS")) {
+			await e.ignore(28);
+			let t = new Uint8Array(8);
+			return await e.readBuffer(t), O(t, [
+				79,
+				112,
+				117,
+				115,
+				72,
+				101,
+				97,
+				100
+			]) ? {
+				ext: "opus",
+				mime: "audio/ogg; codecs=opus"
+			} : O(t, [
+				128,
+				116,
+				104,
+				101,
+				111,
+				114,
+				97
+			]) ? {
+				ext: "ogv",
+				mime: "video/ogg"
+			} : O(t, [
+				1,
+				118,
+				105,
+				100,
+				101,
+				111,
+				0
+			]) ? {
+				ext: "ogm",
+				mime: "video/ogg"
+			} : O(t, [
+				127,
+				70,
+				76,
+				65,
+				67
+			]) ? {
+				ext: "oga",
+				mime: "audio/ogg"
+			} : O(t, [
+				83,
+				112,
+				101,
+				101,
+				120,
+				32,
+				32
+			]) ? {
+				ext: "spx",
+				mime: "audio/ogg"
+			} : O(t, [
+				1,
+				118,
+				111,
+				114,
+				98,
+				105,
+				115
+			]) ? {
+				ext: "ogg",
+				mime: "audio/ogg"
+			} : {
+				ext: "ogx",
+				mime: "application/ogg"
+			};
+		}
+		if (this.check([80, 75]) && (this.buffer[2] === 3 || this.buffer[2] === 5 || this.buffer[2] === 7) && (this.buffer[3] === 4 || this.buffer[3] === 6 || this.buffer[3] === 8)) return {
+			ext: "zip",
+			mime: "application/zip"
+		};
+		if (this.checkString("MThd")) return {
+			ext: "mid",
+			mime: "audio/midi"
+		};
+		if (this.checkString("wOFF") && (this.check([
+			0,
+			1,
+			0,
+			0
+		], { offset: 4 }) || this.checkString("OTTO", { offset: 4 }))) return {
+			ext: "woff",
+			mime: "font/woff"
+		};
+		if (this.checkString("wOF2") && (this.check([
+			0,
+			1,
+			0,
+			0
+		], { offset: 4 }) || this.checkString("OTTO", { offset: 4 }))) return {
+			ext: "woff2",
+			mime: "font/woff2"
+		};
+		if (this.check([
+			212,
+			195,
+			178,
+			161
+		]) || this.check([
+			161,
+			178,
+			195,
+			212
+		])) return {
+			ext: "pcap",
+			mime: "application/vnd.tcpdump.pcap"
+		};
+		if (this.checkString("DSD ")) return {
+			ext: "dsf",
+			mime: "audio/x-dsf"
+		};
+		if (this.checkString("LZIP")) return {
+			ext: "lz",
+			mime: "application/x-lzip"
+		};
+		if (this.checkString("fLaC")) return {
+			ext: "flac",
+			mime: "audio/flac"
+		};
+		if (this.check([
+			66,
+			80,
+			71,
+			251
+		])) return {
+			ext: "bpg",
+			mime: "image/bpg"
+		};
+		if (this.checkString("wvpk")) return {
+			ext: "wv",
+			mime: "audio/wavpack"
+		};
+		if (this.checkString("%PDF")) return {
+			ext: "pdf",
+			mime: "application/pdf"
+		};
+		if (this.check([
+			0,
+			97,
+			115,
+			109
+		])) return {
+			ext: "wasm",
+			mime: "application/wasm"
+		};
+		if (this.check([73, 73])) {
+			let t = await this.readTiffHeader(!1);
+			if (t) return t;
+		}
+		if (this.check([77, 77])) {
+			let t = await this.readTiffHeader(!0);
+			if (t) return t;
+		}
+		if (this.checkString("MAC ")) return {
+			ext: "ape",
+			mime: "audio/ape"
+		};
+		if (this.check([
+			26,
+			69,
+			223,
+			163
+		])) {
+			async function t() {
+				let m = await e.peekNumber(Ze), f = 128, c = 0;
+				for (; (m & f) === 0 && f !== 0;) ++c, f >>= 1;
+				let p = new Uint8Array(c + 1);
+				return await Be(e, p, void 0, {
+					maximumLength: p.length,
+					reason: "EBML field"
+				}), p;
+			}
+			async function r() {
+				let m = await t(), f = await t();
+				f[0] ^= 128 >> f.length - 1;
+				let c = Math.min(6, f.length), p = new DataView(m.buffer), u = new DataView(f.buffer, f.length - c, c);
+				return {
+					id: Ae(p),
+					len: Ae(u)
+				};
+			}
+			async function n(m) {
+				let f = 0;
+				for (; m > 0;) {
+					if (f++, f > Ci || ee(e, s, v)) return;
+					let c = e.position, p = await r();
+					if (p.id === 17026) {
+						if (p.len > yt) return;
+						let u = Oe(p.len, yt, "EBML DocType");
+						return (await e.readToken(new S(u))).replaceAll(/\00.*$/g, "");
+					}
+					if (b(e) && (!Number.isFinite(p.len) || p.len < 0 || p.len > kt) || (await R(e, p.len, {
+						maximumLength: b(e) ? kt : e.fileInfo.size,
+						reason: "EBML payload"
+					}), --m, e.position <= c)) return;
+				}
+			}
+			let o = await r(), s = e.position;
+			switch (await n(o.len)) {
+				case "webm": return {
+					ext: "webm",
+					mime: "video/webm"
+				};
+				case "matroska": return {
+					ext: "mkv",
+					mime: "video/matroska"
+				};
+				default: return;
+			}
+		}
+		if (this.checkString("SQLi")) return {
+			ext: "sqlite",
+			mime: "application/x-sqlite3"
+		};
+		if (this.check([
+			78,
+			69,
+			83,
+			26
+		])) return {
+			ext: "nes",
+			mime: "application/x-nintendo-nes-rom"
+		};
+		if (this.checkString("Cr24")) return {
+			ext: "crx",
+			mime: "application/x-google-chrome-extension"
+		};
+		if (this.checkString("MSCF") || this.checkString("ISc(")) return {
+			ext: "cab",
+			mime: "application/vnd.ms-cab-compressed"
+		};
+		if (this.check([
+			237,
+			171,
+			238,
+			219
+		])) return {
+			ext: "rpm",
+			mime: "application/x-rpm"
+		};
+		if (this.check([
+			197,
+			208,
+			211,
+			198
+		])) return {
+			ext: "eps",
+			mime: "application/eps"
+		};
+		if (this.check([
+			40,
+			181,
+			47,
+			253
+		])) return {
+			ext: "zst",
+			mime: "application/zstd"
+		};
+		if (this.check([
+			127,
+			69,
+			76,
+			70
+		])) return {
+			ext: "elf",
+			mime: "application/x-elf"
+		};
+		if (this.check([
+			33,
+			66,
+			68,
+			78
+		])) return {
+			ext: "pst",
+			mime: "application/vnd.ms-outlook"
+		};
+		if (this.checkString("PAR1") || this.checkString("PARE")) return {
+			ext: "parquet",
+			mime: "application/vnd.apache.parquet"
+		};
+		if (this.checkString("ttcf")) return {
+			ext: "ttc",
+			mime: "font/collection"
+		};
+		if (this.check([
+			254,
+			237,
+			250,
+			206
+		]) || this.check([
+			254,
+			237,
+			250,
+			207
+		]) || this.check([
+			206,
+			250,
+			237,
+			254
+		]) || this.check([
+			207,
+			250,
+			237,
+			254
+		])) return {
+			ext: "macho",
+			mime: "application/x-mach-binary"
+		};
+		if (this.check([
+			4,
+			34,
+			77,
+			24
+		])) return {
+			ext: "lz4",
+			mime: "application/x-lz4"
+		};
+		if (this.checkString("regf")) return {
+			ext: "dat",
+			mime: "application/x-ft-windows-registry-hive"
+		};
+		if (this.checkString("$FL2") || this.checkString("$FL3")) return {
+			ext: "sav",
+			mime: "application/x-spss-sav"
+		};
+		if (this.check([
+			79,
+			84,
+			84,
+			79,
+			0
+		])) return {
+			ext: "otf",
+			mime: "font/otf"
+		};
+		if (this.checkString("#!AMR")) return {
+			ext: "amr",
+			mime: "audio/amr"
+		};
+		if (this.checkString("{\\rtf")) return {
+			ext: "rtf",
+			mime: "application/rtf"
+		};
+		if (this.check([
+			70,
+			76,
+			86,
+			1
+		])) return {
+			ext: "flv",
+			mime: "video/x-flv"
+		};
+		if (this.checkString("IMPM")) return {
+			ext: "it",
+			mime: "audio/x-it"
+		};
+		if (this.checkString("-lh0-", { offset: 2 }) || this.checkString("-lh1-", { offset: 2 }) || this.checkString("-lh2-", { offset: 2 }) || this.checkString("-lh3-", { offset: 2 }) || this.checkString("-lh4-", { offset: 2 }) || this.checkString("-lh5-", { offset: 2 }) || this.checkString("-lh6-", { offset: 2 }) || this.checkString("-lh7-", { offset: 2 }) || this.checkString("-lzs-", { offset: 2 }) || this.checkString("-lz4-", { offset: 2 }) || this.checkString("-lz5-", { offset: 2 }) || this.checkString("-lhd-", { offset: 2 })) return {
+			ext: "lzh",
+			mime: "application/x-lzh-compressed"
+		};
+		if (this.check([
+			0,
+			0,
+			1,
+			186
+		])) {
+			if (this.check([33], {
+				offset: 4,
+				mask: [241]
+			})) return {
+				ext: "mpg",
+				mime: "video/MP1S"
+			};
+			if (this.check([68], {
+				offset: 4,
+				mask: [196]
+			})) return {
+				ext: "mpg",
+				mime: "video/MP2P"
+			};
+		}
+		if (this.checkString("ITSF")) return {
+			ext: "chm",
+			mime: "application/vnd.ms-htmlhelp"
+		};
+		if (this.check([
+			202,
+			254,
+			186,
+			190
+		])) {
+			let t = be.get(this.buffer, 4), r = _.get(this.buffer, 6);
+			if (t > 0 && t <= 30) return {
+				ext: "macho",
+				mime: "application/x-mach-binary"
+			};
+			if (r > 30) return {
+				ext: "class",
+				mime: "application/java-vm"
+			};
+		}
+		if (this.checkString(".RMF")) return {
+			ext: "rm",
+			mime: "application/vnd.rn-realmedia"
+		};
+		if (this.checkString("DRACO")) return {
+			ext: "drc",
+			mime: "application/vnd.google.draco"
+		};
+		if (this.check([
+			253,
+			55,
+			122,
+			88,
+			90,
+			0
+		])) return {
+			ext: "xz",
+			mime: "application/x-xz"
+		};
+		if (this.checkString("<?xml ")) return {
+			ext: "xml",
+			mime: "application/xml"
+		};
+		if (this.check([
+			55,
+			122,
+			188,
+			175,
+			39,
+			28
+		])) return {
+			ext: "7z",
+			mime: "application/x-7z-compressed"
+		};
+		if (this.check([
+			82,
+			97,
+			114,
+			33,
+			26,
+			7
+		]) && (this.buffer[6] === 0 || this.buffer[6] === 1)) return {
+			ext: "rar",
+			mime: "application/x-rar-compressed"
+		};
+		if (this.checkString("solid ")) return {
+			ext: "stl",
+			mime: "model/stl"
+		};
+		if (this.checkString("AC")) {
+			let t = new S(4, "latin1").get(this.buffer, 2);
+			if (t.match("^d*") && t >= 1e3 && t <= 1050) return {
+				ext: "dwg",
+				mime: "image/vnd.dwg"
+			};
+		}
+		if (this.checkString("070707")) return {
+			ext: "cpio",
+			mime: "application/x-cpio"
+		};
+		if (this.checkString("BLENDER")) return {
+			ext: "blend",
+			mime: "application/x-blender"
+		};
+		if (this.checkString("!<arch>")) return await e.ignore(8), await e.readToken(new S(13, "ascii")) === "debian-binary" ? {
+			ext: "deb",
+			mime: "application/x-deb"
+		} : {
+			ext: "ar",
+			mime: "application/x-unix-archive"
+		};
+		if (this.checkString("WEBVTT") && [
+			`
+`,
+			"\r",
+			"	",
+			" ",
+			"\0"
+		].some((t) => this.checkString(t, { offset: 6 }))) return {
+			ext: "vtt",
+			mime: "text/vtt"
+		};
+		if (this.check([
+			137,
+			80,
+			78,
+			71,
+			13,
+			10,
+			26,
+			10
+		])) {
+			let t = {
+				ext: "png",
+				mime: "image/png"
+			}, r = {
+				ext: "apng",
+				mime: "image/apng"
+			};
+			await e.ignore(8);
+			async function n() {
+				return {
+					length: await e.readToken(Ve),
+					type: await e.readToken(new S(4, "latin1"))
+				};
+			}
+			let o = b(e), s = e.position, a = 0, m = !1;
+			do {
+				if (a++, a > Si || ee(e, s, Fi)) break;
+				let f = e.position, c = await n();
+				if (c.length < 0) return;
+				if (c.type === "IHDR") {
+					if (c.length !== 13) return;
+					m = !0;
+				}
+				switch (c.type) {
+					case "IDAT": return t;
+					case "acTL": return r;
+					default:
+						if (!m && c.type !== "CgBI") return;
+						if (o && c.length > Ct) return m && Li(c.type) ? t : void 0;
+						try {
+							await R(e, c.length + 4, {
+								maximumLength: o ? Ct + 4 : e.fileInfo.size,
+								reason: "PNG chunk payload"
+							});
+						} catch (p) {
+							if (!o && (p instanceof M || p instanceof l)) return t;
+							throw p;
+						}
+				}
+				if (e.position <= f) break;
+			} while (e.position + 8 < e.fileInfo.size);
+			return t;
+		}
+		if (this.check([
+			65,
+			82,
+			82,
+			79,
+			87,
+			49,
+			0,
+			0
+		])) return {
+			ext: "arrow",
+			mime: "application/vnd.apache.arrow.file"
+		};
+		if (this.check([
+			103,
+			108,
+			84,
+			70,
+			2,
+			0,
+			0,
+			0
+		])) return {
+			ext: "glb",
+			mime: "model/gltf-binary"
+		};
+		if (this.check([
+			102,
+			114,
+			101,
+			101
+		], { offset: 4 }) || this.check([
+			109,
+			100,
+			97,
+			116
+		], { offset: 4 }) || this.check([
+			109,
+			111,
+			111,
+			118
+		], { offset: 4 }) || this.check([
+			119,
+			105,
+			100,
+			101
+		], { offset: 4 })) return {
+			ext: "mov",
+			mime: "video/quicktime"
+		};
+		if (this.check([
+			73,
+			73,
+			82,
+			79,
+			8,
+			0,
+			0,
+			0,
+			24
+		])) return {
+			ext: "orf",
+			mime: "image/x-olympus-orf"
+		};
+		if (this.checkString("gimp xcf ")) return {
+			ext: "xcf",
+			mime: "image/x-xcf"
+		};
+		if (this.checkString("ftyp", { offset: 4 }) && (this.buffer[8] & 96) !== 0) {
+			let t = new S(4, "latin1").get(this.buffer, 8).replace("\0", " ").trim();
+			switch (t) {
+				case "avif":
+				case "avis": return {
+					ext: "avif",
+					mime: "image/avif"
+				};
+				case "mif1": return {
+					ext: "heic",
+					mime: "image/heif"
+				};
+				case "msf1": return {
+					ext: "heic",
+					mime: "image/heif-sequence"
+				};
+				case "heic":
+				case "heix": return {
+					ext: "heic",
+					mime: "image/heic"
+				};
+				case "hevc":
+				case "hevx": return {
+					ext: "heic",
+					mime: "image/heic-sequence"
+				};
+				case "qt": return {
+					ext: "mov",
+					mime: "video/quicktime"
+				};
+				case "M4V":
+				case "M4VH":
+				case "M4VP": return {
+					ext: "m4v",
+					mime: "video/x-m4v"
+				};
+				case "M4P": return {
+					ext: "m4p",
+					mime: "video/mp4"
+				};
+				case "M4B": return {
+					ext: "m4b",
+					mime: "audio/mp4"
+				};
+				case "M4A": return {
+					ext: "m4a",
+					mime: "audio/x-m4a"
+				};
+				case "F4V": return {
+					ext: "f4v",
+					mime: "video/mp4"
+				};
+				case "F4P": return {
+					ext: "f4p",
+					mime: "video/mp4"
+				};
+				case "F4A": return {
+					ext: "f4a",
+					mime: "audio/mp4"
+				};
+				case "F4B": return {
+					ext: "f4b",
+					mime: "audio/mp4"
+				};
+				case "crx": return {
+					ext: "cr3",
+					mime: "image/x-canon-cr3"
+				};
+				default: return t.startsWith("3g") ? t.startsWith("3g2") ? {
+					ext: "3g2",
+					mime: "video/3gpp2"
+				} : {
+					ext: "3gp",
+					mime: "video/3gpp"
+				} : {
+					ext: "mp4",
+					mime: "video/mp4"
+				};
+			}
+		}
+		if (this.checkString(`REGEDIT4\r
+`)) return {
+			ext: "reg",
+			mime: "application/x-ms-regedit"
+		};
+		if (this.check([
+			82,
+			73,
+			70,
+			70
+		])) {
+			if (this.checkString("WEBP", { offset: 8 })) return {
+				ext: "webp",
+				mime: "image/webp"
+			};
+			if (this.check([
+				65,
+				86,
+				73
+			], { offset: 8 })) return {
+				ext: "avi",
+				mime: "video/vnd.avi"
+			};
+			if (this.check([
+				87,
+				65,
+				86,
+				69
+			], { offset: 8 })) return {
+				ext: "wav",
+				mime: "audio/wav"
+			};
+			if (this.check([
+				81,
+				76,
+				67,
+				77
+			], { offset: 8 })) return {
+				ext: "qcp",
+				mime: "audio/qcelp"
+			};
+		}
+		if (this.check([
+			73,
+			73,
+			85,
+			0,
+			24,
+			0,
+			0,
+			0,
+			136,
+			231,
+			116,
+			216
+		])) return {
+			ext: "rw2",
+			mime: "image/x-panasonic-rw2"
+		};
+		if (this.check([
+			48,
+			38,
+			178,
+			117,
+			142,
+			102,
+			207,
+			17,
+			166,
+			217
+		])) {
+			let t = !1;
+			try {
+				async function r() {
+					let a = new Uint8Array(16);
+					return await Be(e, a, void 0, {
+						maximumLength: a.length,
+						reason: "ASF header GUID"
+					}), {
+						id: a,
+						size: Number(await e.readToken(qe))
+					};
+				}
+				await R(e, 30, {
+					maximumLength: 30,
+					reason: "ASF header prelude"
+				});
+				let n = b(e), o = e.position, s = 0;
+				for (; e.position + 24 < e.fileInfo.size && (s++, !(s > Ei || ee(e, o, v)));) {
+					let a = e.position, m = await r(), f = m.size - 24;
+					if (!Number.isFinite(f) || f < 0) {
+						t = !0;
+						break;
+					}
+					if (O(m.id, [
+						145,
+						7,
+						220,
+						183,
+						183,
+						169,
+						207,
+						17,
+						142,
+						230,
+						0,
+						192,
+						12,
+						32,
+						83,
+						101
+					])) {
+						let c = new Uint8Array(16);
+						if (f -= await Be(e, c, void 0, {
+							maximumLength: c.length,
+							reason: "ASF stream type GUID"
+						}), O(c, [
+							64,
+							158,
+							105,
+							248,
+							77,
+							91,
+							207,
+							17,
+							168,
+							253,
+							0,
+							128,
+							95,
+							92,
+							68,
+							43
+						])) return {
+							ext: "asf",
+							mime: "audio/x-ms-asf"
+						};
+						if (O(c, [
+							192,
+							239,
+							25,
+							188,
+							77,
+							91,
+							207,
+							17,
+							168,
+							253,
+							0,
+							128,
+							95,
+							92,
+							68,
+							43
+						])) return {
+							ext: "asf",
+							mime: "video/x-ms-asf"
+						};
+						break;
+					}
+					if (n && f > St) {
+						t = !0;
+						break;
+					}
+					if (await R(e, f, {
+						maximumLength: n ? St : e.fileInfo.size,
+						reason: "ASF header payload"
+					}), e.position <= a) {
+						t = !0;
+						break;
+					}
+				}
+			} catch (r) {
+				if (r instanceof l || r instanceof M) b(e) && (t = !0);
+				else throw r;
+			}
+			return t ? void 0 : {
+				ext: "asf",
+				mime: "application/vnd.ms-asf"
+			};
+		}
+		if (this.check([
+			171,
+			75,
+			84,
+			88,
+			32,
+			49,
+			49,
+			187,
+			13,
+			10,
+			26,
+			10
+		])) return {
+			ext: "ktx",
+			mime: "image/ktx"
+		};
+		if ((this.check([
+			126,
+			16,
+			4
+		]) || this.check([
+			126,
+			24,
+			4
+		])) && this.check([
+			48,
+			77,
+			73,
+			69
+		], { offset: 4 })) return {
+			ext: "mie",
+			mime: "application/x-mie"
+		};
+		if (this.check([
+			39,
+			10,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0
+		], { offset: 2 })) return {
+			ext: "shp",
+			mime: "application/x-esri-shape"
+		};
+		if (this.check([
+			255,
+			79,
+			255,
+			81
+		])) return {
+			ext: "j2c",
+			mime: "image/j2c"
+		};
+		if (this.check([
+			0,
+			0,
+			0,
+			12,
+			106,
+			80,
+			32,
+			32,
+			13,
+			10,
+			135,
+			10
+		])) switch (await e.ignore(20), await e.readToken(new S(4, "ascii"))) {
+			case "jp2 ": return {
+				ext: "jp2",
+				mime: "image/jp2"
+			};
+			case "jpx ": return {
+				ext: "jpx",
+				mime: "image/jpx"
+			};
+			case "jpm ": return {
+				ext: "jpm",
+				mime: "image/jpm"
+			};
+			case "mjp2": return {
+				ext: "mj2",
+				mime: "image/mj2"
+			};
+			default: return;
+		}
+		if (this.check([255, 10]) || this.check([
+			0,
+			0,
+			0,
+			12,
+			74,
+			88,
+			76,
+			32,
+			13,
+			10,
+			135,
+			10
+		])) return {
+			ext: "jxl",
+			mime: "image/jxl"
+		};
+		if (this.check([254, 255])) return this.checkString("<?xml ", {
+			offset: 2,
+			encoding: "utf-16be"
+		}) ? {
+			ext: "xml",
+			mime: "application/xml"
+		} : void 0;
+		if (this.check([
+			208,
+			207,
+			17,
+			224,
+			161,
+			177,
+			26,
+			225
+		])) return {
+			ext: "cfb",
+			mime: "application/x-cfb"
+		};
+		if (await e.peekBuffer(this.buffer, {
+			length: Math.min(256, e.fileInfo.size),
+			mayBeLess: !0
+		}), this.check([
+			97,
+			99,
+			115,
+			112
+		], { offset: 36 })) return {
+			ext: "icc",
+			mime: "application/vnd.iccprofile"
+		};
+		if (this.checkString("**ACE", { offset: 7 }) && this.checkString("**", { offset: 12 })) return {
+			ext: "ace",
+			mime: "application/x-ace-compressed"
+		};
+		if (this.checkString("BEGIN:")) {
+			if (this.checkString("VCARD", { offset: 6 })) return {
+				ext: "vcf",
+				mime: "text/vcard"
+			};
+			if (this.checkString("VCALENDAR", { offset: 6 })) return {
+				ext: "ics",
+				mime: "text/calendar"
+			};
+		}
+		if (this.checkString("FUJIFILMCCD-RAW")) return {
+			ext: "raf",
+			mime: "image/x-fujifilm-raf"
+		};
+		if (this.checkString("Extended Module:")) return {
+			ext: "xm",
+			mime: "audio/x-xm"
+		};
+		if (this.checkString("Creative Voice File")) return {
+			ext: "voc",
+			mime: "audio/x-voc"
+		};
+		if (this.check([
+			4,
+			0,
+			0,
+			0
+		]) && this.buffer.length >= 16) {
+			let t = new DataView(this.buffer.buffer).getUint32(12, !0);
+			if (t > 12 && this.buffer.length >= t + 16) try {
+				let r = new TextDecoder().decode(this.buffer.subarray(16, t + 16));
+				if (JSON.parse(r).files) return {
+					ext: "asar",
+					mime: "application/x-asar"
+				};
+			} catch {}
+		}
+		if (this.check([
+			6,
+			14,
+			43,
+			52,
+			2,
+			5,
+			1,
+			1,
+			13,
+			1,
+			2,
+			1,
+			1,
+			2
+		])) return {
+			ext: "mxf",
+			mime: "application/mxf"
+		};
+		if (this.checkString("SCRM", { offset: 44 })) return {
+			ext: "s3m",
+			mime: "audio/x-s3m"
+		};
+		if (this.check([71]) && this.check([71], { offset: 188 })) return {
+			ext: "mts",
+			mime: "video/mp2t"
+		};
+		if (this.check([71], { offset: 4 }) && this.check([71], { offset: 196 })) return {
+			ext: "mts",
+			mime: "video/mp2t"
+		};
+		if (this.check([
+			66,
+			79,
+			79,
+			75,
+			77,
+			79,
+			66,
+			73
+		], { offset: 60 })) return {
+			ext: "mobi",
+			mime: "application/x-mobipocket-ebook"
+		};
+		if (this.check([
+			68,
+			73,
+			67,
+			77
+		], { offset: 128 })) return {
+			ext: "dcm",
+			mime: "application/dicom"
+		};
+		if (this.check([
+			76,
+			0,
+			0,
+			0,
+			1,
+			20,
+			2,
+			0,
+			0,
+			0,
+			0,
+			0,
+			192,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			70
+		])) return {
+			ext: "lnk",
+			mime: "application/x.ms.shortcut"
+		};
+		if (this.check([
+			98,
+			111,
+			111,
+			107,
+			0,
+			0,
+			0,
+			0,
+			109,
+			97,
+			114,
+			107,
+			0,
+			0,
+			0,
+			0
+		])) return {
+			ext: "alias",
+			mime: "application/x.apple.alias"
+		};
+		if (this.checkString("Kaydara FBX Binary  \0")) return {
+			ext: "fbx",
+			mime: "application/x.autodesk.fbx"
+		};
+		if (this.check([76, 80], { offset: 34 }) && (this.check([
+			0,
+			0,
+			1
+		], { offset: 8 }) || this.check([
+			1,
+			0,
+			2
+		], { offset: 8 }) || this.check([
+			2,
+			0,
+			2
+		], { offset: 8 }))) return {
+			ext: "eot",
+			mime: "application/vnd.ms-fontobject"
+		};
+		if (this.check([
+			6,
+			6,
+			237,
+			245,
+			216,
+			29,
+			70,
+			229,
+			189,
+			49,
+			239,
+			231,
+			254,
+			116,
+			183,
+			29
+		])) return {
+			ext: "indd",
+			mime: "application/x-indesign"
+		};
+		if (this.check([
+			255,
+			255,
+			0,
+			0,
+			7,
+			0,
+			0,
+			0,
+			4,
+			0,
+			0,
+			0,
+			1,
+			0,
+			1,
+			0
+		]) || this.check([
+			0,
+			0,
+			255,
+			255,
+			0,
+			0,
+			0,
+			7,
+			0,
+			0,
+			0,
+			4,
+			0,
+			1,
+			0,
+			1
+		])) return {
+			ext: "jmp",
+			mime: "application/x-jmp-data"
+		};
+		if (await e.peekBuffer(this.buffer, {
+			length: Math.min(512, e.fileInfo.size),
+			mayBeLess: !0
+		}), this.checkString("ustar", { offset: 257 }) && (this.checkString("\0", { offset: 262 }) || this.checkString(" ", { offset: 262 })) || this.check([
+			0,
+			0,
+			0,
+			0,
+			0,
+			0
+		], { offset: 257 }) && ut(this.buffer)) return {
+			ext: "tar",
+			mime: "application/x-tar"
+		};
+		if (this.check([255, 254])) {
+			let t = "utf-16le";
+			return this.checkString("<?xml ", {
+				offset: 2,
+				encoding: t
+			}) ? {
+				ext: "xml",
+				mime: "application/xml"
+			} : this.check([255, 14], { offset: 2 }) && this.checkString("SketchUp Model", {
+				offset: 4,
+				encoding: t
+			}) ? {
+				ext: "skp",
+				mime: "application/vnd.sketchup.skp"
+			} : this.checkString(`Windows Registry Editor Version 5.00\r
+`, {
+				offset: 2,
+				encoding: t
+			}) ? {
+				ext: "reg",
+				mime: "application/x-ms-regedit"
+			} : void 0;
+		}
+		if (this.checkString("-----BEGIN PGP MESSAGE-----")) return {
+			ext: "pgp",
+			mime: "application/pgp-encrypted"
+		};
+	};
+	detectImprecise = async (e) => {
+		this.buffer = new Uint8Array(K);
+		let t = Gi(e.fileInfo.size);
+		if (await e.peekBuffer(this.buffer, {
+			length: Math.min(8, t),
+			mayBeLess: !0
+		}), this.check([
+			0,
+			0,
+			1,
+			186
+		]) || this.check([
+			0,
+			0,
+			1,
+			179
+		])) return {
+			ext: "mpg",
+			mime: "video/mpeg"
+		};
+		if (this.check([
+			0,
+			1,
+			0,
+			0,
+			0
+		])) return {
+			ext: "ttf",
+			mime: "font/ttf"
+		};
+		if (this.check([
+			0,
+			0,
+			1,
+			0
+		])) return {
+			ext: "ico",
+			mime: "image/x-icon"
+		};
+		if (this.check([
+			0,
+			0,
+			2,
+			0
+		])) return {
+			ext: "cur",
+			mime: "image/x-icon"
+		};
+		if (await e.peekBuffer(this.buffer, {
+			length: Math.min(2 + this.options.mpegOffsetTolerance, t),
+			mayBeLess: !0
+		}), this.buffer.length >= 2 + this.options.mpegOffsetTolerance) for (let r = 0; r <= this.options.mpegOffsetTolerance; ++r) {
+			let n = this.scanMpeg(r);
+			if (n) return n;
+		}
+	};
+	async readTiffTag(e) {
+		let t = await this.tokenizer.readToken(e ? _ : h);
+		switch (await this.tokenizer.ignore(10), t) {
+			case 50341: return {
+				ext: "arw",
+				mime: "image/x-sony-arw"
+			};
+			case 50706: return {
+				ext: "dng",
+				mime: "image/x-adobe-dng"
+			};
+			default:
+		}
+	}
+	async readTiffIFD(e) {
+		let t = await this.tokenizer.readToken(e ? _ : h);
+		if (!(t > Ti) && !(b(this.tokenizer) && 2 + t * 12 > Ft)) for (let r = 0; r < t; ++r) {
+			let n = await this.readTiffTag(e);
+			if (n) return n;
+		}
+	}
+	async readTiffHeader(e) {
+		let t = {
+			ext: "tif",
+			mime: "image/tiff"
+		}, r = (e ? _ : h).get(this.buffer, 2), n = (e ? be : x).get(this.buffer, 4);
+		if (r === 42) {
+			if (n >= 6) {
+				if (this.checkString("CR", { offset: 8 })) return {
+					ext: "cr2",
+					mime: "image/x-canon-cr2"
+				};
+				if (n >= 8) {
+					let a = (e ? _ : h).get(this.buffer, 8), m = (e ? _ : h).get(this.buffer, 10);
+					if (a === 28 && m === 254 || a === 31 && m === 11) return {
+						ext: "nef",
+						mime: "image/x-nikon-nef"
+					};
+				}
+			}
+			if (b(this.tokenizer) && n > vi) return t;
+			let o = b(this.tokenizer) ? Ft : this.tokenizer.fileInfo.size;
+			try {
+				await R(this.tokenizer, n, {
+					maximumLength: o,
+					reason: "TIFF IFD offset"
+				});
+			} catch (a) {
+				if (a instanceof l) return;
+				throw a;
+			}
+			let s;
+			try {
+				s = await this.readTiffIFD(e);
+			} catch (a) {
+				if (a instanceof l) return;
+				throw a;
+			}
+			return s ?? t;
+		}
+		if (r === 43) return t;
+	}
+	scanMpeg(e) {
+		if (this.check([255, 224], {
+			offset: e,
+			mask: [255, 224]
+		})) {
+			if (this.check([16], {
+				offset: e + 1,
+				mask: [22]
+			})) return this.check([8], {
+				offset: e + 1,
+				mask: [8]
+			}) ? {
+				ext: "aac",
+				mime: "audio/aac"
+			} : {
+				ext: "aac",
+				mime: "audio/aac"
+			};
+			if (this.check([2], {
+				offset: e + 1,
+				mask: [6]
+			})) return {
+				ext: "mp3",
+				mime: "audio/mpeg"
+			};
+			if (this.check([4], {
+				offset: e + 1,
+				mask: [6]
+			})) return {
+				ext: "mp2",
+				mime: "audio/mpeg"
+			};
+			if (this.check([6], {
+				offset: e + 1,
+				mask: [6]
+			})) return {
+				ext: "mp1",
+				mime: "audio/mpeg"
+			};
+		}
+	}
+};
+new Set(dt);
+new Set(xt);
+var Yi = {
+	name: "file",
+	summary: "determine file type",
+	usage: "file [OPTION]... FILE...",
+	options: [
+		"-b, --brief          do not prepend filenames to output",
+		"-i, --mime           output MIME type strings",
+		"-L, --dereference    follow symlinks",
+		"    --help           display this help and exit"
+	]
+}, Ki = new Map([
+	[".js", {
+		description: "JavaScript source",
+		mime: "text/javascript"
+	}],
+	[".mjs", {
+		description: "JavaScript module",
+		mime: "text/javascript"
+	}],
+	[".cjs", {
+		description: "CommonJS module",
+		mime: "text/javascript"
+	}],
+	[".ts", {
+		description: "TypeScript source",
+		mime: "text/typescript"
+	}],
+	[".tsx", {
+		description: "TypeScript JSX source",
+		mime: "text/typescript"
+	}],
+	[".jsx", {
+		description: "JavaScript JSX source",
+		mime: "text/javascript"
+	}],
+	[".py", {
+		description: "Python script",
+		mime: "text/x-python"
+	}],
+	[".rb", {
+		description: "Ruby script",
+		mime: "text/x-ruby"
+	}],
+	[".go", {
+		description: "Go source",
+		mime: "text/x-go"
+	}],
+	[".rs", {
+		description: "Rust source",
+		mime: "text/x-rust"
+	}],
+	[".c", {
+		description: "C source",
+		mime: "text/x-c"
+	}],
+	[".h", {
+		description: "C header",
+		mime: "text/x-c"
+	}],
+	[".cpp", {
+		description: "C++ source",
+		mime: "text/x-c++"
+	}],
+	[".hpp", {
+		description: "C++ header",
+		mime: "text/x-c++"
+	}],
+	[".java", {
+		description: "Java source",
+		mime: "text/x-java"
+	}],
+	[".sh", {
+		description: "Bourne-Again shell script",
+		mime: "text/x-shellscript"
+	}],
+	[".bash", {
+		description: "Bourne-Again shell script",
+		mime: "text/x-shellscript"
+	}],
+	[".zsh", {
+		description: "Zsh shell script",
+		mime: "text/x-shellscript"
+	}],
+	[".json", {
+		description: "JSON data",
+		mime: "application/json"
+	}],
+	[".yaml", {
+		description: "YAML data",
+		mime: "text/yaml"
+	}],
+	[".yml", {
+		description: "YAML data",
+		mime: "text/yaml"
+	}],
+	[".xml", {
+		description: "XML document",
+		mime: "application/xml"
+	}],
+	[".csv", {
+		description: "CSV text",
+		mime: "text/csv"
+	}],
+	[".toml", {
+		description: "TOML data",
+		mime: "text/toml"
+	}],
+	[".html", {
+		description: "HTML document",
+		mime: "text/html"
+	}],
+	[".htm", {
+		description: "HTML document",
+		mime: "text/html"
+	}],
+	[".css", {
+		description: "CSS stylesheet",
+		mime: "text/css"
+	}],
+	[".svg", {
+		description: "SVG image",
+		mime: "image/svg+xml"
+	}],
+	[".md", {
+		description: "Markdown document",
+		mime: "text/markdown"
+	}],
+	[".markdown", {
+		description: "Markdown document",
+		mime: "text/markdown"
+	}],
+	[".txt", {
+		description: "ASCII text",
+		mime: "text/plain"
+	}],
+	[".rst", {
+		description: "reStructuredText",
+		mime: "text/x-rst"
+	}],
+	[".env", {
+		description: "ASCII text",
+		mime: "text/plain"
+	}],
+	[".gitignore", {
+		description: "ASCII text",
+		mime: "text/plain"
+	}],
+	[".dockerignore", {
+		description: "ASCII text",
+		mime: "text/plain"
+	}]
+]), er = new Map([
+	["jpg", "JPEG image data"],
+	["jpeg", "JPEG image data"],
+	["png", "PNG image data"],
+	["gif", "GIF image data"],
+	["webp", "WebP image data"],
+	["bmp", "PC bitmap"],
+	["ico", "MS Windows icon resource"],
+	["tif", "TIFF image data"],
+	["tiff", "TIFF image data"],
+	["psd", "Adobe Photoshop Document"],
+	["avif", "AVIF image"],
+	["heic", "HEIC image"],
+	["heif", "HEIF image"],
+	["jxl", "JPEG XL image"],
+	["icns", "Mac OS X icon"],
+	["svg", "SVG Scalable Vector Graphics image"],
+	["pdf", "PDF document"],
+	["epub", "EPUB document"],
+	["mobi", "Mobipocket E-book"],
+	["djvu", "DjVu document"],
+	["zip", "Zip archive data"],
+	["gz", "gzip compressed data"],
+	["gzip", "gzip compressed data"],
+	["bz2", "bzip2 compressed data"],
+	["xz", "XZ compressed data"],
+	["tar", "POSIX tar archive"],
+	["rar", "RAR archive data"],
+	["7z", "7-zip archive data"],
+	["lz", "lzip compressed data"],
+	["lzma", "LZMA compressed data"],
+	["zst", "Zstandard compressed data"],
+	["cab", "Microsoft Cabinet archive"],
+	["ar", "Unix ar archive"],
+	["rpm", "RPM package"],
+	["deb", "Debian binary package"],
+	["apk", "Android Package"],
+	["dmg", "Apple disk image"],
+	["iso", "ISO 9660 CD-ROM filesystem data"],
+	["vhd", "Microsoft Virtual Hard Disk"],
+	["vhdx", "Microsoft Virtual Hard Disk (new format)"],
+	["qcow2", "QEMU QCOW Image"],
+	["mp3", "Audio file with ID3"],
+	["m4a", "MPEG-4 audio"],
+	["aac", "AAC audio"],
+	["wav", "RIFF (little-endian) data, WAVE audio"],
+	["flac", "FLAC audio bitstream data"],
+	["ogg", "Ogg data"],
+	["oga", "Ogg audio"],
+	["opus", "Ogg Opus audio"],
+	["aiff", "AIFF audio"],
+	["wma", "Windows Media Audio"],
+	["amr", "AMR audio"],
+	["mid", "MIDI audio"],
+	["midi", "MIDI audio"],
+	["ape", "Monkey's Audio"],
+	["mp4", "ISO Media, MPEG-4"],
+	["m4v", "MPEG-4 video"],
+	["webm", "WebM"],
+	["avi", "RIFF (little-endian) data, AVI"],
+	["mov", "ISO Media, Apple QuickTime movie"],
+	["mkv", "Matroska data"],
+	["wmv", "Windows Media Video"],
+	["flv", "Flash Video"],
+	["3gp", "3GPP multimedia"],
+	["3g2", "3GPP2 multimedia"],
+	["ogv", "Ogg video"],
+	["mts", "MPEG transport stream"],
+	["m2ts", "MPEG transport stream"],
+	["ts", "MPEG transport stream"],
+	["mpg", "MPEG video"],
+	["mpeg", "MPEG video"],
+	["exe", "PE32 executable"],
+	["dll", "PE32 DLL"],
+	["elf", "ELF executable"],
+	["mach", "Mach-O executable"],
+	["wasm", "WebAssembly (wasm) binary module"],
+	["dex", "Android Dalvik executable"],
+	["class", "Java class file"],
+	["swf", "Adobe Flash"],
+	["doc", "Microsoft Word Document"],
+	["docx", "Microsoft Word 2007+ Document"],
+	["xls", "Microsoft Excel Spreadsheet"],
+	["xlsx", "Microsoft Excel 2007+ Spreadsheet"],
+	["ppt", "Microsoft PowerPoint Presentation"],
+	["pptx", "Microsoft PowerPoint 2007+ Presentation"],
+	["odt", "OpenDocument Text"],
+	["ods", "OpenDocument Spreadsheet"],
+	["odp", "OpenDocument Presentation"],
+	["ttf", "TrueType Font"],
+	["otf", "OpenType Font"],
+	["woff", "Web Open Font Format"],
+	["woff2", "Web Open Font Format 2"],
+	["eot", "Embedded OpenType font"],
+	["stl", "Stereolithography CAD"],
+	["obj", "Wavefront 3D Object"],
+	["gltf", "GL Transmission Format"],
+	["glb", "GL Transmission Format (binary)"],
+	["sqlite", "SQLite 3.x database"],
+	["mdb", "Microsoft Access Database"],
+	["xml", "XML document"],
+	["json", "JSON data"],
+	["macho", "Mach-O binary"],
+	["ics", "iCalendar data"],
+	["vcf", "vCard data"],
+	["msi", "Microsoft Installer"],
+	["ps", "PostScript"],
+	["ai", "Adobe Illustrator"],
+	["indd", "Adobe InDesign"],
+	["sketch", "Sketch design file"],
+	["fig", "Figma design file"],
+	["xd", "Adobe XD"],
+	["blend", "Blender"],
+	["fbx", "Autodesk FBX"],
+	["lnk", "MS Windows shortcut"],
+	["alias", "Mac OS alias"],
+	["torrent", "BitTorrent file"],
+	["pcap", "pcap capture file"],
+	["arrow", "Apache Arrow"],
+	["parquet", "Apache Parquet"]
+]);
+function tr(i, e) {
+	let t = er.get(i);
+	if (t) return t;
+	let [r, n] = e.split("/"), o = n?.split("+")[0]?.replace(/-/g, " ") || i;
+	switch (r) {
+		case "image": return `${o.toUpperCase()} image data`;
+		case "audio": return `${o.toUpperCase()} audio`;
+		case "video": return `${o.toUpperCase()} video`;
+		case "font": return `${o} font`;
+		case "model": return `${o} 3D model`;
+		case "application": return n?.includes("zip") || n?.includes("compressed") ? `${o} archive data` : n?.includes("executable") ? `${o} executable` : `${i.toUpperCase()} data`;
+		default: return `${i.toUpperCase()} data`;
+	}
+}
+function ir(i) {
+	let e = i.split("/").pop() || i;
+	if (e.startsWith(".") && !e.includes(".", 1)) return e;
+	let t = e.lastIndexOf(".");
+	return t === -1 || t === 0 ? "" : e.slice(t).toLowerCase();
+}
+function rr(i, e) {
+	if (i.startsWith("#!")) {
+		let f = i.split(`
+`)[0];
+		return f.includes("python") ? {
+			description: "Python script, ASCII text executable",
+			mime: "text/x-python"
+		} : f.includes("node") || f.includes("bun") || f.includes("deno") ? {
+			description: "JavaScript script, ASCII text executable",
+			mime: "text/javascript"
+		} : f.includes("bash") ? {
+			description: "Bourne-Again shell script, ASCII text executable",
+			mime: "text/x-shellscript"
+		} : f.includes("sh") ? {
+			description: "POSIX shell script, ASCII text executable",
+			mime: "text/x-shellscript"
+		} : f.includes("ruby") ? {
+			description: "Ruby script, ASCII text executable",
+			mime: "text/x-ruby"
+		} : f.includes("perl") ? {
+			description: "Perl script, ASCII text executable",
+			mime: "text/x-perl"
+		} : {
+			description: "script, ASCII text executable",
+			mime: "text/plain"
+		};
+	}
+	let t = i.trimStart();
+	if (t.startsWith("<?xml")) return {
+		description: "XML document",
+		mime: "application/xml"
+	};
+	if (t.startsWith("<!DOCTYPE html") || t.toLowerCase().startsWith("<html")) return {
+		description: "HTML document",
+		mime: "text/html"
+	};
+	let r = i.includes(`\r
+`), n = i.includes("\r") && !r, o = "";
+	r ? o = ", with CRLF line terminators" : n && (o = ", with CR line terminators");
+	let s = ir(e), a = s ? Ki.get(s) : void 0;
+	if (a) return a.mime.startsWith("text/") && o ? {
+		description: `${a.description}${o}`,
+		mime: a.mime
+	} : a;
+	let m = !1;
+	for (let f = 0; f < Math.min(i.length, 8192); f++) if (i.charCodeAt(f) > 127) {
+		m = !0;
+		break;
+	}
+	return m ? {
+		description: `UTF-8 Unicode text${o}`,
+		mime: "text/plain; charset=utf-8"
+	} : {
+		description: `ASCII text${o}`,
+		mime: "text/plain"
+	};
+}
+async function nr(i, e) {
+	if (e.length === 0) return {
+		description: "empty",
+		mime: "inode/x-empty"
+	};
+	let t = await ze(e);
+	if (t) return {
+		description: tr(t.ext, t.mime),
+		mime: t.mime
+	};
+	return rr(new TextDecoder("utf-8", { fatal: !1 }).decode(e), i);
+}
+var _n = {
+	name: "file",
+	async execute(i, e) {
+		if (require_chunk_QAYAQNCG.o(i)) return require_chunk_QAYAQNCG.s(Yi);
+		let t = !1, r$1 = !1, n = [];
+		for (let a of i) if (a.startsWith("--")) {
+			if (a === "--brief") t = !0;
+			else if (a === "--mime" || a === "--mime-type") r$1 = !0;
+			else if (a !== "--dereference") return require_chunk_QAYAQNCG.r("file", a);
+		} else if (a.startsWith("-") && a !== "-") {
+			for (let m of a.slice(1)) if (m === "b") t = !0;
+			else if (m === "i") r$1 = !0;
+			else if (m !== "L") return require_chunk_QAYAQNCG.r("file", `-${m}`);
+		} else n.push(a);
+		if (n.length === 0) return {
+			stdout: "",
+			stderr: `Usage: file [-bLi] FILE...
+`,
+			exitCode: 1
+		};
+		let o = "", s$1 = 0;
+		for (let a of n) try {
+			let m = e.fs.resolvePath(e.cwd, a);
+			if ((await e.fs.stat(m)).isDirectory) {
+				let d = r$1 ? "inode/directory" : "directory";
+				o += t ? `${d}
+` : `${a}: ${d}
+`;
+				continue;
+			}
+			let p = await nr(a, await e.fs.readFileBuffer(m)), u = r$1 ? p.mime : p.description;
+			o += t ? `${u}
+` : `${a}: ${u}
+`;
+		} catch {
+			o += t ? `cannot open
+` : `${a}: cannot open (No such file or directory)
+`, s$1 = 1;
+		}
+		return {
+			stdout: o,
+			stderr: "",
+			exitCode: s$1
+		};
+	}
+}, $n = {
+	name: "file",
+	flags: [
+		{
+			flag: "-b",
+			type: "boolean"
+		},
+		{
+			flag: "-i",
+			type: "boolean"
+		},
+		{
+			flag: "-L",
+			type: "boolean"
+		}
+	],
+	needsArgs: !0
+};
+/*! Bundled license information:
+
+ieee754/index.js:
+(*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> *)
+*/
+//#endregion
+Object.defineProperty(exports, "$n", {
+	enumerable: true,
+	get: function() {
+		return $n;
+	}
+});
+Object.defineProperty(exports, "_n", {
+	enumerable: true,
+	get: function() {
+		return _n;
+	}
+});
+
+//# sourceMappingURL=chunk-WVRWIZF5-B5z8SbAq.cjs.map