@jackuait/blok 0.17.0 → 0.19.0

package/dist/chunks/core-DdDpt2u7.mjs

@@ -0,0 +1,3931 @@
+import { i as e, t } from "./chunk-5O_1xk2F.mjs";
+import { n, t as r } from "./objectSpread2-jlBcdYeb.mjs";
+import { A as i, C as a, D as o, E as s, a as c, b as l, c as u, i as d, n as f, p as ee, v as p, w as m, y as h } from "./BasicParser-BFTgNkp-.mjs";
+import { i as g, n as te, r as ne, t as re } from "./core-CqiEzfU3.mjs";
+import { d as _, l as ie, n as ae } from "./Util-DiBcLCh8.mjs";
+import { c as oe, i as se } from "./ID3v2Token-D5v9lCfb.mjs";
+import { t as ce } from "./APEv2Parser-WvRvu4zL.mjs";
+import { r as le } from "./ID3v1Parser-DoxlznrE.mjs";
+import { n as ue, r as de } from "./types-gj36fzRQ.mjs";
+//#region node_modules/@tokenizer/inflate/lib/ZipToken.js
+var v = /* @__PURE__ */ e(u(), 1), y = {
+	LocalFileHeader: 67324752,
+	DataDescriptor: 134695760,
+	CentralFileHeader: 33639248,
+	EndOfCentralDirectory: 101010256
+}, fe = {
+	get(e) {
+		return {
+			signature: m.get(e, 0),
+			compressedSize: m.get(e, 8),
+			uncompressedSize: m.get(e, 12)
+		};
+	},
+	len: 16
+}, pe = {
+	get(e) {
+		let t = l.get(e, 6);
+		return {
+			signature: m.get(e, 0),
+			minVersion: l.get(e, 4),
+			dataDescriptor: !!(t & 8),
+			compressedMethod: l.get(e, 8),
+			compressedSize: m.get(e, 18),
+			uncompressedSize: m.get(e, 22),
+			filenameLength: l.get(e, 26),
+			extraFieldLength: l.get(e, 28),
+			filename: null
+		};
+	},
+	len: 30
+}, me = {
+	get(e) {
+		return {
+			signature: m.get(e, 0),
+			nrOfThisDisk: l.get(e, 4),
+			nrOfThisDiskWithTheStart: l.get(e, 6),
+			nrOfEntriesOnThisDisk: l.get(e, 8),
+			nrOfEntriesOfSize: l.get(e, 10),
+			sizeOfCd: m.get(e, 12),
+			offsetOfStartOfCd: m.get(e, 16),
+			zipFileCommentLength: l.get(e, 20)
+		};
+	},
+	len: 22
+}, he = {
+	get(e) {
+		let t = l.get(e, 8);
+		return {
+			signature: m.get(e, 0),
+			minVersion: l.get(e, 6),
+			dataDescriptor: !!(t & 8),
+			compressedMethod: l.get(e, 10),
+			compressedSize: m.get(e, 20),
+			uncompressedSize: m.get(e, 24),
+			filenameLength: l.get(e, 28),
+			extraFieldLength: l.get(e, 30),
+			fileCommentLength: l.get(e, 32),
+			relativeOffsetOfLocalHeader: m.get(e, 42),
+			filename: null
+		};
+	},
+	len: 46
+};
+//#endregion
+//#region node_modules/@tokenizer/inflate/lib/ZipHandler.js
+function b(e) {
+	let t = new Uint8Array(m.len);
+	return m.put(t, 0, e), t;
+}
+var x = (0, v.default)("tokenizer:inflate"), S = 256 * 1024, ge = b(y.DataDescriptor), C = b(y.EndOfCentralDirectory), w = class e {
+	constructor(e) {
+		this.tokenizer = e, this.syncBuffer = new Uint8Array(S);
+	}
+	async isZip() {
+		return await this.peekSignature() === y.LocalFileHeader;
+	}
+	peekSignature() {
+		return this.tokenizer.peekToken(m);
+	}
+	async findEndOfCentralDirectoryLocator() {
+		var e = this;
+		let t = e.tokenizer, n = Math.min(16 * 1024, t.fileInfo.size), r = e.syncBuffer.subarray(0, n);
+		await e.tokenizer.readBuffer(r, { position: t.fileInfo.size - n });
+		for (let e = r.length - 4; e >= 0; e--) if (r[e] === C[0] && r[e + 1] === C[1] && r[e + 2] === C[2] && r[e + 3] === C[3]) return t.fileInfo.size - n + e;
+		return -1;
+	}
+	async readCentralDirectory() {
+		var e = this;
+		if (!e.tokenizer.supportsRandomAccess()) {
+			x("Cannot reading central-directory without random-read support");
+			return;
+		}
+		x("Reading central-directory...");
+		let t = e.tokenizer.position, n = await e.findEndOfCentralDirectoryLocator();
+		if (n > 0) {
+			x("Central-directory 32-bit signature found");
+			let r = await e.tokenizer.readToken(me, n), i = [];
+			e.tokenizer.setPosition(r.offsetOfStartOfCd);
+			for (let t = 0; t < r.nrOfEntriesOfSize; ++t) {
+				let n = await e.tokenizer.readToken(he);
+				if (n.signature !== y.CentralFileHeader) throw Error("Expected Central-File-Header signature");
+				n.filename = await e.tokenizer.readToken(new p(n.filenameLength, "utf-8")), await e.tokenizer.ignore(n.extraFieldLength), await e.tokenizer.ignore(n.fileCommentLength), i.push(n), x(`Add central-directory file-entry: n=${t + 1}/${i.length}: filename=${i[t].filename}`);
+			}
+			return e.tokenizer.setPosition(t), i;
+		}
+		e.tokenizer.setPosition(t);
+	}
+	async unzip(e) {
+		var t = this;
+		let n = await t.readCentralDirectory();
+		if (n) return t.iterateOverCentralDirectory(n, e);
+		let r = !1;
+		do {
+			let n = await t.readLocalFileHeader();
+			if (!n) break;
+			let i = e(n);
+			r = !!i.stop;
+			let a;
+			if (await t.tokenizer.ignore(n.extraFieldLength), n.dataDescriptor && n.compressedSize === 0) {
+				let e = [], r = S;
+				x("Compressed-file-size unknown, scanning for next data-descriptor-signature....");
+				let a = -1;
+				for (; a < 0 && r === S;) {
+					r = await t.tokenizer.peekBuffer(t.syncBuffer, { mayBeLess: !0 }), a = _e(t.syncBuffer.subarray(0, r), ge);
+					let n = a >= 0 ? a : r;
+					if (i.handler) {
+						let r = new Uint8Array(n);
+						await t.tokenizer.readBuffer(r), e.push(r);
+					} else await t.tokenizer.ignore(n);
+				}
+				x(`Found data-descriptor-signature at pos=${t.tokenizer.position}`), i.handler && await t.inflate(n, ve(e), i.handler);
+			} else i.handler ? (x(`Reading compressed-file-data: ${n.compressedSize} bytes`), a = new Uint8Array(n.compressedSize), await t.tokenizer.readBuffer(a), await t.inflate(n, a, i.handler)) : (x(`Ignoring compressed-file-data: ${n.compressedSize} bytes`), await t.tokenizer.ignore(n.compressedSize));
+			if (x(`Reading data-descriptor at pos=${t.tokenizer.position}`), n.dataDescriptor && (await t.tokenizer.readToken(fe)).signature !== 134695760) throw Error(`Expected data-descriptor-signature at position ${t.tokenizer.position - fe.len}`);
+		} while (!r);
+	}
+	async iterateOverCentralDirectory(e, t) {
+		var n = this;
+		for (let r of e) {
+			let e = t(r);
+			if (e.handler) {
+				n.tokenizer.setPosition(r.relativeOffsetOfLocalHeader);
+				let t = await n.readLocalFileHeader();
+				if (t) {
+					await n.tokenizer.ignore(t.extraFieldLength);
+					let i = new Uint8Array(r.compressedSize);
+					await n.tokenizer.readBuffer(i), await n.inflate(t, i, e.handler);
+				}
+			}
+			if (e.stop) break;
+		}
+	}
+	async inflate(t, n, r) {
+		if (t.compressedMethod === 0) return r(n);
+		if (t.compressedMethod !== 8) throw Error(`Unsupported ZIP compression method: ${t.compressedMethod}`);
+		return x(`Decompress filename=${t.filename}, compressed-size=${n.length}`), r(await e.decompressDeflateRaw(n));
+	}
+	static async decompressDeflateRaw(e) {
+		let t = new ReadableStream({ start(t) {
+			t.enqueue(e), t.close();
+		} }), n = new DecompressionStream("deflate-raw"), r = t.pipeThrough(n);
+		try {
+			let e = await new Response(r).arrayBuffer();
+			return new Uint8Array(e);
+		} catch (e) {
+			let t = e instanceof Error ? `Failed to deflate ZIP entry: ${e.message}` : "Unknown decompression error in ZIP entry";
+			throw TypeError(t);
+		}
+	}
+	async readLocalFileHeader() {
+		var e = this;
+		let t = await e.tokenizer.peekToken(m);
+		if (t === y.LocalFileHeader) {
+			let t = await e.tokenizer.readToken(pe);
+			return t.filename = await e.tokenizer.readToken(new p(t.filenameLength, "utf-8")), t;
+		}
+		if (t === y.CentralFileHeader) return !1;
+		throw Error(t === 3759263696 ? "Encrypted ZIP" : "Unexpected signature");
+	}
+};
+function _e(e, t) {
+	let n = e.length, r = t.length;
+	if (r > n) return -1;
+	for (let i = 0; i <= n - r; i++) {
+		let n = !0;
+		for (let a = 0; a < r; a++) if (e[i + a] !== t[a]) {
+			n = !1;
+			break;
+		}
+		if (n) return i;
+	}
+	return -1;
+}
+function ve(e) {
+	let t = e.reduce((e, t) => e + t.length, 0), n = new Uint8Array(t), r = 0;
+	for (let t of e) n.set(t, r), r += t.length;
+	return n;
+}
+//#endregion
+//#region node_modules/@tokenizer/inflate/lib/GzipHandler.js
+var ye = class {
+	constructor(e) {
+		this.tokenizer = e;
+	}
+	inflate() {
+		let e = this.tokenizer;
+		return new ReadableStream({ async pull(t) {
+			let n = new Uint8Array(1024), r = await e.readBuffer(n, { mayBeLess: !0 });
+			if (r === 0) {
+				t.close();
+				return;
+			}
+			t.enqueue(n.subarray(0, r));
+		} }).pipeThrough(new DecompressionStream("gzip"));
+	}
+};
+//#endregion
+//#region node_modules/file-type/util.js
+function be(e, t) {
+	if (t === "utf-16le") {
+		let t = [];
+		for (let n = 0; n < e.length; n++) {
+			let r = e.charCodeAt(n);
+			t.push(r & 255, r >> 8 & 255);
+		}
+		return t;
+	}
+	if (t === "utf-16be") {
+		let t = [];
+		for (let n = 0; n < e.length; n++) {
+			let r = e.charCodeAt(n);
+			t.push(r >> 8 & 255, r & 255);
+		}
+		return t;
+	}
+	return [...e].map((e) => e.charCodeAt(0));
+}
+function xe(e, t = 0) {
+	let n = Number.parseInt(new p(6).get(e, 148).replace(/\0.*$/, "").trim(), 8);
+	if (Number.isNaN(n)) return !1;
+	let r = 256;
+	for (let n = t; n < t + 148; n++) r += e[n];
+	for (let n = t + 156; n < t + 512; n++) r += e[n];
+	return n === r;
+}
+var Se = {
+	get: (e, t) => e[t + 3] & 127 | e[t + 2] << 7 | e[t + 1] << 14 | e[t] << 21,
+	len: 4
+}, Ce = /* @__PURE__ */ "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".split(","), we = /* @__PURE__ */ "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".split(","), T = 4100, Te = T - 2, E = 1024 * 1024, Ee = 1024, De = 2 ** 31 - 1, D = 16 * 1024 * 1024, O = E, Oe = E, ke = D, Ae = 1, je = 100, k = D, A = 64, j = O, Me = 256, Ne = 512, Pe = D, Fe = 512, Ie = 512, M = 256, N = O, P = O, Le = O, F = D, Re = new Set([
+	"Unexpected signature",
+	"Encrypted ZIP",
+	"Expected Central-File-Header signature"
+]), ze = [
+	"ZIP entry count exceeds ",
+	"Unsupported ZIP compression method:",
+	"ZIP entry compressed data exceeds ",
+	"ZIP entry decompressed data exceeds ",
+	"Expected data-descriptor-signature at position "
+], Be = new Set([
+	"Z_BUF_ERROR",
+	"Z_DATA_ERROR",
+	"ERR_INVALID_STATE"
+]), I = class extends Error {};
+function Ve(e) {
+	var t;
+	let n = e == null ? void 0 : e.streamReader;
+	if ((n == null || (t = n.constructor) == null ? void 0 : t.name) !== "WebStreamByobReader") return e;
+	let { reader: r } = n, i = async () => {
+		await r.cancel(), r.releaseLock();
+	};
+	return n.close = i, n.abort = async () => {
+		n.interrupted = !0, await i();
+	}, e;
+}
+function L(e, t, n) {
+	if (!Number.isFinite(e) || e < 0 || e > t) throw new I(`${n} has invalid size ${e} (maximum ${t} bytes)`);
+	return e;
+}
+async function R(e, t, { maximumLength: n = D, reason: r = "skip" } = {}) {
+	let i = L(t, n, r);
+	await e.ignore(i);
+}
+async function z(e, t, n, { maximumLength: i = t.length, reason: a = "read" } = {}) {
+	var o;
+	let s = L((o = n == null ? void 0 : n.length) == null ? t.length : o, i, a);
+	return e.readBuffer(t, r(r({}, n), {}, { length: s }));
+}
+async function He(e, { maximumLength: t = E } = {}) {
+	let n = new ReadableStream({ start(t) {
+		t.enqueue(e), t.close();
+	} }).pipeThrough(new DecompressionStream("deflate-raw")).getReader(), r = [], i = 0;
+	try {
+		for (;;) {
+			let { done: e, value: a } = await n.read();
+			if (e) break;
+			if (i += a.length, i > t) throw await n.cancel(), Error(`ZIP entry decompressed data exceeds ${t} bytes`);
+			r.push(a);
+		}
+	} finally {
+		n.releaseLock();
+	}
+	let a = new Uint8Array(i), o = 0;
+	for (let e of r) a.set(e, o), o += e.length;
+	return a;
+}
+var B = 134695760, V = 16, Ue = V - 1;
+function We(e, t) {
+	if (e.length < V) return -1;
+	let n = e.length - V;
+	for (let r = 0; r <= n; r++) if (m.get(e, r) === B && m.get(e, r + 8) === t + r) return r;
+	return -1;
+}
+function Ge(e) {
+	return (e.codePointAt(0) & 32) != 0;
+}
+function Ke(e, t) {
+	let n = new Uint8Array(t), r = 0;
+	for (let t of e) n.set(t, r), r += t.length;
+	return n;
+}
+async function qe(e, { shouldBuffer: t, maximumLength: n = E } = {}) {
+	let { syncBuffer: r } = e, { length: i } = r, a = [], o = 0;
+	for (;;) {
+		let s = await e.tokenizer.peekBuffer(r, { mayBeLess: !0 }), c = We(r.subarray(0, s), o), l = c >= 0 ? 0 : s === i ? Math.min(Ue, s - 1) : 0, u = c >= 0 ? c : s - l;
+		if (u === 0) break;
+		if (o += u, o > n) throw Error(`ZIP entry compressed data exceeds ${n} bytes`);
+		if (t) {
+			let t = new Uint8Array(u);
+			await e.tokenizer.readBuffer(t), a.push(t);
+		} else await e.tokenizer.ignore(u);
+		if (c >= 0) break;
+	}
+	if (G(e.tokenizer) || (e.knownSizeDescriptorScannedBytes += o), t) return Ke(a, o);
+}
+function Je(e, t) {
+	return G(e.tokenizer) ? Math.max(0, D - (e.tokenizer.position - t)) : Math.max(0, E - e.knownSizeDescriptorScannedBytes);
+}
+async function Ye(e, t, { shouldBuffer: n, maximumDescriptorLength: r = E } = {}) {
+	if (t.dataDescriptor && t.compressedSize === 0) return qe(e, {
+		shouldBuffer: n,
+		maximumLength: r
+	});
+	if (!n) {
+		await R(e.tokenizer, t.compressedSize, {
+			maximumLength: G(e.tokenizer) ? E : e.tokenizer.fileInfo.size,
+			reason: "ZIP entry compressed data"
+		});
+		return;
+	}
+	let i = tt(e.tokenizer);
+	if (!Number.isFinite(t.compressedSize) || t.compressedSize < 0 || t.compressedSize > i) throw Error(`ZIP entry compressed data exceeds ${i} bytes`);
+	let a = new Uint8Array(t.compressedSize);
+	return await e.tokenizer.readBuffer(a), a;
+}
+w.prototype.inflate = async function(e, t, n) {
+	if (e.compressedMethod === 0) return n(t);
+	if (e.compressedMethod !== 8) throw Error(`Unsupported ZIP compression method: ${e.compressedMethod}`);
+	return n(await He(t, { maximumLength: E }));
+}, w.prototype.unzip = async function(e) {
+	let t = !1, n = 0, r = this.tokenizer.position;
+	this.knownSizeDescriptorScannedBytes = 0;
+	do {
+		if (K(this.tokenizer, r, D)) throw new I(`ZIP stream probing exceeds ${D} bytes`);
+		let i = await this.readLocalFileHeader();
+		if (!i) break;
+		if (n++, n > Ee) throw Error(`ZIP entry count exceeds ${Ee}`);
+		let a = e(i);
+		t = !!a.stop, await this.tokenizer.ignore(i.extraFieldLength);
+		let o = await Ye(this, i, {
+			shouldBuffer: !!a.handler,
+			maximumDescriptorLength: Math.min(E, Je(this, r))
+		});
+		if (a.handler && await this.inflate(i, o, a.handler), i.dataDescriptor) {
+			let e = new Uint8Array(V);
+			if (await this.tokenizer.readBuffer(e), m.get(e, 0) !== B) throw Error(`Expected data-descriptor-signature at position ${this.tokenizer.position - e.length}`);
+		}
+		if (K(this.tokenizer, r, D)) throw new I(`ZIP stream probing exceeds ${D} bytes`);
+	} while (!t);
+};
+function Xe(e, t) {
+	let n = e.getReader(), r = 0, i = !1, a = !1, o = async (e) => {
+		i || a || (a = !0, await n.cancel(e));
+	};
+	return new ReadableStream({
+		async pull(e) {
+			if (r >= t) {
+				e.close(), await o();
+				return;
+			}
+			let { done: a, value: s } = await n.read();
+			if (a || !s) {
+				i = !0, e.close();
+				return;
+			}
+			let c = t - r;
+			if (s.length > c) {
+				e.enqueue(s.subarray(0, c)), r += c, e.close(), await o();
+				return;
+			}
+			e.enqueue(s), r += s.length;
+		},
+		async cancel(e) {
+			await o(e);
+		}
+	});
+}
+async function H(e, t) {
+	return new ct(t).fromBuffer(e);
+}
+function U(e) {
+	switch (e = e.toLowerCase(), e) {
+		case "application/epub+zip": return {
+			ext: "epub",
+			mime: e
+		};
+		case "application/vnd.oasis.opendocument.text": return {
+			ext: "odt",
+			mime: e
+		};
+		case "application/vnd.oasis.opendocument.text-template": return {
+			ext: "ott",
+			mime: e
+		};
+		case "application/vnd.oasis.opendocument.spreadsheet": return {
+			ext: "ods",
+			mime: e
+		};
+		case "application/vnd.oasis.opendocument.spreadsheet-template": return {
+			ext: "ots",
+			mime: e
+		};
+		case "application/vnd.oasis.opendocument.presentation": return {
+			ext: "odp",
+			mime: e
+		};
+		case "application/vnd.oasis.opendocument.presentation-template": return {
+			ext: "otp",
+			mime: e
+		};
+		case "application/vnd.oasis.opendocument.graphics": return {
+			ext: "odg",
+			mime: e
+		};
+		case "application/vnd.oasis.opendocument.graphics-template": return {
+			ext: "otg",
+			mime: e
+		};
+		case "application/vnd.openxmlformats-officedocument.presentationml.slideshow": return {
+			ext: "ppsx",
+			mime: e
+		};
+		case "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": return {
+			ext: "xlsx",
+			mime: e
+		};
+		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: e
+		};
+		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: e
+		};
+		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: e
+		};
+		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: e
+		};
+		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: e
+		};
+		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 W(e, t, n) {
+	n = r({ offset: 0 }, n);
+	for (let [r, i] of t.entries()) if (n.mask) {
+		if (i !== (n.mask[r] & e[r + n.offset])) return !1;
+	} else if (i !== e[r + n.offset]) return !1;
+	return !0;
+}
+function Ze(e) {
+	return Number.isFinite(e) ? Math.max(1, Math.trunc(e)) : T;
+}
+function Qe(e, t, n) {
+	return n === void 0 ? e.read(t) : (n.throwIfAborted(), new Promise((r, i) => {
+		let a = () => {
+			n.removeEventListener("abort", o);
+		}, o = () => {
+			let t = n.reason;
+			a(), (async () => {
+				try {
+					await e.cancel(t);
+				} catch (e) {}
+			})(), i(t);
+		};
+		n.addEventListener("abort", o, { once: !0 }), (async () => {
+			try {
+				let n = await e.read(t);
+				a(), r(n);
+			} catch (e) {
+				a(), i(e);
+			}
+		})();
+	}));
+}
+function $e(e) {
+	return Number.isFinite(e) ? Math.max(0, Math.min(Te, Math.trunc(e))) : 0;
+}
+function et(e) {
+	return Number.isFinite(e) ? Math.max(0, e) : 2 ** 53 - 1;
+}
+function G(e) {
+	let t = e.fileInfo.size;
+	return !Number.isFinite(t) || t === 2 ** 53 - 1;
+}
+function K(e, t, n) {
+	return G(e) && e.position - t > n;
+}
+function tt(e) {
+	let t = e.fileInfo.size, n = Number.isFinite(t) ? Math.max(0, t - e.position) : 2 ** 53 - 1;
+	return Math.min(n, De);
+}
+function nt(e) {
+	if (e instanceof g || e instanceof I) return !0;
+	if (!(e instanceof Error)) return !1;
+	if (Re.has(e.message) || Be.has(e.code)) return !0;
+	for (let t of ze) if (e.message.startsWith(t)) return !0;
+	return !1;
+}
+function rt(e, t = E) {
+	let n = [e.compressedSize, e.uncompressedSize];
+	for (let e of n) if (!Number.isFinite(e) || e < 0 || e > t) return !1;
+	return !0;
+}
+function it() {
+	return {
+		hasContentTypesEntry: !1,
+		hasParsedContentTypesEntry: !1,
+		isParsingContentTypes: !1,
+		hasUnparseableContentTypes: !1,
+		hasWordDirectory: !1,
+		hasPresentationDirectory: !1,
+		hasSpreadsheetDirectory: !1,
+		hasThreeDimensionalModelEntry: !1
+	};
+}
+function at(e, t) {
+	t.startsWith("word/") && (e.hasWordDirectory = !0), t.startsWith("ppt/") && (e.hasPresentationDirectory = !0), t.startsWith("xl/") && (e.hasSpreadsheetDirectory = !0), t.startsWith("3D/") && t.endsWith(".model") && (e.hasThreeDimensionalModelEntry = !0);
+}
+function ot(e) {
+	if (!(!e.hasContentTypesEntry || e.hasUnparseableContentTypes || e.isParsingContentTypes || e.hasParsedContentTypesEntry)) {
+		if (e.hasWordDirectory) return {
+			ext: "docx",
+			mime: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+		};
+		if (e.hasPresentationDirectory) return {
+			ext: "pptx",
+			mime: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+		};
+		if (e.hasSpreadsheetDirectory) return {
+			ext: "xlsx",
+			mime: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+		};
+		if (e.hasThreeDimensionalModelEntry) return {
+			ext: "3mf",
+			mime: "model/3mf"
+		};
+	}
+}
+function st(e) {
+	let t = e.indexOf(".main+xml\"");
+	if (t === -1) {
+		let t = "application/vnd.ms-package.3dmanufacturing-3dmodel+xml";
+		return e.includes(`ContentType="${t}"`) ? t : void 0;
+	}
+	let n = e.slice(0, t), r = n.lastIndexOf("\"");
+	return n.slice(r + 1);
+}
+var ct = class e {
+	constructor(e) {
+		var t = this, i;
+		n(this, "detectConfident", async (e) => {
+			if (t.buffer = new Uint8Array(T), e.fileInfo.size === void 0 && (e.fileInfo.size = 2 ** 53 - 1), t.tokenizer = e, G(e) && (await e.peekBuffer(t.buffer, {
+				length: 3,
+				mayBeLess: !0
+			}), t.check([
+				31,
+				139,
+				8
+			]))) return t.detectGzip(e);
+			if (await e.peekBuffer(t.buffer, {
+				length: 32,
+				mayBeLess: !0
+			}), t.check([66, 77])) return {
+				ext: "bmp",
+				mime: "image/bmp"
+			};
+			if (t.check([11, 119])) return {
+				ext: "ac3",
+				mime: "audio/vnd.dolby.dd-raw"
+			};
+			if (t.check([120, 1])) return {
+				ext: "dmg",
+				mime: "application/x-apple-diskimage"
+			};
+			if (t.check([77, 90])) return {
+				ext: "exe",
+				mime: "application/x-msdownload"
+			};
+			if (t.check([37, 33])) return await e.peekBuffer(t.buffer, {
+				length: 24,
+				mayBeLess: !0
+			}), t.checkString("PS-Adobe-", { offset: 2 }) && t.checkString(" EPSF-", { offset: 14 }) ? {
+				ext: "eps",
+				mime: "application/eps"
+			} : {
+				ext: "ps",
+				mime: "application/postscript"
+			};
+			if (t.check([31, 160]) || t.check([31, 157])) return {
+				ext: "Z",
+				mime: "application/x-compress"
+			};
+			if (t.check([199, 113])) return {
+				ext: "cpio",
+				mime: "application/x-cpio"
+			};
+			if (t.check([96, 234])) return {
+				ext: "arj",
+				mime: "application/x-arj"
+			};
+			if (t.check([
+				239,
+				187,
+				191
+			])) return t.detectionReentryCount >= M ? void 0 : (t.detectionReentryCount++, await t.tokenizer.ignore(3), t.detectConfident(e));
+			if (t.check([
+				71,
+				73,
+				70
+			])) return {
+				ext: "gif",
+				mime: "image/gif"
+			};
+			if (t.check([
+				73,
+				73,
+				188
+			])) return {
+				ext: "jxr",
+				mime: "image/vnd.ms-photo"
+			};
+			if (t.check([
+				31,
+				139,
+				8
+			])) return t.detectGzip(e);
+			if (t.check([
+				66,
+				90,
+				104
+			])) return {
+				ext: "bz2",
+				mime: "application/x-bzip2"
+			};
+			if (t.checkString("ID3")) {
+				await R(e, 6, {
+					maximumLength: 6,
+					reason: "ID3 header prefix"
+				});
+				let n = await e.readToken(Se), r = G(e);
+				if (!Number.isFinite(n) || n < 0 || r && (n > k || e.position + n > k)) return;
+				if (e.position + n > e.fileInfo.size) return r ? void 0 : {
+					ext: "mp3",
+					mime: "audio/mpeg"
+				};
+				try {
+					await R(e, n, {
+						maximumLength: r ? k : e.fileInfo.size,
+						reason: "ID3 payload"
+					});
+				} catch (e) {
+					if (e instanceof g) return;
+					throw e;
+				}
+				return t.detectionReentryCount >= M ? void 0 : (t.detectionReentryCount++, t.parseTokenizer(e, t.detectionReentryCount));
+			}
+			if (t.checkString("MP+")) return {
+				ext: "mpc",
+				mime: "audio/x-musepack"
+			};
+			if ((t.buffer[0] === 67 || t.buffer[0] === 70) && t.check([87, 83], { offset: 1 })) return {
+				ext: "swf",
+				mime: "application/x-shockwave-flash"
+			};
+			if (t.check([
+				255,
+				216,
+				255
+			])) return t.check([247], { offset: 3 }) ? {
+				ext: "jls",
+				mime: "image/jls"
+			} : {
+				ext: "jpg",
+				mime: "image/jpeg"
+			};
+			if (t.check([
+				79,
+				98,
+				106,
+				1
+			])) return {
+				ext: "avro",
+				mime: "application/avro"
+			};
+			if (t.checkString("FLIF")) return {
+				ext: "flif",
+				mime: "image/flif"
+			};
+			if (t.checkString("8BPS")) return {
+				ext: "psd",
+				mime: "image/vnd.adobe.photoshop"
+			};
+			if (t.checkString("MPCK")) return {
+				ext: "mpc",
+				mime: "audio/x-musepack"
+			};
+			if (t.checkString("FORM")) return {
+				ext: "aif",
+				mime: "audio/aiff"
+			};
+			if (t.checkString("icns", { offset: 0 })) return {
+				ext: "icns",
+				mime: "image/icns"
+			};
+			if (t.check([
+				80,
+				75,
+				3,
+				4
+			])) {
+				var n, r;
+				let t, i = it();
+				try {
+					await new w(e).unzip((e) => {
+						at(i, e.filename);
+						let n = e.filename === "[Content_Types].xml", r = ot(i);
+						if (!n && r) return t = r, { stop: !0 };
+						switch (e.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 rt(e, Oe) ? {
+								async handler(e) {
+									t = U(new TextDecoder("utf-8").decode(e).trim());
+								},
+								stop: !0
+							} : {};
+							case "[Content_Types].xml": return i.hasContentTypesEntry = !0, rt(e, Oe) ? (i.isParsingContentTypes = !0, {
+								async handler(e) {
+									let n = st(new TextDecoder("utf-8").decode(e));
+									n && (t = U(n)), i.hasParsedContentTypesEntry = !0, i.isParsingContentTypes = !1;
+								},
+								stop: !0
+							}) : (i.hasUnparseableContentTypes = !0, {});
+							default: return /classes\d*\.dex/.test(e.filename) ? (t = {
+								ext: "apk",
+								mime: "application/vnd.android.package-archive"
+							}, { stop: !0 }) : {};
+						}
+					});
+				} catch (e) {
+					if (!nt(e)) throw e;
+					i.isParsingContentTypes && (i.isParsingContentTypes = !1, i.hasUnparseableContentTypes = !0);
+				}
+				return (n = (r = t) == null ? ot(i) : r) == null ? {
+					ext: "zip",
+					mime: "application/zip"
+				} : n;
+			}
+			if (t.checkString("OggS")) {
+				await e.ignore(28);
+				let t = new Uint8Array(8);
+				return await e.readBuffer(t), W(t, [
+					79,
+					112,
+					117,
+					115,
+					72,
+					101,
+					97,
+					100
+				]) ? {
+					ext: "opus",
+					mime: "audio/ogg; codecs=opus"
+				} : W(t, [
+					128,
+					116,
+					104,
+					101,
+					111,
+					114,
+					97
+				]) ? {
+					ext: "ogv",
+					mime: "video/ogg"
+				} : W(t, [
+					1,
+					118,
+					105,
+					100,
+					101,
+					111,
+					0
+				]) ? {
+					ext: "ogm",
+					mime: "video/ogg"
+				} : W(t, [
+					127,
+					70,
+					76,
+					65,
+					67
+				]) ? {
+					ext: "oga",
+					mime: "audio/ogg"
+				} : W(t, [
+					83,
+					112,
+					101,
+					101,
+					120,
+					32,
+					32
+				]) ? {
+					ext: "spx",
+					mime: "audio/ogg"
+				} : W(t, [
+					1,
+					118,
+					111,
+					114,
+					98,
+					105,
+					115
+				]) ? {
+					ext: "ogg",
+					mime: "audio/ogg"
+				} : {
+					ext: "ogx",
+					mime: "application/ogg"
+				};
+			}
+			if (t.check([80, 75]) && (t.buffer[2] === 3 || t.buffer[2] === 5 || t.buffer[2] === 7) && (t.buffer[3] === 4 || t.buffer[3] === 6 || t.buffer[3] === 8)) return {
+				ext: "zip",
+				mime: "application/zip"
+			};
+			if (t.checkString("MThd")) return {
+				ext: "mid",
+				mime: "audio/midi"
+			};
+			if (t.checkString("wOFF") && (t.check([
+				0,
+				1,
+				0,
+				0
+			], { offset: 4 }) || t.checkString("OTTO", { offset: 4 }))) return {
+				ext: "woff",
+				mime: "font/woff"
+			};
+			if (t.checkString("wOF2") && (t.check([
+				0,
+				1,
+				0,
+				0
+			], { offset: 4 }) || t.checkString("OTTO", { offset: 4 }))) return {
+				ext: "woff2",
+				mime: "font/woff2"
+			};
+			if (t.check([
+				212,
+				195,
+				178,
+				161
+			]) || t.check([
+				161,
+				178,
+				195,
+				212
+			])) return {
+				ext: "pcap",
+				mime: "application/vnd.tcpdump.pcap"
+			};
+			if (t.checkString("DSD ")) return {
+				ext: "dsf",
+				mime: "audio/x-dsf"
+			};
+			if (t.checkString("LZIP")) return {
+				ext: "lz",
+				mime: "application/x-lzip"
+			};
+			if (t.checkString("fLaC")) return {
+				ext: "flac",
+				mime: "audio/flac"
+			};
+			if (t.check([
+				66,
+				80,
+				71,
+				251
+			])) return {
+				ext: "bpg",
+				mime: "image/bpg"
+			};
+			if (t.checkString("wvpk")) return {
+				ext: "wv",
+				mime: "audio/wavpack"
+			};
+			if (t.checkString("%PDF")) return {
+				ext: "pdf",
+				mime: "application/pdf"
+			};
+			if (t.check([
+				0,
+				97,
+				115,
+				109
+			])) return {
+				ext: "wasm",
+				mime: "application/wasm"
+			};
+			if (t.check([73, 73])) {
+				let e = await t.readTiffHeader(!1);
+				if (e) return e;
+			}
+			if (t.check([77, 77])) {
+				let e = await t.readTiffHeader(!0);
+				if (e) return e;
+			}
+			if (t.checkString("MAC ")) return {
+				ext: "ape",
+				mime: "audio/ape"
+			};
+			if (t.check([
+				26,
+				69,
+				223,
+				163
+			])) {
+				async function t() {
+					let t = await e.peekNumber(o), n = 128, r = 0;
+					for (; (t & n) === 0 && n !== 0;) ++r, n >>= 1;
+					let i = new Uint8Array(r + 1);
+					return await z(e, i, void 0, {
+						maximumLength: i.length,
+						reason: "EBML field"
+					}), i;
+				}
+				async function n() {
+					let e = await t(), n = await t();
+					n[0] ^= 128 >> n.length - 1;
+					let r = Math.min(6, n.length), i = new DataView(e.buffer), a = new DataView(n.buffer, n.length - r, r);
+					return {
+						id: _(i),
+						len: _(a)
+					};
+				}
+				async function r(t) {
+					let r = 0;
+					for (; t > 0;) {
+						if (r++, r > Me || K(e, a, D)) return;
+						let i = e.position, o = await n();
+						if (o.id === 17026) {
+							if (o.len > A) return;
+							let t = L(o.len, A, "EBML DocType");
+							return (await e.readToken(new p(t))).replaceAll(/\00.*$/g, "");
+						}
+						if (G(e) && (!Number.isFinite(o.len) || o.len < 0 || o.len > j) || (await R(e, o.len, {
+							maximumLength: G(e) ? j : e.fileInfo.size,
+							reason: "EBML payload"
+						}), --t, e.position <= i)) return;
+					}
+				}
+				let i = await n(), a = e.position;
+				switch (await r(i.len)) {
+					case "webm": return {
+						ext: "webm",
+						mime: "video/webm"
+					};
+					case "matroska": return {
+						ext: "mkv",
+						mime: "video/matroska"
+					};
+					default: return;
+				}
+			}
+			if (t.checkString("SQLi")) return {
+				ext: "sqlite",
+				mime: "application/x-sqlite3"
+			};
+			if (t.check([
+				78,
+				69,
+				83,
+				26
+			])) return {
+				ext: "nes",
+				mime: "application/x-nintendo-nes-rom"
+			};
+			if (t.checkString("Cr24")) return {
+				ext: "crx",
+				mime: "application/x-google-chrome-extension"
+			};
+			if (t.checkString("MSCF") || t.checkString("ISc(")) return {
+				ext: "cab",
+				mime: "application/vnd.ms-cab-compressed"
+			};
+			if (t.check([
+				237,
+				171,
+				238,
+				219
+			])) return {
+				ext: "rpm",
+				mime: "application/x-rpm"
+			};
+			if (t.check([
+				197,
+				208,
+				211,
+				198
+			])) return {
+				ext: "eps",
+				mime: "application/eps"
+			};
+			if (t.check([
+				40,
+				181,
+				47,
+				253
+			])) return {
+				ext: "zst",
+				mime: "application/zstd"
+			};
+			if (t.check([
+				127,
+				69,
+				76,
+				70
+			])) return {
+				ext: "elf",
+				mime: "application/x-elf"
+			};
+			if (t.check([
+				33,
+				66,
+				68,
+				78
+			])) return {
+				ext: "pst",
+				mime: "application/vnd.ms-outlook"
+			};
+			if (t.checkString("PAR1") || t.checkString("PARE")) return {
+				ext: "parquet",
+				mime: "application/vnd.apache.parquet"
+			};
+			if (t.checkString("ttcf")) return {
+				ext: "ttc",
+				mime: "font/collection"
+			};
+			if (t.check([
+				254,
+				237,
+				250,
+				206
+			]) || t.check([
+				254,
+				237,
+				250,
+				207
+			]) || t.check([
+				206,
+				250,
+				237,
+				254
+			]) || t.check([
+				207,
+				250,
+				237,
+				254
+			])) return {
+				ext: "macho",
+				mime: "application/x-mach-binary"
+			};
+			if (t.check([
+				4,
+				34,
+				77,
+				24
+			])) return {
+				ext: "lz4",
+				mime: "application/x-lz4"
+			};
+			if (t.checkString("regf")) return {
+				ext: "dat",
+				mime: "application/x-ft-windows-registry-hive"
+			};
+			if (t.checkString("$FL2") || t.checkString("$FL3")) return {
+				ext: "sav",
+				mime: "application/x-spss-sav"
+			};
+			if (t.check([
+				79,
+				84,
+				84,
+				79,
+				0
+			])) return {
+				ext: "otf",
+				mime: "font/otf"
+			};
+			if (t.checkString("#!AMR")) return {
+				ext: "amr",
+				mime: "audio/amr"
+			};
+			if (t.checkString("{\\rtf")) return {
+				ext: "rtf",
+				mime: "application/rtf"
+			};
+			if (t.check([
+				70,
+				76,
+				86,
+				1
+			])) return {
+				ext: "flv",
+				mime: "video/x-flv"
+			};
+			if (t.checkString("IMPM")) return {
+				ext: "it",
+				mime: "audio/x-it"
+			};
+			if (t.checkString("-lh0-", { offset: 2 }) || t.checkString("-lh1-", { offset: 2 }) || t.checkString("-lh2-", { offset: 2 }) || t.checkString("-lh3-", { offset: 2 }) || t.checkString("-lh4-", { offset: 2 }) || t.checkString("-lh5-", { offset: 2 }) || t.checkString("-lh6-", { offset: 2 }) || t.checkString("-lh7-", { offset: 2 }) || t.checkString("-lzs-", { offset: 2 }) || t.checkString("-lz4-", { offset: 2 }) || t.checkString("-lz5-", { offset: 2 }) || t.checkString("-lhd-", { offset: 2 })) return {
+				ext: "lzh",
+				mime: "application/x-lzh-compressed"
+			};
+			if (t.check([
+				0,
+				0,
+				1,
+				186
+			])) {
+				if (t.check([33], {
+					offset: 4,
+					mask: [241]
+				})) return {
+					ext: "mpg",
+					mime: "video/MP1S"
+				};
+				if (t.check([68], {
+					offset: 4,
+					mask: [196]
+				})) return {
+					ext: "mpg",
+					mime: "video/MP2P"
+				};
+			}
+			if (t.checkString("ITSF")) return {
+				ext: "chm",
+				mime: "application/vnd.ms-htmlhelp"
+			};
+			if (t.check([
+				202,
+				254,
+				186,
+				190
+			])) {
+				let e = a.get(t.buffer, 4), n = h.get(t.buffer, 6);
+				if (e > 0 && e <= 30) return {
+					ext: "macho",
+					mime: "application/x-mach-binary"
+				};
+				if (n > 30) return {
+					ext: "class",
+					mime: "application/java-vm"
+				};
+			}
+			if (t.checkString(".RMF")) return {
+				ext: "rm",
+				mime: "application/vnd.rn-realmedia"
+			};
+			if (t.checkString("DRACO")) return {
+				ext: "drc",
+				mime: "application/vnd.google.draco"
+			};
+			if (t.check([
+				253,
+				55,
+				122,
+				88,
+				90,
+				0
+			])) return {
+				ext: "xz",
+				mime: "application/x-xz"
+			};
+			if (t.checkString("<?xml ")) return {
+				ext: "xml",
+				mime: "application/xml"
+			};
+			if (t.check([
+				55,
+				122,
+				188,
+				175,
+				39,
+				28
+			])) return {
+				ext: "7z",
+				mime: "application/x-7z-compressed"
+			};
+			if (t.check([
+				82,
+				97,
+				114,
+				33,
+				26,
+				7
+			]) && (t.buffer[6] === 0 || t.buffer[6] === 1)) return {
+				ext: "rar",
+				mime: "application/x-rar-compressed"
+			};
+			if (t.checkString("solid ")) return {
+				ext: "stl",
+				mime: "model/stl"
+			};
+			if (t.checkString("AC")) {
+				let e = new p(4, "latin1").get(t.buffer, 2);
+				if (e.match("^d*") && e >= 1e3 && e <= 1050) return {
+					ext: "dwg",
+					mime: "image/vnd.dwg"
+				};
+			}
+			if (t.checkString("070707")) return {
+				ext: "cpio",
+				mime: "application/x-cpio"
+			};
+			if (t.checkString("BLENDER")) return {
+				ext: "blend",
+				mime: "application/x-blender"
+			};
+			if (t.checkString("!<arch>")) return await e.ignore(8), await e.readToken(new p(13, "ascii")) === "debian-binary" ? {
+				ext: "deb",
+				mime: "application/x-deb"
+			} : {
+				ext: "ar",
+				mime: "application/x-unix-archive"
+			};
+			if (t.checkString("WEBVTT") && [
+				"\n",
+				"\r",
+				"	",
+				" ",
+				"\0"
+			].some((e) => t.checkString(e, { offset: 6 }))) return {
+				ext: "vtt",
+				mime: "text/vtt"
+			};
+			if (t.check([
+				137,
+				80,
+				78,
+				71,
+				13,
+				10,
+				26,
+				10
+			])) {
+				let t = {
+					ext: "png",
+					mime: "image/png"
+				}, n = {
+					ext: "apng",
+					mime: "image/apng"
+				};
+				await e.ignore(8);
+				async function r() {
+					return {
+						length: await e.readToken(ee),
+						type: await e.readToken(new p(4, "latin1"))
+					};
+				}
+				let i = G(e), a = e.position, o = 0, s = !1;
+				do {
+					if (o++, o > Ne || K(e, a, Pe)) break;
+					let c = e.position, l = await r();
+					if (l.length < 0) return;
+					if (l.type === "IHDR") {
+						if (l.length !== 13) return;
+						s = !0;
+					}
+					switch (l.type) {
+						case "IDAT": return t;
+						case "acTL": return n;
+						default:
+							if (!s && l.type !== "CgBI") return;
+							if (i && l.length > N) return s && Ge(l.type) ? t : void 0;
+							try {
+								await R(e, l.length + 4, {
+									maximumLength: i ? N + 4 : e.fileInfo.size,
+									reason: "PNG chunk payload"
+								});
+							} catch (e) {
+								if (!i && (e instanceof I || e instanceof g)) return t;
+								throw e;
+							}
+					}
+					if (e.position <= c) break;
+				} while (e.position + 8 < e.fileInfo.size);
+				return t;
+			}
+			if (t.check([
+				65,
+				82,
+				82,
+				79,
+				87,
+				49,
+				0,
+				0
+			])) return {
+				ext: "arrow",
+				mime: "application/vnd.apache.arrow.file"
+			};
+			if (t.check([
+				103,
+				108,
+				84,
+				70,
+				2,
+				0,
+				0,
+				0
+			])) return {
+				ext: "glb",
+				mime: "model/gltf-binary"
+			};
+			if (t.check([
+				102,
+				114,
+				101,
+				101
+			], { offset: 4 }) || t.check([
+				109,
+				100,
+				97,
+				116
+			], { offset: 4 }) || t.check([
+				109,
+				111,
+				111,
+				118
+			], { offset: 4 }) || t.check([
+				119,
+				105,
+				100,
+				101
+			], { offset: 4 })) return {
+				ext: "mov",
+				mime: "video/quicktime"
+			};
+			if (t.check([
+				73,
+				73,
+				82,
+				79,
+				8,
+				0,
+				0,
+				0,
+				24
+			])) return {
+				ext: "orf",
+				mime: "image/x-olympus-orf"
+			};
+			if (t.checkString("gimp xcf ")) return {
+				ext: "xcf",
+				mime: "image/x-xcf"
+			};
+			if (t.checkString("ftyp", { offset: 4 }) && t.buffer[8] & 96) {
+				let e = new p(4, "latin1").get(t.buffer, 8).replace("\0", " ").trim();
+				switch (e) {
+					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 e.startsWith("3g") ? e.startsWith("3g2") ? {
+						ext: "3g2",
+						mime: "video/3gpp2"
+					} : {
+						ext: "3gp",
+						mime: "video/3gpp"
+					} : {
+						ext: "mp4",
+						mime: "video/mp4"
+					};
+				}
+			}
+			if (t.checkString("REGEDIT4\r\n")) return {
+				ext: "reg",
+				mime: "application/x-ms-regedit"
+			};
+			if (t.check([
+				82,
+				73,
+				70,
+				70
+			])) {
+				if (t.checkString("WEBP", { offset: 8 })) return {
+					ext: "webp",
+					mime: "image/webp"
+				};
+				if (t.check([
+					65,
+					86,
+					73
+				], { offset: 8 })) return {
+					ext: "avi",
+					mime: "video/vnd.avi"
+				};
+				if (t.check([
+					87,
+					65,
+					86,
+					69
+				], { offset: 8 })) return {
+					ext: "wav",
+					mime: "audio/wav"
+				};
+				if (t.check([
+					81,
+					76,
+					67,
+					77
+				], { offset: 8 })) return {
+					ext: "qcp",
+					mime: "audio/qcelp"
+				};
+			}
+			if (t.check([
+				73,
+				73,
+				85,
+				0,
+				24,
+				0,
+				0,
+				0,
+				136,
+				231,
+				116,
+				216
+			])) return {
+				ext: "rw2",
+				mime: "image/x-panasonic-rw2"
+			};
+			if (t.check([
+				48,
+				38,
+				178,
+				117,
+				142,
+				102,
+				207,
+				17,
+				166,
+				217
+			])) {
+				let t = !1;
+				try {
+					async function n() {
+						let t = new Uint8Array(16);
+						return await z(e, t, void 0, {
+							maximumLength: t.length,
+							reason: "ASF header GUID"
+						}), {
+							id: t,
+							size: Number(await e.readToken(s))
+						};
+					}
+					await R(e, 30, {
+						maximumLength: 30,
+						reason: "ASF header prelude"
+					});
+					let r = G(e), i = e.position, a = 0;
+					for (; e.position + 24 < e.fileInfo.size && (a++, !(a > Fe || K(e, i, D)));) {
+						let i = e.position, a = await n(), o = a.size - 24;
+						if (!Number.isFinite(o) || o < 0) {
+							t = !0;
+							break;
+						}
+						if (W(a.id, [
+							145,
+							7,
+							220,
+							183,
+							183,
+							169,
+							207,
+							17,
+							142,
+							230,
+							0,
+							192,
+							12,
+							32,
+							83,
+							101
+						])) {
+							let t = new Uint8Array(16);
+							if (o -= await z(e, t, void 0, {
+								maximumLength: t.length,
+								reason: "ASF stream type GUID"
+							}), W(t, [
+								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 (W(t, [
+								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 (r && o > P) {
+							t = !0;
+							break;
+						}
+						if (await R(e, o, {
+							maximumLength: r ? P : e.fileInfo.size,
+							reason: "ASF header payload"
+						}), e.position <= i) {
+							t = !0;
+							break;
+						}
+					}
+				} catch (n) {
+					if (n instanceof g || n instanceof I) G(e) && (t = !0);
+					else throw n;
+				}
+				return t ? void 0 : {
+					ext: "asf",
+					mime: "application/vnd.ms-asf"
+				};
+			}
+			if (t.check([
+				171,
+				75,
+				84,
+				88,
+				32,
+				49,
+				49,
+				187,
+				13,
+				10,
+				26,
+				10
+			])) return {
+				ext: "ktx",
+				mime: "image/ktx"
+			};
+			if ((t.check([
+				126,
+				16,
+				4
+			]) || t.check([
+				126,
+				24,
+				4
+			])) && t.check([
+				48,
+				77,
+				73,
+				69
+			], { offset: 4 })) return {
+				ext: "mie",
+				mime: "application/x-mie"
+			};
+			if (t.check([
+				39,
+				10,
+				0,
+				0,
+				0,
+				0,
+				0,
+				0,
+				0,
+				0,
+				0,
+				0
+			], { offset: 2 })) return {
+				ext: "shp",
+				mime: "application/x-esri-shape"
+			};
+			if (t.check([
+				255,
+				79,
+				255,
+				81
+			])) return {
+				ext: "j2c",
+				mime: "image/j2c"
+			};
+			if (t.check([
+				0,
+				0,
+				0,
+				12,
+				106,
+				80,
+				32,
+				32,
+				13,
+				10,
+				135,
+				10
+			])) switch (await e.ignore(20), await e.readToken(new p(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 (t.check([255, 10]) || t.check([
+				0,
+				0,
+				0,
+				12,
+				74,
+				88,
+				76,
+				32,
+				13,
+				10,
+				135,
+				10
+			])) return {
+				ext: "jxl",
+				mime: "image/jxl"
+			};
+			if (t.check([254, 255])) return t.checkString("<?xml ", {
+				offset: 2,
+				encoding: "utf-16be"
+			}) ? {
+				ext: "xml",
+				mime: "application/xml"
+			} : void 0;
+			if (t.check([
+				208,
+				207,
+				17,
+				224,
+				161,
+				177,
+				26,
+				225
+			])) return {
+				ext: "cfb",
+				mime: "application/x-cfb"
+			};
+			if (await e.peekBuffer(t.buffer, {
+				length: Math.min(256, e.fileInfo.size),
+				mayBeLess: !0
+			}), t.check([
+				97,
+				99,
+				115,
+				112
+			], { offset: 36 })) return {
+				ext: "icc",
+				mime: "application/vnd.iccprofile"
+			};
+			if (t.checkString("**ACE", { offset: 7 }) && t.checkString("**", { offset: 12 })) return {
+				ext: "ace",
+				mime: "application/x-ace-compressed"
+			};
+			if (t.checkString("BEGIN:")) {
+				if (t.checkString("VCARD", { offset: 6 })) return {
+					ext: "vcf",
+					mime: "text/vcard"
+				};
+				if (t.checkString("VCALENDAR", { offset: 6 })) return {
+					ext: "ics",
+					mime: "text/calendar"
+				};
+			}
+			if (t.checkString("FUJIFILMCCD-RAW")) return {
+				ext: "raf",
+				mime: "image/x-fujifilm-raf"
+			};
+			if (t.checkString("Extended Module:")) return {
+				ext: "xm",
+				mime: "audio/x-xm"
+			};
+			if (t.checkString("Creative Voice File")) return {
+				ext: "voc",
+				mime: "audio/x-voc"
+			};
+			if (t.check([
+				4,
+				0,
+				0,
+				0
+			]) && t.buffer.length >= 16) {
+				let e = new DataView(t.buffer.buffer).getUint32(12, !0);
+				if (e > 12 && t.buffer.length >= e + 16) try {
+					let n = new TextDecoder().decode(t.buffer.subarray(16, e + 16));
+					if (JSON.parse(n).files) return {
+						ext: "asar",
+						mime: "application/x-asar"
+					};
+				} catch (e) {}
+			}
+			if (t.check([
+				6,
+				14,
+				43,
+				52,
+				2,
+				5,
+				1,
+				1,
+				13,
+				1,
+				2,
+				1,
+				1,
+				2
+			])) return {
+				ext: "mxf",
+				mime: "application/mxf"
+			};
+			if (t.checkString("SCRM", { offset: 44 })) return {
+				ext: "s3m",
+				mime: "audio/x-s3m"
+			};
+			if (t.check([71]) && t.check([71], { offset: 188 }) || t.check([71], { offset: 4 }) && t.check([71], { offset: 196 })) return {
+				ext: "mts",
+				mime: "video/mp2t"
+			};
+			if (t.check([
+				66,
+				79,
+				79,
+				75,
+				77,
+				79,
+				66,
+				73
+			], { offset: 60 })) return {
+				ext: "mobi",
+				mime: "application/x-mobipocket-ebook"
+			};
+			if (t.check([
+				68,
+				73,
+				67,
+				77
+			], { offset: 128 })) return {
+				ext: "dcm",
+				mime: "application/dicom"
+			};
+			if (t.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 (t.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 (t.checkString("Kaydara FBX Binary  \0")) return {
+				ext: "fbx",
+				mime: "application/x.autodesk.fbx"
+			};
+			if (t.check([76, 80], { offset: 34 }) && (t.check([
+				0,
+				0,
+				1
+			], { offset: 8 }) || t.check([
+				1,
+				0,
+				2
+			], { offset: 8 }) || t.check([
+				2,
+				0,
+				2
+			], { offset: 8 }))) return {
+				ext: "eot",
+				mime: "application/vnd.ms-fontobject"
+			};
+			if (t.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 (t.check([
+				255,
+				255,
+				0,
+				0,
+				7,
+				0,
+				0,
+				0,
+				4,
+				0,
+				0,
+				0,
+				1,
+				0,
+				1,
+				0
+			]) || t.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(t.buffer, {
+				length: Math.min(512, e.fileInfo.size),
+				mayBeLess: !0
+			}), t.checkString("ustar", { offset: 257 }) && (t.checkString("\0", { offset: 262 }) || t.checkString(" ", { offset: 262 })) || t.check([
+				0,
+				0,
+				0,
+				0,
+				0,
+				0
+			], { offset: 257 }) && xe(t.buffer)) return {
+				ext: "tar",
+				mime: "application/x-tar"
+			};
+			if (t.check([255, 254])) {
+				let e = "utf-16le";
+				return t.checkString("<?xml ", {
+					offset: 2,
+					encoding: e
+				}) ? {
+					ext: "xml",
+					mime: "application/xml"
+				} : t.check([255, 14], { offset: 2 }) && t.checkString("SketchUp Model", {
+					offset: 4,
+					encoding: e
+				}) ? {
+					ext: "skp",
+					mime: "application/vnd.sketchup.skp"
+				} : t.checkString("Windows Registry Editor Version 5.00\r\n", {
+					offset: 2,
+					encoding: e
+				}) ? {
+					ext: "reg",
+					mime: "application/x-ms-regedit"
+				} : void 0;
+			}
+			if (t.checkString("-----BEGIN PGP MESSAGE-----")) return {
+				ext: "pgp",
+				mime: "application/pgp-encrypted"
+			};
+		}), n(this, "detectImprecise", async (e) => {
+			t.buffer = new Uint8Array(T);
+			let n = et(e.fileInfo.size);
+			if (await e.peekBuffer(t.buffer, {
+				length: Math.min(8, n),
+				mayBeLess: !0
+			}), t.check([
+				0,
+				0,
+				1,
+				186
+			]) || t.check([
+				0,
+				0,
+				1,
+				179
+			])) return {
+				ext: "mpg",
+				mime: "video/mpeg"
+			};
+			if (t.check([
+				0,
+				1,
+				0,
+				0,
+				0
+			])) return {
+				ext: "ttf",
+				mime: "font/ttf"
+			};
+			if (t.check([
+				0,
+				0,
+				1,
+				0
+			])) return {
+				ext: "ico",
+				mime: "image/x-icon"
+			};
+			if (t.check([
+				0,
+				0,
+				2,
+				0
+			])) return {
+				ext: "cur",
+				mime: "image/x-icon"
+			};
+			if (await e.peekBuffer(t.buffer, {
+				length: Math.min(2 + t.options.mpegOffsetTolerance, n),
+				mayBeLess: !0
+			}), t.buffer.length >= 2 + t.options.mpegOffsetTolerance) for (let e = 0; e <= t.options.mpegOffsetTolerance; ++e) {
+				let n = t.scanMpeg(e);
+				if (n) return n;
+			}
+		});
+		let c = $e(e == null ? void 0 : e.mpegOffsetTolerance);
+		this.options = r(r({}, e), {}, { mpegOffsetTolerance: c }), this.detectors = [
+			...(i = this.options.customDetectors) == null ? [] : i,
+			{
+				id: "core",
+				detect: this.detectConfident
+			},
+			{
+				id: "core.imprecise",
+				detect: this.detectImprecise
+			}
+		], this.tokenizerOptions = { abortSignal: this.options.signal }, this.gzipProbeDepth = 0;
+	}
+	getTokenizerOptions() {
+		return r({}, this.tokenizerOptions);
+	}
+	createTokenizerFromWebStream(e) {
+		return Ve(ne(e, this.getTokenizerOptions()));
+	}
+	async parseTokenizer(e, t = 0) {
+		var n = this;
+		n.detectionReentryCount = t;
+		let r = e.position;
+		for (let t of n.detectors) {
+			let n;
+			try {
+				n = await t.detect(e);
+			} catch (e) {
+				if (e instanceof g || e instanceof I) return;
+				throw e;
+			}
+			if (n) return n;
+			if (r !== e.position) return;
+		}
+	}
+	async fromTokenizer(e) {
+		var t = this;
+		try {
+			return await t.parseTokenizer(e);
+		} finally {
+			await e.close();
+		}
+	}
+	async fromBuffer(e) {
+		var t = this;
+		if (!(e instanceof Uint8Array || e instanceof ArrayBuffer)) throw TypeError(`Expected the \`input\` argument to be of type \`Uint8Array\` or \`ArrayBuffer\`, got \`${typeof e}\``);
+		let n = e instanceof Uint8Array ? e : new Uint8Array(e);
+		if ((n == null ? void 0 : n.length) > 1) return t.fromTokenizer(te(n, t.getTokenizerOptions()));
+	}
+	async fromBlob(e) {
+		var t = this, n;
+		(n = t.options.signal) == null || n.throwIfAborted();
+		let r = re(e, t.getTokenizerOptions());
+		return t.fromTokenizer(r);
+	}
+	async fromStream(e) {
+		var t = this, n;
+		(n = t.options.signal) == null || n.throwIfAborted();
+		let r = t.createTokenizerFromWebStream(e);
+		return t.fromTokenizer(r);
+	}
+	async toDetectionStream(e, t) {
+		var n = this, r;
+		let i = Ze((r = t == null ? void 0 : t.sampleSize) == null ? T : r), a, o, s = e.getReader({ mode: "byob" });
+		try {
+			let { value: e, done: t } = await Qe(s, new Uint8Array(i), n.options.signal);
+			if (o = e, !t && e) try {
+				a = await n.fromBuffer(e.subarray(0, i));
+			} catch (e) {
+				if (!(e instanceof g)) throw e;
+				a = void 0;
+			}
+			o = e;
+		} finally {
+			s.releaseLock();
+		}
+		let c = new TransformStream({
+			async start(e) {
+				e.enqueue(o);
+			},
+			transform(e, t) {
+				t.enqueue(e);
+			}
+		}), l = e.pipeThrough(c);
+		return l.fileType = a, l;
+	}
+	async detectGzip(t) {
+		var n = this;
+		if (n.gzipProbeDepth >= Ae) return {
+			ext: "gz",
+			mime: "application/gzip"
+		};
+		let i = Xe(new ye(t).inflate(), ke), a = G(t), o, s, c, l;
+		if (a) {
+			let t = new AbortController();
+			o = setTimeout(() => {
+				t.abort(new DOMException(`Operation timed out after ${je} ms`, "TimeoutError"));
+			}, je), s = n.options.signal === void 0 ? t.signal : AbortSignal.any([n.options.signal, t.signal]), c = new e(r(r({}, n.options), {}, { signal: s })), c.gzipProbeDepth = n.gzipProbeDepth + 1;
+		} else n.gzipProbeDepth++;
+		try {
+			var u;
+			l = await ((u = c) == null ? n : u).fromStream(i);
+		} catch (e) {
+			var d;
+			if ((e == null ? void 0 : e.name) === "AbortError" && (s == null || (d = s.reason) == null ? void 0 : d.name) !== "TimeoutError") throw e;
+		} finally {
+			clearTimeout(o), a || n.gzipProbeDepth--;
+		}
+		return (l == null ? void 0 : l.ext) === "tar" ? {
+			ext: "tar.gz",
+			mime: "application/gzip"
+		} : {
+			ext: "gz",
+			mime: "application/gzip"
+		};
+	}
+	check(e, t) {
+		return W(this.buffer, e, t);
+	}
+	checkString(e, t) {
+		return this.check(be(e, t == null ? void 0 : t.encoding), t);
+	}
+	async readTiffTag(e) {
+		var t = this;
+		let n = await t.tokenizer.readToken(e ? h : l);
+		switch (await t.tokenizer.ignore(10), n) {
+			case 50341: return {
+				ext: "arw",
+				mime: "image/x-sony-arw"
+			};
+			case 50706: return {
+				ext: "dng",
+				mime: "image/x-adobe-dng"
+			};
+			default:
+		}
+	}
+	async readTiffIFD(e) {
+		var t = this;
+		let n = await t.tokenizer.readToken(e ? h : l);
+		if (!(n > Ie) && !(G(t.tokenizer) && 2 + n * 12 > F)) for (let r = 0; r < n; ++r) {
+			let n = await t.readTiffTag(e);
+			if (n) return n;
+		}
+	}
+	async readTiffHeader(e) {
+		var t = this;
+		let n = {
+			ext: "tif",
+			mime: "image/tiff"
+		}, r = (e ? h : l).get(t.buffer, 2), i = (e ? a : m).get(t.buffer, 4);
+		if (r === 42) {
+			var o;
+			if (i >= 6) {
+				if (t.checkString("CR", { offset: 8 })) return {
+					ext: "cr2",
+					mime: "image/x-canon-cr2"
+				};
+				if (i >= 8) {
+					let n = (e ? h : l).get(t.buffer, 8), r = (e ? h : l).get(t.buffer, 10);
+					if (n === 28 && r === 254 || n === 31 && r === 11) return {
+						ext: "nef",
+						mime: "image/x-nikon-nef"
+					};
+				}
+			}
+			if (G(t.tokenizer) && i > Le) return n;
+			let r = G(t.tokenizer) ? F : t.tokenizer.fileInfo.size;
+			try {
+				await R(t.tokenizer, i, {
+					maximumLength: r,
+					reason: "TIFF IFD offset"
+				});
+			} catch (e) {
+				if (e instanceof g) return;
+				throw e;
+			}
+			let a;
+			try {
+				a = await t.readTiffIFD(e);
+			} catch (e) {
+				if (e instanceof g) return;
+				throw e;
+			}
+			return (o = a) == null ? n : o;
+		}
+		if (r === 43) return n;
+	}
+	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"
+			};
+			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(Ce), new Set(we);
+//#endregion
+//#region node_modules/media-typer/dist/index.js
+var lt = /* @__PURE__ */ e((/* @__PURE__ */ t(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.parse = n;
+	var t = /* @__PURE__ */ (() => {
+		let e = function() {};
+		return e.prototype = Object.create(null), e;
+	})();
+	function n(e, n) {
+		let r = e.length, i = d(e, 0, r), a = i;
+		i = u(e, i, r);
+		let o = f(e, a, i);
+		return {
+			type: e.slice(a, o).toLowerCase(),
+			parameters: (n == null ? void 0 : n.parameters) === !1 ? new t() : l(e, i, r)
+		};
+	}
+	var r = 32, i = 9, a = 59, o = 61, s = 34, c = 92;
+	function l(e, n, r) {
+		let i = new t();
+		parameter: for (; n < r;) {
+			n = d(e, n + 1, r);
+			let t = n;
+			for (; n < r;) {
+				let l = e.charCodeAt(n);
+				if (l === a) continue parameter;
+				if (l === o) {
+					let a = f(e, t, n), o = e.slice(t, a).toLowerCase();
+					if (n = d(e, n + 1, r), n < r && e.charCodeAt(n) === s) {
+						n++;
+						let t = "";
+						for (; n < r;) {
+							let a = e.charCodeAt(n++);
+							if (a === s) {
+								n = u(e, n, r), i[o] === void 0 && (i[o] = t);
+								break;
+							}
+							if (a === c && n < r) {
+								t += e[n++];
+								continue;
+							}
+							t += String.fromCharCode(a);
+						}
+						continue parameter;
+					}
+					let l = n;
+					if (n = u(e, n, r), i[o] === void 0) {
+						let t = f(e, l, n);
+						i[o] = e.slice(l, t);
+					}
+					continue parameter;
+				}
+				n++;
+			}
+		}
+		return i;
+	}
+	function u(e, t, n) {
+		for (; t < n && e.charCodeAt(t) !== a;) t++;
+		return t;
+	}
+	function d(e, t, n) {
+		for (; t < n;) {
+			let n = e.charCodeAt(t);
+			if (n !== r && n !== i) break;
+			t++;
+		}
+		return t;
+	}
+	function f(e, t, n) {
+		for (; n > t;) {
+			let t = e.charCodeAt(n - 1);
+			if (t !== r && t !== i) break;
+			n--;
+		}
+		return n;
+	}
+})))(), 1), ut = /^[A-Za-z0-9][A-Za-z0-9!#$&^_-]{0,126}\/[A-Za-z0-9][A-Za-z0-9!#$&^_.+-]{0,126}$/;
+function dt(e) {
+	if (!ut.test(e)) throw TypeError(`Invalid media type: ${e}`);
+	let t = e.indexOf("/"), n = e.slice(0, t).toLowerCase(), r = e.slice(t + 1).toLowerCase(), i, a = r.lastIndexOf("+");
+	return a !== -1 && (i = r.slice(a + 1), r = r.slice(0, a)), {
+		type: n,
+		subtype: r,
+		suffix: i
+	};
+}
+//#endregion
+//#region node_modules/music-metadata/lib/common/GenericTagTypes.js
+var q = { multiple: !1 }, J = {
+	year: q,
+	track: q,
+	disk: q,
+	title: q,
+	artist: q,
+	artists: {
+		multiple: !0,
+		unique: !0
+	},
+	albumartist: q,
+	albumartists: {
+		multiple: !0,
+		unique: !0
+	},
+	album: q,
+	date: q,
+	originaldate: q,
+	originalyear: q,
+	releasedate: q,
+	comment: {
+		multiple: !0,
+		unique: !1
+	},
+	genre: {
+		multiple: !0,
+		unique: !0
+	},
+	picture: {
+		multiple: !0,
+		unique: !0
+	},
+	composer: {
+		multiple: !0,
+		unique: !0
+	},
+	lyrics: {
+		multiple: !0,
+		unique: !1
+	},
+	albumsort: {
+		multiple: !1,
+		unique: !0
+	},
+	titlesort: {
+		multiple: !1,
+		unique: !0
+	},
+	work: {
+		multiple: !1,
+		unique: !0
+	},
+	artistsort: {
+		multiple: !1,
+		unique: !0
+	},
+	albumartistsort: {
+		multiple: !1,
+		unique: !0
+	},
+	composersort: {
+		multiple: !1,
+		unique: !0
+	},
+	lyricist: {
+		multiple: !0,
+		unique: !0
+	},
+	writer: {
+		multiple: !0,
+		unique: !0
+	},
+	conductor: {
+		multiple: !0,
+		unique: !0
+	},
+	remixer: {
+		multiple: !0,
+		unique: !0
+	},
+	arranger: {
+		multiple: !0,
+		unique: !0
+	},
+	engineer: {
+		multiple: !0,
+		unique: !0
+	},
+	producer: {
+		multiple: !0,
+		unique: !0
+	},
+	technician: {
+		multiple: !0,
+		unique: !0
+	},
+	djmixer: {
+		multiple: !0,
+		unique: !0
+	},
+	mixer: {
+		multiple: !0,
+		unique: !0
+	},
+	label: {
+		multiple: !0,
+		unique: !0
+	},
+	grouping: q,
+	subtitle: { multiple: !0 },
+	discsubtitle: q,
+	totaltracks: q,
+	totaldiscs: q,
+	compilation: q,
+	rating: { multiple: !0 },
+	bpm: q,
+	mood: q,
+	media: q,
+	catalognumber: {
+		multiple: !0,
+		unique: !0
+	},
+	tvShow: q,
+	tvShowSort: q,
+	tvSeason: q,
+	tvEpisode: q,
+	tvEpisodeId: q,
+	tvNetwork: q,
+	podcast: q,
+	podcasturl: q,
+	releasestatus: q,
+	releasetype: { multiple: !0 },
+	releasecountry: q,
+	script: q,
+	language: q,
+	copyright: q,
+	license: q,
+	encodedby: q,
+	encodersettings: q,
+	gapless: q,
+	barcode: q,
+	isrc: { multiple: !0 },
+	asin: q,
+	musicbrainz_recordingid: q,
+	musicbrainz_trackid: q,
+	musicbrainz_albumid: q,
+	musicbrainz_artistid: { multiple: !0 },
+	musicbrainz_albumartistid: { multiple: !0 },
+	musicbrainz_releasegroupid: q,
+	musicbrainz_workid: q,
+	musicbrainz_trmid: q,
+	musicbrainz_discid: q,
+	acoustid_id: q,
+	acoustid_fingerprint: q,
+	musicip_puid: q,
+	musicip_fingerprint: q,
+	website: q,
+	"performer:instrument": {
+		multiple: !0,
+		unique: !0
+	},
+	averageLevel: q,
+	peakLevel: q,
+	notes: {
+		multiple: !0,
+		unique: !1
+	},
+	key: q,
+	originalalbum: q,
+	originalartist: q,
+	discogs_artist_id: {
+		multiple: !0,
+		unique: !0
+	},
+	discogs_release_id: q,
+	discogs_label_id: q,
+	discogs_master_release_id: q,
+	discogs_votes: q,
+	discogs_rating: q,
+	replaygain_track_peak: q,
+	replaygain_track_gain: q,
+	replaygain_album_peak: q,
+	replaygain_album_gain: q,
+	replaygain_track_minmax: q,
+	replaygain_album_minmax: q,
+	replaygain_undo: q,
+	description: { multiple: !0 },
+	longDescription: q,
+	category: { multiple: !0 },
+	hdVideo: q,
+	keywords: { multiple: !0 },
+	movement: q,
+	movementIndex: q,
+	movementTotal: q,
+	podcastId: q,
+	showMovement: q,
+	stik: q,
+	playCounter: q
+};
+function ft(e) {
+	return J[e] && !J[e].multiple;
+}
+function pt(e) {
+	return !J[e].multiple || J[e].unique || !1;
+}
+//#endregion
+//#region node_modules/music-metadata/lib/common/GenericTagMapper.js
+var Y = class {
+	static toIntOrNull(e) {
+		let t = Number.parseInt(e, 10);
+		return Number.isNaN(t) ? null : t;
+	}
+	static normalizeTrack(e) {
+		let t = e.toString().split("/");
+		return {
+			no: Number.parseInt(t[0], 10) || null,
+			of: Number.parseInt(t[1], 10) || null
+		};
+	}
+	constructor(e, t) {
+		this.tagTypes = e, this.tagMap = t;
+	}
+	mapGenericTag(e, t) {
+		e = {
+			id: e.id,
+			value: e.value
+		}, this.postMap(e, t);
+		let n = this.getCommonName(e.id);
+		return n ? {
+			id: n,
+			value: e.value
+		} : null;
+	}
+	getCommonName(e) {
+		return this.tagMap[e];
+	}
+	postMap(e, t) {}
+};
+Y.maxRatingScore = 1;
+//#endregion
+//#region node_modules/music-metadata/lib/id3v1/ID3v1TagMap.js
+var mt = {
+	title: "title",
+	artist: "artist",
+	album: "album",
+	year: "year",
+	comment: "comment",
+	track: "track",
+	genre: "genre"
+}, ht = class extends Y {
+	constructor() {
+		super(["ID3v1"], mt);
+	}
+}, X = class extends Y {
+	constructor(e, t) {
+		let n = {};
+		for (let e of Object.keys(t)) n[e.toUpperCase()] = t[e];
+		super(e, n);
+	}
+	getCommonName(e) {
+		return this.tagMap[e.toUpperCase()];
+	}
+}, gt = {
+	TIT2: "title",
+	TPE1: "artist",
+	"TXXX:Artists": "artists",
+	TPE2: "albumartist",
+	TALB: "album",
+	TDRV: "date",
+	TORY: "originalyear",
+	TPOS: "disk",
+	TCON: "genre",
+	APIC: "picture",
+	TCOM: "composer",
+	USLT: "lyrics",
+	TSOA: "albumsort",
+	TSOT: "titlesort",
+	TOAL: "originalalbum",
+	TSOP: "artistsort",
+	TSO2: "albumartistsort",
+	TSOC: "composersort",
+	TEXT: "lyricist",
+	"TXXX:Writer": "writer",
+	TPE3: "conductor",
+	TPE4: "remixer",
+	"IPLS:arranger": "arranger",
+	"IPLS:engineer": "engineer",
+	"IPLS:producer": "producer",
+	"IPLS:DJ-mix": "djmixer",
+	"IPLS:mix": "mixer",
+	TPUB: "label",
+	TIT1: "grouping",
+	TIT3: "subtitle",
+	TRCK: "track",
+	TCMP: "compilation",
+	POPM: "rating",
+	TBPM: "bpm",
+	TMED: "media",
+	"TXXX:CATALOGNUMBER": "catalognumber",
+	"TXXX:MusicBrainz Album Status": "releasestatus",
+	"TXXX:MusicBrainz Album Type": "releasetype",
+	"TXXX:MusicBrainz Album Release Country": "releasecountry",
+	"TXXX:RELEASECOUNTRY": "releasecountry",
+	"TXXX:SCRIPT": "script",
+	TLAN: "language",
+	TCOP: "copyright",
+	WCOP: "license",
+	TENC: "encodedby",
+	TSSE: "encodersettings",
+	"TXXX:BARCODE": "barcode",
+	"TXXX:ISRC": "isrc",
+	TSRC: "isrc",
+	"TXXX:ASIN": "asin",
+	"TXXX:originalyear": "originalyear",
+	"UFID:http://musicbrainz.org": "musicbrainz_recordingid",
+	"TXXX:MusicBrainz Release Track Id": "musicbrainz_trackid",
+	"TXXX:MusicBrainz Album Id": "musicbrainz_albumid",
+	"TXXX:MusicBrainz Artist Id": "musicbrainz_artistid",
+	"TXXX:MusicBrainz Album Artist Id": "musicbrainz_albumartistid",
+	"TXXX:MusicBrainz Release Group Id": "musicbrainz_releasegroupid",
+	"TXXX:MusicBrainz Work Id": "musicbrainz_workid",
+	"TXXX:MusicBrainz TRM Id": "musicbrainz_trmid",
+	"TXXX:MusicBrainz Disc Id": "musicbrainz_discid",
+	"TXXX:ACOUSTID_ID": "acoustid_id",
+	"TXXX:Acoustid Id": "acoustid_id",
+	"TXXX:Acoustid Fingerprint": "acoustid_fingerprint",
+	"TXXX:MusicIP PUID": "musicip_puid",
+	"TXXX:MusicMagic Fingerprint": "musicip_fingerprint",
+	WOAR: "website",
+	TDRC: "date",
+	TYER: "year",
+	TDOR: "originaldate",
+	"TIPL:arranger": "arranger",
+	"TIPL:engineer": "engineer",
+	"TIPL:producer": "producer",
+	"TIPL:DJ-mix": "djmixer",
+	"TIPL:mix": "mixer",
+	TMOO: "mood",
+	SYLT: "lyrics",
+	TSST: "discsubtitle",
+	TKEY: "key",
+	COMM: "comment",
+	TOPE: "originalartist",
+	"PRIV:AverageLevel": "averageLevel",
+	"PRIV:PeakLevel": "peakLevel",
+	"TXXX:DISCOGS_ARTIST_ID": "discogs_artist_id",
+	"TXXX:DISCOGS_ARTISTS": "artists",
+	"TXXX:DISCOGS_ARTIST_NAME": "artists",
+	"TXXX:DISCOGS_ALBUM_ARTISTS": "albumartist",
+	"TXXX:DISCOGS_CATALOG": "catalognumber",
+	"TXXX:DISCOGS_COUNTRY": "releasecountry",
+	"TXXX:DISCOGS_DATE": "originaldate",
+	"TXXX:DISCOGS_LABEL": "label",
+	"TXXX:DISCOGS_LABEL_ID": "discogs_label_id",
+	"TXXX:DISCOGS_MASTER_RELEASE_ID": "discogs_master_release_id",
+	"TXXX:DISCOGS_RATING": "discogs_rating",
+	"TXXX:DISCOGS_RELEASED": "date",
+	"TXXX:DISCOGS_RELEASE_ID": "discogs_release_id",
+	"TXXX:DISCOGS_VOTES": "discogs_votes",
+	"TXXX:CATALOGID": "catalognumber",
+	"TXXX:STYLE": "genre",
+	"TXXX:REPLAYGAIN_TRACK_PEAK": "replaygain_track_peak",
+	"TXXX:REPLAYGAIN_TRACK_GAIN": "replaygain_track_gain",
+	"TXXX:REPLAYGAIN_ALBUM_PEAK": "replaygain_album_peak",
+	"TXXX:REPLAYGAIN_ALBUM_GAIN": "replaygain_album_gain",
+	"TXXX:MP3GAIN_MINMAX": "replaygain_track_minmax",
+	"TXXX:MP3GAIN_ALBUM_MINMAX": "replaygain_album_minmax",
+	"TXXX:MP3GAIN_UNDO": "replaygain_undo",
+	MVNM: "movement",
+	MVIN: "movementIndex",
+	PCST: "podcast",
+	TCAT: "category",
+	TDES: "description",
+	TDRL: "releasedate",
+	TGID: "podcastId",
+	TKWD: "keywords",
+	WFED: "podcasturl",
+	GRP1: "grouping",
+	PCNT: "playCounter"
+}, _t = class e extends X {
+	static toRating(e) {
+		return {
+			source: e.email,
+			rating: e.rating > 0 ? (e.rating - 1) / 254 * Y.maxRatingScore : void 0
+		};
+	}
+	constructor() {
+		super(["ID3v2.3", "ID3v2.4"], gt);
+	}
+	postMap(t, n) {
+		switch (t.id) {
+			case "UFID":
+				{
+					let e = t.value;
+					e.owner_identifier === "http://musicbrainz.org" && (t.id += `:${e.owner_identifier}`, t.value = ae(e.identifier, "latin1"));
+				}
+				break;
+			case "PRIV":
+				{
+					let e = t.value;
+					switch (e.owner_identifier) {
+						case "AverageLevel":
+						case "PeakValue":
+							t.id += `:${e.owner_identifier}`, t.value = e.data.length === 4 ? m.get(e.data, 0) : null, t.value === null && n.addWarning("Failed to parse PRIV:PeakValue");
+							break;
+						default: n.addWarning(`Unknown PRIV owner-identifier: ${e.data}`);
+					}
+				}
+				break;
+			case "POPM":
+				t.value = e.toRating(t.value);
+				break;
+			default: break;
+		}
+	}
+}, vt = {
+	Title: "title",
+	Author: "artist",
+	"WM/AlbumArtist": "albumartist",
+	"WM/AlbumTitle": "album",
+	"WM/Year": "date",
+	"WM/OriginalReleaseTime": "originaldate",
+	"WM/OriginalReleaseYear": "originalyear",
+	Description: "comment",
+	"WM/TrackNumber": "track",
+	"WM/PartOfSet": "disk",
+	"WM/Genre": "genre",
+	"WM/Composer": "composer",
+	"WM/Lyrics": "lyrics",
+	"WM/AlbumSortOrder": "albumsort",
+	"WM/TitleSortOrder": "titlesort",
+	"WM/ArtistSortOrder": "artistsort",
+	"WM/AlbumArtistSortOrder": "albumartistsort",
+	"WM/ComposerSortOrder": "composersort",
+	"WM/Writer": "lyricist",
+	"WM/Conductor": "conductor",
+	"WM/ModifiedBy": "remixer",
+	"WM/Engineer": "engineer",
+	"WM/Producer": "producer",
+	"WM/DJMixer": "djmixer",
+	"WM/Mixer": "mixer",
+	"WM/Publisher": "label",
+	"WM/ContentGroupDescription": "grouping",
+	"WM/SubTitle": "subtitle",
+	"WM/SetSubTitle": "discsubtitle",
+	"WM/IsCompilation": "compilation",
+	"WM/SharedUserRating": "rating",
+	"WM/BeatsPerMinute": "bpm",
+	"WM/Mood": "mood",
+	"WM/Media": "media",
+	"WM/CatalogNo": "catalognumber",
+	"MusicBrainz/Album Status": "releasestatus",
+	"MusicBrainz/Album Type": "releasetype",
+	"MusicBrainz/Album Release Country": "releasecountry",
+	"WM/Script": "script",
+	"WM/Language": "language",
+	Copyright: "copyright",
+	LICENSE: "license",
+	"WM/EncodedBy": "encodedby",
+	"WM/EncodingSettings": "encodersettings",
+	"WM/Barcode": "barcode",
+	"WM/ISRC": "isrc",
+	"MusicBrainz/Track Id": "musicbrainz_recordingid",
+	"MusicBrainz/Release Track Id": "musicbrainz_trackid",
+	"MusicBrainz/Album Id": "musicbrainz_albumid",
+	"MusicBrainz/Artist Id": "musicbrainz_artistid",
+	"MusicBrainz/Album Artist Id": "musicbrainz_albumartistid",
+	"MusicBrainz/Release Group Id": "musicbrainz_releasegroupid",
+	"MusicBrainz/Work Id": "musicbrainz_workid",
+	"MusicBrainz/TRM Id": "musicbrainz_trmid",
+	"MusicBrainz/Disc Id": "musicbrainz_discid",
+	"Acoustid/Id": "acoustid_id",
+	"Acoustid/Fingerprint": "acoustid_fingerprint",
+	"MusicIP/PUID": "musicip_puid",
+	"WM/ARTISTS": "artists",
+	"WM/InitialKey": "key",
+	ASIN: "asin",
+	"WM/Work": "work",
+	"WM/AuthorURL": "website",
+	"WM/Picture": "picture"
+}, yt = class e extends Y {
+	static toRating(e) {
+		return { rating: Number.parseFloat(e + 1) / 5 };
+	}
+	constructor() {
+		super(["asf"], vt);
+	}
+	postMap(t) {
+		switch (t.id) {
+			case "WM/SharedUserRating": {
+				let n = t.id.split(":");
+				t.value = e.toRating(t.value), t.id = n[0];
+				break;
+			}
+		}
+	}
+}, bt = {
+	TT2: "title",
+	TP1: "artist",
+	TP2: "albumartist",
+	TAL: "album",
+	TYE: "year",
+	COM: "comment",
+	TRK: "track",
+	TPA: "disk",
+	TCO: "genre",
+	PIC: "picture",
+	TCM: "composer",
+	TOR: "originaldate",
+	TOT: "originalalbum",
+	TXT: "lyricist",
+	TP3: "conductor",
+	TPB: "label",
+	TT1: "grouping",
+	TT3: "subtitle",
+	TLA: "language",
+	TCR: "copyright",
+	WCP: "license",
+	TEN: "encodedby",
+	TSS: "encodersettings",
+	WAR: "website",
+	PCS: "podcast",
+	TCP: "compilation",
+	TDR: "date",
+	TS2: "albumartistsort",
+	TSA: "albumsort",
+	TSC: "composersort",
+	TSP: "artistsort",
+	TST: "titlesort",
+	WFD: "podcasturl",
+	TBP: "bpm",
+	GP1: "grouping"
+}, xt = class extends X {
+	constructor() {
+		super(["ID3v2.2"], bt);
+	}
+}, St = {
+	Title: "title",
+	Artist: "artist",
+	Artists: "artists",
+	"Album Artist": "albumartist",
+	Album: "album",
+	Year: "date",
+	Originalyear: "originalyear",
+	Originaldate: "originaldate",
+	Releasedate: "releasedate",
+	Comment: "comment",
+	Track: "track",
+	Disc: "disk",
+	DISCNUMBER: "disk",
+	Genre: "genre",
+	"Cover Art (Front)": "picture",
+	"Cover Art (Back)": "picture",
+	Composer: "composer",
+	Lyrics: "lyrics",
+	ALBUMSORT: "albumsort",
+	TITLESORT: "titlesort",
+	WORK: "work",
+	ARTISTSORT: "artistsort",
+	ALBUMARTISTSORT: "albumartistsort",
+	COMPOSERSORT: "composersort",
+	Lyricist: "lyricist",
+	Writer: "writer",
+	Conductor: "conductor",
+	MixArtist: "remixer",
+	Arranger: "arranger",
+	Engineer: "engineer",
+	Producer: "producer",
+	DJMixer: "djmixer",
+	Mixer: "mixer",
+	Label: "label",
+	Grouping: "grouping",
+	Subtitle: "subtitle",
+	DiscSubtitle: "discsubtitle",
+	Compilation: "compilation",
+	BPM: "bpm",
+	Mood: "mood",
+	Media: "media",
+	CatalogNumber: "catalognumber",
+	MUSICBRAINZ_ALBUMSTATUS: "releasestatus",
+	MUSICBRAINZ_ALBUMTYPE: "releasetype",
+	RELEASECOUNTRY: "releasecountry",
+	Script: "script",
+	Language: "language",
+	Copyright: "copyright",
+	LICENSE: "license",
+	EncodedBy: "encodedby",
+	EncoderSettings: "encodersettings",
+	Barcode: "barcode",
+	ISRC: "isrc",
+	ASIN: "asin",
+	musicbrainz_trackid: "musicbrainz_recordingid",
+	musicbrainz_releasetrackid: "musicbrainz_trackid",
+	MUSICBRAINZ_ALBUMID: "musicbrainz_albumid",
+	MUSICBRAINZ_ARTISTID: "musicbrainz_artistid",
+	MUSICBRAINZ_ALBUMARTISTID: "musicbrainz_albumartistid",
+	MUSICBRAINZ_RELEASEGROUPID: "musicbrainz_releasegroupid",
+	MUSICBRAINZ_WORKID: "musicbrainz_workid",
+	MUSICBRAINZ_TRMID: "musicbrainz_trmid",
+	MUSICBRAINZ_DISCID: "musicbrainz_discid",
+	Acoustid_Id: "acoustid_id",
+	ACOUSTID_FINGERPRINT: "acoustid_fingerprint",
+	MUSICIP_PUID: "musicip_puid",
+	Weblink: "website",
+	REPLAYGAIN_TRACK_GAIN: "replaygain_track_gain",
+	REPLAYGAIN_TRACK_PEAK: "replaygain_track_peak",
+	MP3GAIN_MINMAX: "replaygain_track_minmax",
+	MP3GAIN_UNDO: "replaygain_undo"
+}, Ct = class extends X {
+	constructor() {
+		super(["APEv2"], St);
+	}
+}, wt = {
+	"©nam": "title",
+	"©ART": "artist",
+	aART: "albumartist",
+	"----:com.apple.iTunes:Band": "albumartist",
+	"©alb": "album",
+	"©day": "date",
+	"©cmt": "comment",
+	"©com": "comment",
+	trkn: "track",
+	disk: "disk",
+	"©gen": "genre",
+	covr: "picture",
+	"©wrt": "composer",
+	"©lyr": "lyrics",
+	soal: "albumsort",
+	sonm: "titlesort",
+	soar: "artistsort",
+	soaa: "albumartistsort",
+	soco: "composersort",
+	"----:com.apple.iTunes:LYRICIST": "lyricist",
+	"----:com.apple.iTunes:CONDUCTOR": "conductor",
+	"----:com.apple.iTunes:REMIXER": "remixer",
+	"----:com.apple.iTunes:ENGINEER": "engineer",
+	"----:com.apple.iTunes:PRODUCER": "producer",
+	"----:com.apple.iTunes:DJMIXER": "djmixer",
+	"----:com.apple.iTunes:MIXER": "mixer",
+	"----:com.apple.iTunes:LABEL": "label",
+	"©grp": "grouping",
+	"----:com.apple.iTunes:SUBTITLE": "subtitle",
+	"----:com.apple.iTunes:DISCSUBTITLE": "discsubtitle",
+	cpil: "compilation",
+	tmpo: "bpm",
+	"----:com.apple.iTunes:MOOD": "mood",
+	"----:com.apple.iTunes:MEDIA": "media",
+	"----:com.apple.iTunes:CATALOGNUMBER": "catalognumber",
+	tvsh: "tvShow",
+	tvsn: "tvSeason",
+	tves: "tvEpisode",
+	sosn: "tvShowSort",
+	tven: "tvEpisodeId",
+	tvnn: "tvNetwork",
+	pcst: "podcast",
+	purl: "podcasturl",
+	"----:com.apple.iTunes:MusicBrainz Album Status": "releasestatus",
+	"----:com.apple.iTunes:MusicBrainz Album Type": "releasetype",
+	"----:com.apple.iTunes:MusicBrainz Album Release Country": "releasecountry",
+	"----:com.apple.iTunes:SCRIPT": "script",
+	"----:com.apple.iTunes:LANGUAGE": "language",
+	cprt: "copyright",
+	"©cpy": "copyright",
+	"----:com.apple.iTunes:LICENSE": "license",
+	"©too": "encodedby",
+	pgap: "gapless",
+	"----:com.apple.iTunes:BARCODE": "barcode",
+	"----:com.apple.iTunes:ISRC": "isrc",
+	"----:com.apple.iTunes:ASIN": "asin",
+	"----:com.apple.iTunes:NOTES": "comment",
+	"----:com.apple.iTunes:MusicBrainz Track Id": "musicbrainz_recordingid",
+	"----:com.apple.iTunes:MusicBrainz Release Track Id": "musicbrainz_trackid",
+	"----:com.apple.iTunes:MusicBrainz Album Id": "musicbrainz_albumid",
+	"----:com.apple.iTunes:MusicBrainz Artist Id": "musicbrainz_artistid",
+	"----:com.apple.iTunes:MusicBrainz Album Artist Id": "musicbrainz_albumartistid",
+	"----:com.apple.iTunes:MusicBrainz Release Group Id": "musicbrainz_releasegroupid",
+	"----:com.apple.iTunes:MusicBrainz Work Id": "musicbrainz_workid",
+	"----:com.apple.iTunes:MusicBrainz TRM Id": "musicbrainz_trmid",
+	"----:com.apple.iTunes:MusicBrainz Disc Id": "musicbrainz_discid",
+	"----:com.apple.iTunes:Acoustid Id": "acoustid_id",
+	"----:com.apple.iTunes:Acoustid Fingerprint": "acoustid_fingerprint",
+	"----:com.apple.iTunes:MusicIP PUID": "musicip_puid",
+	"----:com.apple.iTunes:fingerprint": "musicip_fingerprint",
+	"----:com.apple.iTunes:replaygain_track_gain": "replaygain_track_gain",
+	"----:com.apple.iTunes:replaygain_track_peak": "replaygain_track_peak",
+	"----:com.apple.iTunes:replaygain_album_gain": "replaygain_album_gain",
+	"----:com.apple.iTunes:replaygain_album_peak": "replaygain_album_peak",
+	"----:com.apple.iTunes:replaygain_track_minmax": "replaygain_track_minmax",
+	"----:com.apple.iTunes:replaygain_album_minmax": "replaygain_album_minmax",
+	"----:com.apple.iTunes:replaygain_undo": "replaygain_undo",
+	gnre: "genre",
+	"----:com.apple.iTunes:ALBUMARTISTSORT": "albumartistsort",
+	"----:com.apple.iTunes:ARTISTS": "artists",
+	"----:com.apple.iTunes:ORIGINALDATE": "originaldate",
+	"----:com.apple.iTunes:ORIGINALYEAR": "originalyear",
+	"----:com.apple.iTunes:RELEASEDATE": "releasedate",
+	desc: "description",
+	ldes: "longDescription",
+	"©mvn": "movement",
+	"©mvi": "movementIndex",
+	"©mvc": "movementTotal",
+	"©wrk": "work",
+	catg: "category",
+	egid: "podcastId",
+	hdvd: "hdVideo",
+	keyw: "keywords",
+	shwm: "showMovement",
+	stik: "stik",
+	rate: "rating"
+}, Tt = "iTunes", Et = class extends X {
+	constructor() {
+		super([Tt], wt);
+	}
+	postMap(e, t) {
+		switch (e.id) {
+			case "rate":
+				e.value = {
+					source: void 0,
+					rating: Number.parseFloat(e.value) / 100
+				};
+				break;
+		}
+	}
+}, Dt = {
+	TITLE: "title",
+	ARTIST: "artist",
+	ARTISTS: "artists",
+	ALBUMARTIST: "albumartist",
+	"ALBUM ARTIST": "albumartist",
+	ALBUM: "album",
+	DATE: "date",
+	ORIGINALDATE: "originaldate",
+	ORIGINALYEAR: "originalyear",
+	RELEASEDATE: "releasedate",
+	COMMENT: "comment",
+	TRACKNUMBER: "track",
+	DISCNUMBER: "disk",
+	GENRE: "genre",
+	METADATA_BLOCK_PICTURE: "picture",
+	COMPOSER: "composer",
+	LYRICS: "lyrics",
+	ALBUMSORT: "albumsort",
+	TITLESORT: "titlesort",
+	WORK: "work",
+	ARTISTSORT: "artistsort",
+	ALBUMARTISTSORT: "albumartistsort",
+	COMPOSERSORT: "composersort",
+	LYRICIST: "lyricist",
+	WRITER: "writer",
+	CONDUCTOR: "conductor",
+	REMIXER: "remixer",
+	ARRANGER: "arranger",
+	ENGINEER: "engineer",
+	PRODUCER: "producer",
+	DJMIXER: "djmixer",
+	MIXER: "mixer",
+	LABEL: "label",
+	GROUPING: "grouping",
+	SUBTITLE: "subtitle",
+	DISCSUBTITLE: "discsubtitle",
+	TRACKTOTAL: "totaltracks",
+	DISCTOTAL: "totaldiscs",
+	COMPILATION: "compilation",
+	RATING: "rating",
+	BPM: "bpm",
+	KEY: "key",
+	MOOD: "mood",
+	MEDIA: "media",
+	CATALOGNUMBER: "catalognumber",
+	RELEASESTATUS: "releasestatus",
+	RELEASETYPE: "releasetype",
+	RELEASECOUNTRY: "releasecountry",
+	SCRIPT: "script",
+	LANGUAGE: "language",
+	COPYRIGHT: "copyright",
+	LICENSE: "license",
+	ENCODEDBY: "encodedby",
+	ENCODERSETTINGS: "encodersettings",
+	BARCODE: "barcode",
+	ISRC: "isrc",
+	ASIN: "asin",
+	MUSICBRAINZ_TRACKID: "musicbrainz_recordingid",
+	MUSICBRAINZ_RELEASETRACKID: "musicbrainz_trackid",
+	MUSICBRAINZ_ALBUMID: "musicbrainz_albumid",
+	MUSICBRAINZ_ARTISTID: "musicbrainz_artistid",
+	MUSICBRAINZ_ALBUMARTISTID: "musicbrainz_albumartistid",
+	MUSICBRAINZ_RELEASEGROUPID: "musicbrainz_releasegroupid",
+	MUSICBRAINZ_WORKID: "musicbrainz_workid",
+	MUSICBRAINZ_TRMID: "musicbrainz_trmid",
+	MUSICBRAINZ_DISCID: "musicbrainz_discid",
+	ACOUSTID_ID: "acoustid_id",
+	ACOUSTID_ID_FINGERPRINT: "acoustid_fingerprint",
+	MUSICIP_PUID: "musicip_puid",
+	WEBSITE: "website",
+	NOTES: "notes",
+	TOTALTRACKS: "totaltracks",
+	TOTALDISCS: "totaldiscs",
+	DISCOGS_ARTIST_ID: "discogs_artist_id",
+	DISCOGS_ARTISTS: "artists",
+	DISCOGS_ARTIST_NAME: "artists",
+	DISCOGS_ALBUM_ARTISTS: "albumartist",
+	DISCOGS_CATALOG: "catalognumber",
+	DISCOGS_COUNTRY: "releasecountry",
+	DISCOGS_DATE: "originaldate",
+	DISCOGS_LABEL: "label",
+	DISCOGS_LABEL_ID: "discogs_label_id",
+	DISCOGS_MASTER_RELEASE_ID: "discogs_master_release_id",
+	DISCOGS_RATING: "discogs_rating",
+	DISCOGS_RELEASED: "date",
+	DISCOGS_RELEASE_ID: "discogs_release_id",
+	DISCOGS_VOTES: "discogs_votes",
+	CATALOGID: "catalognumber",
+	STYLE: "genre",
+	REPLAYGAIN_TRACK_GAIN: "replaygain_track_gain",
+	REPLAYGAIN_TRACK_PEAK: "replaygain_track_peak",
+	REPLAYGAIN_ALBUM_GAIN: "replaygain_album_gain",
+	REPLAYGAIN_ALBUM_PEAK: "replaygain_album_peak",
+	REPLAYGAIN_MINMAX: "replaygain_track_minmax",
+	REPLAYGAIN_ALBUM_MINMAX: "replaygain_album_minmax",
+	REPLAYGAIN_UNDO: "replaygain_undo"
+}, Ot = class e extends Y {
+	static toRating(e, t, n) {
+		return {
+			source: e ? e.toLowerCase() : void 0,
+			rating: Number.parseFloat(t) / n * Y.maxRatingScore
+		};
+	}
+	constructor() {
+		super(["vorbis"], Dt);
+	}
+	postMap(t) {
+		if (t.id === "RATING") t.value = e.toRating(void 0, t.value, 100);
+		else if (t.id.indexOf("RATING:") === 0) {
+			let n = t.id.split(":");
+			t.value = e.toRating(n[1], t.value, 1), t.id = n[0];
+		}
+	}
+}, kt = {
+	IART: "artist",
+	ICRD: "date",
+	INAM: "title",
+	TITL: "title",
+	IPRD: "album",
+	ITRK: "track",
+	IPRT: "track",
+	COMM: "comment",
+	ICMT: "comment",
+	ICNT: "releasecountry",
+	GNRE: "genre",
+	IWRI: "writer",
+	RATE: "rating",
+	YEAR: "year",
+	ISFT: "encodedby",
+	CODE: "encodedby",
+	TURL: "website",
+	IGNR: "genre",
+	IENG: "engineer",
+	ITCH: "technician",
+	IMED: "media",
+	IRPD: "album"
+}, At = class extends Y {
+	constructor() {
+		super(["exif"], kt);
+	}
+}, jt = {
+	"segment:title": "title",
+	"album:ARTIST": "albumartist",
+	"album:ARTISTSORT": "albumartistsort",
+	"album:TITLE": "album",
+	"album:DATE_RECORDED": "originaldate",
+	"album:DATE_RELEASED": "releasedate",
+	"album:PART_NUMBER": "disk",
+	"album:TOTAL_PARTS": "totaltracks",
+	"track:ARTIST": "artist",
+	"track:ARTISTSORT": "artistsort",
+	"track:TITLE": "title",
+	"track:PART_NUMBER": "track",
+	"track:MUSICBRAINZ_TRACKID": "musicbrainz_recordingid",
+	"track:MUSICBRAINZ_ALBUMID": "musicbrainz_albumid",
+	"track:MUSICBRAINZ_ARTISTID": "musicbrainz_artistid",
+	"track:PUBLISHER": "label",
+	"track:GENRE": "genre",
+	"track:ENCODER": "encodedby",
+	"track:ENCODER_OPTIONS": "encodersettings",
+	"edition:TOTAL_PARTS": "totaldiscs",
+	picture: "picture"
+}, Mt = class extends X {
+	constructor() {
+		super(["matroska"], jt);
+	}
+}, Nt = {
+	NAME: "title",
+	AUTH: "artist",
+	"(c) ": "copyright",
+	ANNO: "comment"
+}, Pt = class extends Y {
+	constructor() {
+		super(["AIFF"], Nt);
+	}
+}, Ft = class {
+	constructor() {
+		this.tagMappers = {}, [
+			new ht(),
+			new xt(),
+			new _t(),
+			new Et(),
+			new Et(),
+			new Ot(),
+			new Ct(),
+			new yt(),
+			new At(),
+			new Mt(),
+			new Pt()
+		].forEach((e) => {
+			this.registerTagMapper(e);
+		});
+	}
+	mapTag(e, t, n) {
+		if (this.tagMappers[e]) return this.tagMappers[e].mapGenericTag(t, n);
+		throw new d(`No generic tag mapper defined for tag-format: ${e}`);
+	}
+	registerTagMapper(e) {
+		for (let t of e.tagTypes) this.tagMappers[t] = e;
+	}
+}, Z = /\[(\d{2}):(\d{2})\.(\d{2,3})]/;
+function It(e) {
+	return Z.test(e) ? Rt(e) : Lt(e);
+}
+function Lt(e) {
+	return {
+		contentType: se.lyrics,
+		timeStampFormat: oe.notSynchronized,
+		text: e.trim(),
+		syncText: []
+	};
+}
+function Rt(e) {
+	let t = e.split("\n"), n = [];
+	for (let e of t) {
+		let t = e.match(Z);
+		if (t) {
+			let r = Number.parseInt(t[1], 10), i = Number.parseInt(t[2], 10), a = t[3].length === 3 ? Number.parseInt(t[3], 10) : Number.parseInt(t[3], 10) * 10, o = (r * 60 + i) * 1e3 + a, s = e.replace(Z, "").trim();
+			n.push({
+				timestamp: o,
+				text: s
+			});
+		}
+	}
+	return {
+		contentType: se.lyrics,
+		timeStampFormat: oe.milliseconds,
+		text: n.map((e) => e.text).join("\n"),
+		syncText: n
+	};
+}
+//#endregion
+//#region node_modules/music-metadata/lib/common/MetadataCollector.js
+var Q = (0, v.default)("music-metadata:collector"), zt = [
+	"matroska",
+	"APEv2",
+	"vorbis",
+	"ID3v2.4",
+	"ID3v2.3",
+	"ID3v2.2",
+	"exif",
+	"asf",
+	"iTunes",
+	"AIFF",
+	"ID3v1"
+], Bt = class {
+	constructor(e) {
+		this.format = {
+			tagTypes: [],
+			trackInfo: []
+		}, this.native = {}, this.common = {
+			track: {
+				no: null,
+				of: null
+			},
+			disk: {
+				no: null,
+				of: null
+			},
+			movementIndex: {
+				no: null,
+				of: null
+			}
+		}, this.quality = { warnings: [] }, this.commonOrigin = {}, this.originPriority = {}, this.tagMapper = new Ft(), this.opts = e;
+		let t = 1;
+		for (let e of zt) this.originPriority[e] = t++;
+		this.originPriority.artificial = 500, this.originPriority.id3v1 = 600;
+	}
+	hasAny() {
+		return Object.keys(this.native).length > 0;
+	}
+	addStreamInfo(e) {
+		Q(`streamInfo: type=${e.type ? de[e.type] : "?"}, codec=${e.codecName}`), this.format.trackInfo.push(e);
+	}
+	setFormat(e, t) {
+		var n;
+		Q(`format: ${e} = ${t}`), this.format[e] = t, (n = this.opts) != null && n.observer && this.opts.observer({
+			metadata: this,
+			tag: {
+				type: "format",
+				id: e,
+				value: t
+			}
+		});
+	}
+	setAudioOnly() {
+		this.setFormat("hasAudio", !0), this.setFormat("hasVideo", !1);
+	}
+	async addTag(e, t, n) {
+		var r = this;
+		Q(`tag ${e}.${t} = ${n}`), r.native[e] || (r.format.tagTypes.push(e), r.native[e] = []), r.native[e].push({
+			id: t,
+			value: n
+		}), await r.toCommon(e, t, n);
+	}
+	addWarning(e) {
+		this.quality.warnings.push({ message: e });
+	}
+	async postMap(e, t) {
+		var n = this;
+		switch (t.id) {
+			case "artist": return n.handleSingularArtistTag(e, t, "artist", "artists");
+			case "albumartist": return n.handleSingularArtistTag(e, t, "albumartist", "albumartists");
+			case "artists": return n.handlePluralArtistTag(e, t, "artist", "artists");
+			case "albumartists": return n.handlePluralArtistTag(e, t, "albumartist", "albumartists");
+			case "picture": return n.postFixPicture(t.value).then((r) => {
+				r !== null && (t.value = r, n.setGenericTag(e, t));
+			});
+			case "totaltracks":
+				n.common.track.of = Y.toIntOrNull(t.value);
+				return;
+			case "totaldiscs":
+				n.common.disk.of = Y.toIntOrNull(t.value);
+				return;
+			case "movementTotal":
+				n.common.movementIndex.of = Y.toIntOrNull(t.value);
+				return;
+			case "track":
+			case "disk":
+			case "movementIndex": {
+				let e = n.common[t.id].of;
+				n.common[t.id] = Y.normalizeTrack(t.value), n.common[t.id].of = e == null ? n.common[t.id].of : e;
+				return;
+			}
+			case "bpm":
+			case "year":
+			case "originalyear":
+				t.value = Number.parseInt(t.value, 10);
+				break;
+			case "date": {
+				let e = Number.parseInt(t.value.substr(0, 4), 10);
+				Number.isNaN(e) || (n.common.year = e);
+				break;
+			}
+			case "discogs_label_id":
+			case "discogs_release_id":
+			case "discogs_master_release_id":
+			case "discogs_artist_id":
+			case "discogs_votes":
+				t.value = typeof t.value == "string" ? Number.parseInt(t.value, 10) : t.value;
+				break;
+			case "replaygain_track_gain":
+			case "replaygain_track_peak":
+			case "replaygain_album_gain":
+			case "replaygain_album_peak":
+				t.value = ie(t.value);
+				break;
+			case "replaygain_track_minmax":
+				t.value = t.value.split(",").map((e) => Number.parseInt(e, 10));
+				break;
+			case "replaygain_undo": {
+				let e = t.value.split(",").map((e) => Number.parseInt(e, 10));
+				t.value = {
+					leftChannel: e[0],
+					rightChannel: e[1]
+				};
+				break;
+			}
+			case "gapless":
+			case "compilation":
+			case "podcast":
+			case "showMovement":
+				t.value = t.value === "1" || t.value === 1;
+				break;
+			case "isrc": {
+				let e = n.common[t.id];
+				if (e && e.indexOf(t.value) !== -1) return;
+				break;
+			}
+			case "comment":
+				typeof t.value == "string" && (t.value = { text: t.value }), t.value.descriptor === "iTunPGAP" && n.setGenericTag(e, {
+					id: "gapless",
+					value: t.value.text === "1"
+				});
+				break;
+			case "lyrics":
+				typeof t.value == "string" && (t.value = It(t.value));
+				break;
+			default:
+		}
+		t.value !== null && n.setGenericTag(e, t);
+	}
+	toCommonMetadata() {
+		return {
+			format: this.format,
+			native: this.native,
+			quality: this.quality,
+			common: this.common
+		};
+	}
+	handleSingularArtistTag(e, t, n, r) {
+		if (this.commonOrigin[n] === this.originPriority[e]) return this.postMap("artificial", {
+			id: r,
+			value: t.value
+		});
+		this.common[r] || this.setGenericTag("artificial", {
+			id: r,
+			value: t.value
+		}), this.setGenericTag(e, t);
+	}
+	handlePluralArtistTag(e, t, n, r) {
+		if ((!this.common[n] || this.commonOrigin[n] === this.originPriority.artificial) && (!this.common[r] || this.common[r].indexOf(t.value) === -1)) {
+			let e = Vt((this.common[r] || []).concat([t.value]));
+			this.setGenericTag("artificial", {
+				id: n,
+				value: e
+			});
+		}
+		this.setGenericTag(e, t);
+	}
+	async postFixPicture(e) {
+		var t = this;
+		if (e.data && e.data.length > 0) {
+			if (!e.format) {
+				let t = await H(Uint8Array.from(e.data));
+				if (t) e.format = t.mime;
+				else return null;
+			}
+			switch (e.format = e.format.toLocaleLowerCase(), e.format) {
+				case "image/jpg": e.format = "image/jpeg";
+			}
+			return e;
+		}
+		return t.addWarning("Empty picture tag found"), null;
+	}
+	async toCommon(e, t, n) {
+		var r = this;
+		let i = {
+			id: t,
+			value: n
+		}, a = r.tagMapper.mapTag(e, i, r);
+		a && await r.postMap(e, a);
+	}
+	setGenericTag(e, t) {
+		var n;
+		Q(`common.${t.id} = ${t.value}`);
+		let r = this.commonOrigin[t.id] || 1e3, i = this.originPriority[e];
+		if (ft(t.id)) if (i <= r) this.common[t.id] = t.value, this.commonOrigin[t.id] = i;
+		else return Q(`Ignore native tag (singleton): ${e}.${t.id} = ${t.value}`);
+		else if (i === r) !pt(t.id) || this.common[t.id].indexOf(t.value) === -1 ? this.common[t.id].push(t.value) : Q(`Ignore duplicate value: ${e}.${t.id} = ${t.value}`);
+		else if (i < r) this.common[t.id] = [t.value], this.commonOrigin[t.id] = i;
+		else return Q(`Ignore native tag (list): ${e}.${t.id} = ${t.value}`);
+		(n = this.opts) != null && n.observer && this.opts.observer({
+			metadata: this,
+			tag: {
+				type: "common",
+				id: t.id,
+				value: t.value
+			}
+		});
+	}
+};
+function Vt(e) {
+	return e.length > 2 ? `${e.slice(0, e.length - 1).join(", ")} & ${e[e.length - 1]}` : e.join(" & ");
+}
+//#endregion
+//#region node_modules/music-metadata/lib/mpeg/MpegLoader.js
+var Ht = {
+	parserType: "mpeg",
+	extensions: [
+		".mp2",
+		".mp3",
+		".m2a",
+		".aac",
+		"aacp"
+	],
+	mimeTypes: [
+		"audio/mpeg",
+		"audio/mp3",
+		"audio/aacs",
+		"audio/aacp"
+	],
+	async load() {
+		return (await import("./MpegParser-R-6QiuhU.mjs")).MpegParser;
+	}
+}, Ut = {
+	parserType: "apev2",
+	extensions: [".ape"],
+	mimeTypes: ["audio/ape", "audio/monkeys-audio"],
+	async load() {
+		return (await import("./APEv2Parser-WvRvu4zL.mjs").then((e) => e.n)).APEv2Parser;
+	}
+}, Wt = {
+	parserType: "asf",
+	extensions: [
+		".asf",
+		".wma",
+		".wmv"
+	],
+	mimeTypes: [
+		"audio/ms-wma",
+		"video/ms-wmv",
+		"audio/ms-asf",
+		"video/ms-asf",
+		"application/vnd.ms-asf"
+	],
+	async load() {
+		return (await import("./AsfParser-CH5F_9Wp.mjs")).AsfParser;
+	}
+}, Gt = {
+	parserType: "dsdiff",
+	extensions: [".dff"],
+	mimeTypes: ["audio/dsf", "audio/dsd"],
+	async load() {
+		return (await import("./DsdiffParser-BAdYwB7y.mjs")).DsdiffParser;
+	}
+}, Kt = {
+	parserType: "aiff",
+	extensions: [
+		".aif",
+		"aiff",
+		"aifc"
+	],
+	mimeTypes: [
+		"audio/aiff",
+		"audio/aif",
+		"audio/aifc",
+		"application/aiff"
+	],
+	async load() {
+		return (await import("./AiffParser-C_VaWeb5.mjs")).AIFFParser;
+	}
+}, qt = {
+	parserType: "dsf",
+	extensions: [".dsf"],
+	mimeTypes: ["audio/dsf"],
+	async load() {
+		return (await import("./DsfParser-DWMLfBH1.mjs")).DsfParser;
+	}
+}, Jt = {
+	parserType: "flac",
+	extensions: [".flac"],
+	mimeTypes: ["audio/flac"],
+	async load() {
+		return (await import("./FlacParser-BdKXrY7L.mjs").then((e) => e.n)).FlacParser;
+	}
+}, Yt = {
+	parserType: "matroska",
+	extensions: [
+		".mka",
+		".mkv",
+		".mk3d",
+		".mks",
+		"webm"
+	],
+	mimeTypes: [
+		"audio/matroska",
+		"video/matroska",
+		"audio/webm",
+		"video/webm"
+	],
+	async load() {
+		return (await import("./MatroskaParser-fxFuCddu.mjs")).MatroskaParser;
+	}
+}, Xt = {
+	parserType: "mp4",
+	extensions: [
+		".mp4",
+		".m4a",
+		".m4b",
+		".m4pa",
+		"m4v",
+		"m4r",
+		"3gp",
+		".mov",
+		".movie",
+		".qt"
+	],
+	mimeTypes: [
+		"audio/mp4",
+		"audio/m4a",
+		"video/m4v",
+		"video/mp4",
+		"video/quicktime"
+	],
+	async load() {
+		return (await import("./MP4Parser-0KMJ-q2k.mjs")).MP4Parser;
+	}
+}, Zt = {
+	parserType: "musepack",
+	extensions: [".mpc"],
+	mimeTypes: ["audio/musepack"],
+	async load() {
+		return (await import("./MusepackParser-DFLoF47O.mjs")).MusepackParser;
+	}
+}, Qt = {
+	parserType: "ogg",
+	extensions: [
+		".ogg",
+		".ogv",
+		".oga",
+		".ogm",
+		".ogx",
+		".opus",
+		".spx"
+	],
+	mimeTypes: [
+		"audio/ogg",
+		"audio/opus",
+		"audio/speex",
+		"video/ogg"
+	],
+	async load() {
+		return (await import("./OggParser-C1qP2qC7.mjs")).OggParser;
+	}
+}, $t = {
+	parserType: "wavpack",
+	extensions: [".wv", ".wvp"],
+	mimeTypes: ["audio/wavpack"],
+	async load() {
+		return (await import("./WavPackParser-Ck8xXsNf.mjs")).WavPackParser;
+	}
+}, en = {
+	parserType: "riff",
+	extensions: [
+		".wav",
+		"wave",
+		".bwf"
+	],
+	mimeTypes: [
+		"audio/vnd.wave",
+		"audio/wav",
+		"audio/wave"
+	],
+	async load() {
+		return (await import("./WaveParser-hxQlWijT.mjs")).WaveParser;
+	}
+}, $ = (0, v.default)("music-metadata:parser:factory");
+function tn(e) {
+	let t = lt.parse(e), n = dt(t.type);
+	return {
+		type: n.type,
+		subtype: n.subtype,
+		suffix: n.suffix,
+		parameters: t.parameters
+	};
+}
+var nn = class {
+	constructor() {
+		this.parsers = [], [
+			Jt,
+			Ht,
+			Ut,
+			Xt,
+			Yt,
+			en,
+			Qt,
+			Wt,
+			Kt,
+			$t,
+			Zt,
+			qt,
+			Gt
+		].forEach((e) => {
+			this.registerParser(e);
+		});
+	}
+	registerParser(e) {
+		this.parsers.push(e);
+	}
+	async parse(e, t, n) {
+		var r = this;
+		if (e.supportsRandomAccess() ? ($("tokenizer supports random-access, scanning for appending headers"), await cn(e, n)) : $("tokenizer does not support random-access, cannot scan for appending headers"), !t) {
+			let n = new Uint8Array(4100);
+			if (e.fileInfo.mimeType && (t = r.findLoaderForContentType(e.fileInfo.mimeType)), !t && e.fileInfo.path && (t = r.findLoaderForExtension(e.fileInfo.path)), !t) {
+				$("Guess parser on content..."), await e.peekBuffer(n, { mayBeLess: !0 });
+				let i = await H(n, { mpegOffsetTolerance: 10 });
+				if (!i || !i.mime) throw new f("Failed to determine audio format");
+				if ($(`Guessed file type is mime=${i.mime}, extension=${i.ext}`), t = r.findLoaderForContentType(i.mime), !t) throw new c(`Guessed MIME-type not supported: ${i.mime}`);
+			}
+		}
+		$(`Loading ${t.parserType} parser...`);
+		let i = new Bt(n), a = new (await (t.load()))(i, e, n == null ? {} : n);
+		return $(`Parser ${t.parserType} loaded`), await a.parse(), i.format.trackInfo && (i.format.hasAudio === void 0 && i.setFormat("hasAudio", !!i.format.trackInfo.find((e) => e.type === ue.audio)), i.format.hasVideo === void 0 && i.setFormat("hasVideo", !!i.format.trackInfo.find((e) => e.type === ue.video))), i.toCommonMetadata();
+	}
+	findLoaderForExtension(e) {
+		if (!e) return;
+		let t = rn(e).toLocaleLowerCase() || e;
+		return this.parsers.find((e) => e.extensions.indexOf(t) !== -1);
+	}
+	findLoaderForContentType(e) {
+		let t;
+		if (!e) return;
+		try {
+			t = tn(e);
+		} catch (t) {
+			$(`Invalid HTTP Content-Type header value: ${e}`);
+			return;
+		}
+		let n = t.subtype.indexOf("x-") === 0 ? t.subtype.substring(2) : t.subtype;
+		return this.parsers.find((e) => e.mimeTypes.find((e) => e.indexOf(`${t.type}/${n}`) !== -1));
+	}
+	getSupportedMimeTypes() {
+		let e = /* @__PURE__ */ new Set();
+		return this.parsers.forEach((t) => {
+			t.mimeTypes.forEach((t) => {
+				e.add(t), e.add(t.replace("/", "/x-"));
+			});
+		}), Array.from(e);
+	}
+};
+function rn(e) {
+	let t = e.lastIndexOf(".");
+	return t === -1 ? "" : e.substring(t);
+}
+async function an(e) {
+	let t = e.fileInfo.size;
+	if (t >= 143) {
+		let n = new Uint8Array(15), r = e.position;
+		await e.readBuffer(n, { position: t - 143 }), e.setPosition(r);
+		let a = i(n, "latin1");
+		if (a.substring(6) === "LYRICS200") return Number.parseInt(a.substring(0, 6), 10) + 15;
+	}
+	return 0;
+}
+//#endregion
+//#region node_modules/music-metadata/lib/core.js
+async function on(e, t, n = {}) {
+	return sn(te(e, { fileInfo: typeof t == "string" ? { mimeType: t } : t }), n);
+}
+function sn(e, t) {
+	return new nn().parse(e, void 0, t);
+}
+async function cn(e, t = {}) {
+	let n = e.fileInfo.size;
+	if (await le(e)) {
+		n -= 128;
+		let t = await an(e);
+		n -= t;
+	}
+	t.apeHeader = await ce.findApeFooterOffset(e, n);
+}
+//#endregion
+export { on as parseBuffer };