@l1yp/file-viewer 0.1.0

package/dist/lib/markdown/styles.js

@@ -0,0 +1,135 @@
+import { MONO as e, SERIF as t } from "../fonts.js";
+//#region src/lib/markdown/styles.ts
+function n(e) {
+	return e > 0 ? {
+		fontFamily: t,
+		fontSize: "16.5px",
+		lineHeight: 1.7,
+		margin: "0 0 8px",
+		color: "var(--text)"
+	} : {
+		fontFamily: t,
+		fontSize: "17px",
+		lineHeight: 1.78,
+		margin: "0 0 16px",
+		color: "var(--text)"
+	};
+}
+function r(e, n) {
+	let r = {
+		fontFamily: t,
+		fontWeight: 600,
+		color: "var(--text-strong)"
+	};
+	switch (e) {
+		case 1: return {
+			...r,
+			fontSize: "24px",
+			margin: `${n ? "4px" : "32px"} 0 15px`,
+			letterSpacing: "-0.02em",
+			lineHeight: 1.3
+		};
+		case 2: return {
+			...r,
+			fontSize: "20px",
+			margin: `${n ? "4px" : "30px"} 0 13px`,
+			letterSpacing: "-0.01em",
+			lineHeight: 1.35
+		};
+		case 3: return {
+			...r,
+			fontSize: "17px",
+			margin: "22px 0 9px",
+			lineHeight: 1.4
+		};
+		case 4: return {
+			...r,
+			fontSize: "15.5px",
+			margin: "20px 0 8px",
+			lineHeight: 1.45
+		};
+		case 5: return {
+			...r,
+			fontSize: "14px",
+			margin: "18px 0 6px",
+			lineHeight: 1.5
+		};
+		default: return {
+			...r,
+			fontSize: "13px",
+			margin: "18px 0 6px",
+			letterSpacing: "0.01em",
+			color: "var(--muted)",
+			lineHeight: 1.5
+		};
+	}
+}
+function i(e, t) {
+	return {
+		margin: e > 0 ? "8px 0 10px" : "4px 0 18px",
+		paddingLeft: t ? "28px" : "24px"
+	};
+}
+function a(e) {
+	return {
+		fontFamily: t,
+		fontSize: e > 0 ? "16.5px" : "17px",
+		lineHeight: 1.72,
+		color: "var(--text)",
+		margin: "0 0 7px",
+		paddingLeft: "3px"
+	};
+}
+var o = {
+	fontFamily: e,
+	fontSize: "0.86em",
+	background: "var(--code-bg)",
+	border: "1px solid var(--code-border)",
+	borderRadius: "5px",
+	padding: "1.5px 5px",
+	color: "var(--accent)",
+	overflowWrap: "anywhere"
+}, s = {
+	fontWeight: 600,
+	color: "var(--text-strong)"
+}, c = { color: "var(--muted)" }, l = { fontStyle: "italic" }, u = {
+	color: "var(--accent)",
+	textDecoration: "underline",
+	textUnderlineOffset: "2px",
+	textDecorationThickness: "1px"
+}, d = {
+	maxWidth: "100%",
+	height: "auto",
+	borderRadius: "8px",
+	margin: "6px 0",
+	border: "1px solid var(--border)"
+}, f = {
+	border: "none",
+	borderTop: "1px solid var(--border)",
+	margin: "28px 0"
+}, p = {
+	margin: "0 0 16px",
+	padding: "2px 0 2px 16px",
+	borderLeft: "3px solid var(--border-2)",
+	color: "var(--muted)"
+};
+function m(e) {
+	return {
+		display: "inline-block",
+		width: "15px",
+		height: "15px",
+		boxSizing: "border-box",
+		verticalAlign: "-2px",
+		marginRight: "8px",
+		borderRadius: "4px",
+		border: `1.5px solid ${e ? "var(--accent)" : "var(--border-2)"}`,
+		background: e ? "var(--accent)" : "transparent",
+		color: "#fff",
+		fontSize: "11px",
+		lineHeight: "12px",
+		textAlign: "center",
+		fontWeight: 700
+	};
+}
+//#endregion
+export { p as blockquoteStyle, c as delStyle, l as emStyle, r as headingStyle, f as hrStyle, d as imgStyle, o as inlineCodeStyle, u as linkStyle, a as listItemStyle, i as listStyle, n as paragraphStyle, s as strongStyle, m as taskCheckboxStyle };

package/dist/lib/mht.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Hand-rolled MHT / MHTML (web archive, RFC 2557) parser — the archive-specific layer on top of the shared
+ * MIME core (lib/mime.ts). An `.mht`/`.mhtml` is a `multipart/related` MIME container: a root HTML part plus
+ * the page's resources (images / CSS / fonts), each part referenced from the HTML by its original URL via a
+ * `Content-Location` header (vs. an email's `cid:` Content-ID).
+ *
+ * Two halves:
+ *  - {@link parseMht} (pure, unit-testable): parse the container, pick the root HTML part, and index every
+ *    other part by its absolute Content-Location (and Content-ID, for the rare `cid:` archive).
+ *  - {@link rewriteHtml} (browser-only, uses DOMParser): rewrite the HTML's resource references to caller-
+ *    supplied blob URLs, strip scripts, and inject a hardened CSP — so the archive renders offline inside a
+ *    sandboxed iframe without running upstream script or phoning home. See MhtViewer.vue.
+ */
+/** A single archived page resource (image / stylesheet / font / …). */
+export interface MhtResource {
+    contentType: string;
+    /** Charset label from the part's Content-Type (for text resources like CSS); '' when none. */
+    charset: string;
+    bytes: Uint8Array;
+}
+/** Flattened, render-ready view of a parsed web archive. */
+export interface ParsedMht {
+    /** `Subject:` header — the saved page's title (browsers write the document title here). */
+    title: string;
+    /** Original page URL (`Snapshot-Content-Location` or the root `Content-Location`), for display. */
+    sourceUrl: string;
+    /** Raw `Date:` header value (the viewer formats it for display). */
+    date: string;
+    /** Decoded root HTML (NOT yet resource-rewritten), or null when the archive has no HTML part. */
+    html: string | null;
+    /** Base URL for resolving the root HTML's resource references (the root part's Content-Location). */
+    rootBase: string;
+    /** Absolute Content-Location → resource. */
+    byLocation: Map<string, MhtResource>;
+    /** Content-ID (no angle brackets) → resource. */
+    byCid: Map<string, MhtResource>;
+}
+/** The hardened CSP injected into the archive before it's handed to the sandboxed iframe. */
+export declare const MHT_CSP: string;
+/** Parse raw `.mht`/`.mhtml` bytes into a flattened {@link ParsedMht}. */
+export declare function parseMht(bytes: Uint8Array): ParsedMht;
+/**
+ * Rewrite the parsed archive's root HTML so every captured resource reference points at a caller-supplied
+ * blob URL, strip scripts, and inject {@link MHT_CSP}. Returns a complete HTML document string for the
+ * sandboxed iframe. Browser-only (uses DOMParser — which neither runs scripts nor fetches subresources).
+ *
+ * `makeUrl(bytes, contentType)` is the caller's blob-URL factory (it tracks the URLs for later revocation).
+ * Resources we can't resolve are left with their original URL — the CSP then blocks the request, so they
+ * show as a broken image rather than leaking to the network.
+ */
+export declare function rewriteHtml(parsed: ParsedMht, makeUrl: (bytes: Uint8Array, contentType: string) => string): string;

package/dist/lib/mht.js

@@ -0,0 +1,122 @@
+import { bytesToBinary as e, collectLeaves as t, decodeCharset as n, decodeWords as r, getHeader as i, parseEntity as a, parseHeaders as o, splitHeadersBody as s } from "./mime.js";
+//#region src/lib/mht.ts
+var c = "default-src 'none'; img-src blob: data:; media-src blob: data:; style-src blob: data: 'unsafe-inline'; font-src blob: data:; script-src 'none'; object-src 'none'; base-uri 'none'; form-action 'none'";
+function l(e, t) {
+	try {
+		return new URL(e, t || void 0).href;
+	} catch {
+		return e;
+	}
+}
+function u(e) {
+	return e.trim().replace(/^<|>$/g, "");
+}
+function d(c) {
+	let d = e(c), f = a(d), p = o(s(d)[0]), m = [];
+	t(f, m);
+	let h = u(f.ctParams.start || ""), g;
+	h && (g = m.find((e) => e.contentId === h)), g ||= m.find((e) => e.contentType === "text/html");
+	let _ = /* @__PURE__ */ new Map(), v = /* @__PURE__ */ new Map();
+	for (let e of m) {
+		if (e === g) continue;
+		let t = {
+			contentType: e.contentType,
+			charset: e.charset,
+			bytes: e.bodyBytes ?? new Uint8Array()
+		};
+		if (e.contentLocation) {
+			_.set(e.contentLocation, t);
+			let n = l(e.contentLocation, e.contentLocation);
+			n !== e.contentLocation && _.set(n, t);
+		}
+		e.contentId && v.set(e.contentId, t);
+	}
+	let y = g?.contentLocation || i(p, "content-location") || "", b = g ? n(g.bodyBytes ?? new Uint8Array(), g.charset) : null;
+	return {
+		title: r(i(p, "subject")),
+		sourceUrl: i(p, "snapshot-content-location") || i(p, "content-location") || y,
+		date: i(p, "date"),
+		html: b,
+		rootBase: y,
+		byLocation: _,
+		byCid: v
+	};
+}
+var f = "http://www.w3.org/1999/xlink";
+function p(e, t) {
+	let r = new DOMParser().parseFromString(e.html ?? "", "text/html"), i = /* @__PURE__ */ new Map(), a = (e) => {
+		let n = i.get(e);
+		return n || (n = t(e.bytes, e.contentType || "application/octet-stream"), i.set(e, n)), n;
+	}, o = (t, n) => {
+		if (!t) return;
+		if (/^cid:/i.test(t)) {
+			let n = u(t.slice(4));
+			return e.byCid.get(n) ?? e.byCid.get(decodeURIComponent(n));
+		}
+		if (/^(data|blob|javascript|about):/i.test(t)) return;
+		let r = l(t, n);
+		return e.byLocation.get(r) ?? e.byLocation.get(t);
+	}, s = (e, t) => {
+		let n = e.replace(/url\(\s*(['"]?)([^'")]+)\1\s*\)/gi, (e, n, r) => {
+			let i = o(r, t);
+			return i ? `url("${a(i)}")` : e;
+		});
+		return n = n.replace(/@import\s+(['"])([^'"]+)\1/gi, (e, n, r) => {
+			let i = o(r, t);
+			return i ? `@import "${a(i)}"` : e;
+		}), n;
+	}, d = (t, n) => {
+		let r = t.getAttribute(n);
+		if (!r) return;
+		let i = o(r, e.rootBase);
+		i && t.setAttribute(n, a(i));
+	};
+	r.querySelectorAll("script, base").forEach((e) => e.remove()), r.querySelectorAll("meta[http-equiv]").forEach((e) => {
+		(e.getAttribute("http-equiv") || "").toLowerCase() === "content-security-policy" && e.remove();
+	}), r.querySelectorAll("link[rel~=\"stylesheet\"][href]").forEach((r) => {
+		let i = r.getAttribute("href");
+		if (!i) return;
+		let a = o(i, e.rootBase);
+		if (!a) return;
+		let c = l(i, e.rootBase), u = s(n(a.bytes, a.charset), c);
+		r.setAttribute("href", t(new TextEncoder().encode(u), "text/css"));
+	});
+	for (let [e, t] of [
+		["img", "src"],
+		["input[type=\"image\"]", "src"],
+		["source", "src"],
+		["video", "src"],
+		["video", "poster"],
+		["audio", "src"],
+		["track", "src"],
+		["embed", "src"],
+		["object", "data"]
+	]) r.querySelectorAll(e).forEach((e) => d(e, t));
+	r.querySelectorAll("image").forEach((t) => {
+		d(t, "href");
+		let n = t.getAttributeNS(f, "href");
+		if (n) {
+			let r = o(n, e.rootBase);
+			r && t.setAttributeNS(f, "href", a(r));
+		}
+	}), r.querySelectorAll("img[srcset], source[srcset]").forEach((t) => {
+		let n = t.getAttribute("srcset");
+		if (!n) return;
+		let r = n.split(",").map((t) => {
+			let n = t.trim();
+			if (!n) return n;
+			let r = n.split(/\s+/), i = o(r[0], e.rootBase);
+			return i && (r[0] = a(i)), r.join(" ");
+		}).join(", ");
+		t.setAttribute("srcset", r);
+	}), r.querySelectorAll("[style]").forEach((t) => {
+		let n = t.getAttribute("style");
+		n && n.includes("url(") && t.setAttribute("style", s(n, e.rootBase));
+	}), r.querySelectorAll("style").forEach((t) => {
+		t.textContent = s(t.textContent ?? "", e.rootBase);
+	});
+	let p = r.createElement("meta");
+	return p.setAttribute("http-equiv", "Content-Security-Policy"), p.setAttribute("content", c), r.head.insertBefore(p, r.head.firstChild), "<!doctype html>\n" + r.documentElement.outerHTML;
+}
+//#endregion
+export { d as parseMht, p as rewriteHtml };

package/dist/lib/midi.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Hand-rolled, zero-dependency Standard MIDI File (.mid/.midi) parser for the side viewer's best-effort
+ * preview. The browser can't *play* MIDI (there's no built-in synthesizer and self-hosting a soundfont is out
+ * of scope), so the viewer instead VISUALIZES the music as a piano roll. This extracts what that needs: the
+ * note events (pitch / timing / track) plus header info and an approximate duration.
+ *
+ * Timing is approximate by design: it uses the first `set_tempo` it sees (or 120 BPM) for the whole file, so
+ * songs with tempo changes will be slightly off — fine for a visual overview. SMPTE-division files fall back
+ * to a nominal ticks-per-quarter. Note-ons with velocity 0 are treated as note-offs (the common shorthand).
+ */
+export interface MidiNote {
+    track: number;
+    channel: number;
+    pitch: number;
+    startTick: number;
+    endTick: number;
+    velocity: number;
+}
+export interface ParsedMidi {
+    format: number;
+    trackCount: number;
+    division: number;
+    notes: MidiNote[];
+    totalTicks: number;
+    durationSec: number;
+    tempoBpm: number;
+}
+export declare function parseMidi(buf: ArrayBuffer): ParsedMidi;

package/dist/lib/midi.js

@@ -0,0 +1,84 @@
+//#region src/lib/midi.ts
+function e(e) {
+	let t = new DataView(e), n = 0, r = () => t.getUint8(n++), i = () => {
+		let e = t.getUint16(n);
+		return n += 2, e;
+	}, a = () => {
+		let e = t.getUint32(n);
+		return n += 4, e;
+	}, o = () => String.fromCharCode(r(), r(), r(), r()), s = () => {
+		let e = 0;
+		for (let t = 0; t < 4; t++) {
+			let t = r();
+			if (e = e << 7 | t & 127, !(t & 128)) break;
+		}
+		return e;
+	};
+	if (e.byteLength < 14 || o() !== "MThd") throw Error("不是有效的 MIDI 文件");
+	let c = a(), l = i(), u = i(), d = i();
+	n = 8 + c;
+	let f = d & 32768 ? 480 : d || 480, p = [], m = 5e5, h = !1, g = 0;
+	for (let e = 0; e < u && n + 8 <= t.byteLength && o() === "MTrk"; e++) {
+		let i = a(), o = Math.min(n + i, t.byteLength), c = 0, l = 0, u = /* @__PURE__ */ new Map(), d = (t, n) => {
+			let r = t << 8 | n, i = u.get(r);
+			i && (p.push({
+				track: e,
+				channel: t,
+				pitch: n,
+				startTick: i.startTick,
+				endTick: c,
+				velocity: i.velocity
+			}), u.delete(r), c > g && (g = c));
+		};
+		for (; n < o;) {
+			c += s();
+			let e = r();
+			if (e & 128 ? l = e : n--, l === 255) {
+				let e = r(), t = s();
+				if (e === 81 && t === 3) {
+					let e = r() << 16 | r() << 8 | r();
+					h ||= (m = e, !0);
+				} else n += t;
+			} else if (l === 240 || l === 247) n += s();
+			else {
+				let e = l & 240, t = l & 15;
+				if (e === 144) {
+					let e = r(), n = r();
+					n > 0 ? u.set(t << 8 | e, {
+						startTick: c,
+						velocity: n
+					}) : d(t, e);
+				} else if (e === 128) {
+					let e = r();
+					r(), d(t, e);
+				} else if (e === 160 || e === 176 || e === 224) n += 2;
+				else if (e === 192 || e === 208) n += 1;
+				else break;
+			}
+		}
+		for (let [t, n] of u) {
+			let r = t & 255, i = t >> 8;
+			p.push({
+				track: e,
+				channel: i,
+				pitch: r,
+				startTick: n.startTick,
+				endTick: c,
+				velocity: n.velocity
+			});
+		}
+		c > g && (g = c), n = o;
+	}
+	let _ = m / 1e6 / f;
+	return {
+		format: l,
+		trackCount: u,
+		division: f,
+		notes: p,
+		totalTicks: g,
+		durationSec: g * _,
+		tempoBpm: Math.round(6e7 / m)
+	};
+}
+//#endregion
+export { e as parseMidi };

package/dist/lib/mime.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Hand-rolled MIME core (RFC 822 / 2045 / 2047 / 2231) shared by the side-viewer's MIME-container previews.
+ *
+ * Zero-dependency, in the spirit of the project's other parsers (lib/zip.ts, lib/binobj.ts). Both an `.eml`
+ * email (lib/eml.ts) and a `.mht`/`.mhtml` web archive (lib/mht.ts) are the SAME on the wire: RFC 822 headers
+ * + a body that may be a tree of multipart entities, each with its own Content-Type / Content-Transfer-
+ * Encoding / charset. This module owns that generic machinery — parse the container into an {@link Entity}
+ * tree, transfer-decode (base64 / quoted-printable) and charset-decode (TextDecoder) each leaf — and the two
+ * format-specific modules flatten the tree into their own render-ready shapes.
+ *
+ * Bytes vs. text: the transport is treated as a 1:1 binary string (each byte → one char in [0,255]) so we
+ * can split on boundaries / unfold headers with plain string ops while keeping leaf bytes exact. Per-part we
+ * then transfer-decode and charset-decode to recover real text / bytes. Real attachments / resources are
+ * virtually always base64/QP (7-bit safe), so the binary string round-trips losslessly even for non-UTF-8.
+ */
+/** Pack bytes into a 1:1 binary string (each byte → one char in [0,255]); chunked to bound arg count. */
+export declare function bytesToBinary(bytes: Uint8Array): string;
+/** Inverse of {@link bytesToBinary}: a binary string back to its exact bytes. */
+export declare function binaryToBytes(s: string): Uint8Array;
+/** Decode base64 (tolerant of embedded whitespace/newlines) to bytes. */
+export declare function base64ToBytes(b64: string): Uint8Array;
+/** Decode bytes with a (possibly messy) charset label, falling back to UTF-8 then a raw binary string. */
+export declare function decodeCharset(bytes: Uint8Array, charset: string): string;
+/** Decode quoted-printable text (soft line-breaks dropped, `=XX` → byte) to a binary string. */
+export declare function decodeQuotedPrintable(s: string): string;
+/**
+ * Decode RFC 2047 encoded-words in a header value (`=?charset?B|Q?text?=`). Adjacent encoded words
+ * separated only by whitespace are concatenated with the whitespace removed (§6.2).
+ */
+export declare function decodeWords(input: string): string;
+export interface HeaderField {
+    name: string;
+    value: string;
+}
+/** Split a raw entity (binary string) into its header block and body at the first blank line. */
+export declare function splitHeadersBody(raw: string): [string, string];
+/** Parse a header block into ordered fields, unfolding continuation (leading-whitespace) lines. */
+export declare function parseHeaders(block: string): HeaderField[];
+/** First header value (case-insensitive), '' when absent. */
+export declare function getHeader(headers: HeaderField[], name: string): string;
+export interface ContentType {
+    type: string;
+    params: Record<string, string>;
+}
+/** Split a structured header value on `;`, ignoring separators inside quotes. */
+export declare function splitParams(value: string): string[];
+/** Parse a Content-Type / Content-Disposition value into its type token + lowercased params. */
+export declare function parseTyped(value: string): ContentType;
+/**
+ * Resolve a parameter (`filename` / `name`) across its RFC 2231 spellings: a plain quoted value (with
+ * RFC 2047 encoded-words decoded), a single extended `name*=`, or `name*0*`/`name*1*` continuations.
+ */
+export declare function paramValue(params: Record<string, string>, base: string): string;
+/** Transfer-decode a leaf body (binary string) per its Content-Transfer-Encoding into exact bytes. */
+export declare function decodeBody(bodyBin: string, encoding: string): Uint8Array;
+/**
+ * Split a multipart body (binary string) into its part substrings (headers + body each). Boundary
+ * delimiter lines are `--boundary` at a line start; the closing one is `--boundary--`. The CRLF preceding
+ * a delimiter belongs to the boundary, so it's excluded from the preceding part.
+ */
+export declare function splitMultipart(bodyBin: string, boundary: string): string[];
+/** One MIME entity: a leaf (with decoded {@link bodyBytes}) or a multipart node (with child {@link parts}). */
+export interface Entity {
+    contentType: string;
+    charset: string;
+    encoding: string;
+    disposition: string;
+    filename: string;
+    /** Content-ID without the angle brackets, '' if none — the key a `cid:` ref resolves to (email inline). */
+    contentId: string;
+    /** Content-Location URI, '' if none — the key a web archive's resource references resolve to (MHT). */
+    contentLocation: string;
+    /** Raw Content-Type params (lowercased), e.g. `boundary` / `start` / `type` — for MHT root selection. */
+    ctParams: Record<string, string>;
+    isMultipart: boolean;
+    parts: Entity[];
+    bodyBytes: Uint8Array | null;
+}
+/** Recursively parse one MIME entity (binary string) into the {@link Entity} tree. */
+export declare function parseEntity(rawBin: string, depth?: number): Entity;
+/** Depth-first collect every leaf (non-multipart) entity. */
+export declare function collectLeaves(ent: Entity, out: Entity[]): void;

package/dist/lib/mime.js

@@ -0,0 +1,151 @@
+//#region src/lib/mime.ts
+var e = {
+	"us-ascii": "utf-8",
+	ascii: "utf-8",
+	"ansi_x3.4-1968": "utf-8",
+	"iso-ir-6": "utf-8",
+	ansi: "windows-1252",
+	cp1252: "windows-1252"
+};
+function t(e) {
+	let t = "", n = 32768;
+	for (let r = 0; r < e.length; r += n) t += String.fromCharCode(...e.subarray(r, r + n));
+	return t;
+}
+function n(e) {
+	let t = new Uint8Array(e.length);
+	for (let n = 0; n < e.length; n++) t[n] = e.charCodeAt(n) & 255;
+	return t;
+}
+function r(e) {
+	let t = e.replace(/[^A-Za-z0-9+/=]/g, "");
+	return n(atob(t));
+}
+function i(n, r) {
+	let i = (r || "utf-8").trim().toLowerCase().split("*")[0];
+	i = e[i] ?? i;
+	try {
+		return new TextDecoder(i, { fatal: !1 }).decode(n);
+	} catch {
+		try {
+			return new TextDecoder("utf-8", { fatal: !1 }).decode(n);
+		} catch {
+			return t(n);
+		}
+	}
+}
+function a(e) {
+	return e.replace(/=\r?\n/g, "").replace(/=([0-9A-Fa-f]{2})/g, (e, t) => String.fromCharCode(parseInt(t, 16)));
+}
+function o(e) {
+	return !e || !e.includes("=?") ? e : e.replace(/\?=\s+=\?/g, "?==?").replace(/=\?([^?]+)\?([BbQq])\?([^?]*)\?=/g, (e, t, a, o) => {
+		try {
+			let e;
+			return e = a.toUpperCase() === "B" ? r(o) : n(o.replace(/_/g, " ").replace(/=([0-9A-Fa-f]{2})/g, (e, t) => String.fromCharCode(parseInt(t, 16)))), i(e, t);
+		} catch {
+			return e;
+		}
+	});
+}
+function s(e) {
+	let t = e.match(/\r?\n\r?\n/);
+	return !t || t.index === void 0 ? [e, ""] : [e.slice(0, t.index), e.slice(t.index + t[0].length)];
+}
+function c(e) {
+	let t = [];
+	for (let n of e.split(/\r?\n/)) if (/^[ \t]/.test(n) && t.length) t[t.length - 1].value += " " + n.replace(/^[ \t]+/, "");
+	else {
+		let e = n.indexOf(":");
+		e > 0 && t.push({
+			name: n.slice(0, e).trim(),
+			value: n.slice(e + 1).trim()
+		});
+	}
+	return t;
+}
+function l(e, t) {
+	let n = t.toLowerCase();
+	return e.find((e) => e.name.toLowerCase() === n)?.value ?? "";
+}
+function u(e) {
+	let t = [], n = "", r = !1;
+	for (let i of e) i === "\"" ? (r = !r, n += i) : i === ";" && !r ? (t.push(n), n = "") : n += i;
+	return n.trim() && t.push(n), t;
+}
+function d(e) {
+	let t = u(e), n = (t.shift() ?? "").trim().toLowerCase(), r = {};
+	for (let e of t) {
+		let t = e.indexOf("=");
+		if (t < 0) continue;
+		let n = e.slice(0, t).trim().toLowerCase(), i = e.slice(t + 1).trim();
+		i.startsWith("\"") && i.endsWith("\"") && (i = i.slice(1, -1)), r[n] = i;
+	}
+	return {
+		type: n,
+		params: r
+	};
+}
+function f(e, t) {
+	let n = [];
+	for (let t = 0; t < e.length; t++) e[t] === "%" && t + 2 < e.length ? (n.push(parseInt(e.slice(t + 1, t + 3), 16)), t += 2) : n.push(e.charCodeAt(t) & 255);
+	return i(Uint8Array.from(n), t || "utf-8");
+}
+function p(e) {
+	let t = e.match(/^([^']*)'[^']*'(.*)$/);
+	return t ? f(t[2], t[1]) : f(e, "");
+}
+function m(e, t) {
+	if (e[t + "*"] !== void 0) return p(e[t + "*"]);
+	if (e[t] !== void 0) return o(e[t]);
+	if (e[`${t}*0`] !== void 0 || e[`${t}*0*`] !== void 0) {
+		let n = "", r = "";
+		for (let i = 0;; i++) {
+			let a = e[`${t}*${i}*`], o = e[`${t}*${i}`];
+			if (a !== void 0) if (i === 0) {
+				let e = a.match(/^([^']*)'[^']*'(.*)$/);
+				e ? (r = e[1], n += f(e[2], r)) : n += f(a, r);
+			} else n += f(a, r);
+			else if (o !== void 0) n += o;
+			else break;
+		}
+		return n;
+	}
+	return "";
+}
+function h(e, t) {
+	let i = (t || "").trim().toLowerCase();
+	return i === "base64" ? r(e) : n(i === "quoted-printable" ? a(e) : e);
+}
+function g(e, t) {
+	let n = t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), r = RegExp(`(?:^|\\r\\n|\\n)--${n}(--)?[ \\t]*(?:\\r\\n|\\n|$)`, "g"), i = [], a, o = -1;
+	for (; (a = r.exec(e)) !== null && (o >= 0 && i.push(e.slice(o, a.index)), a[1] !== "--");) o = r.lastIndex;
+	return i;
+}
+function _(e, t = 0) {
+	let [n, r] = s(e), i = c(n), a = d(l(i, "content-type") || "text/plain"), o = a.type || "text/plain", u = d(l(i, "content-disposition")), f = l(i, "content-id").trim();
+	f.startsWith("<") && f.endsWith(">") && (f = f.slice(1, -1));
+	let p = {
+		contentType: o,
+		charset: a.params.charset || "",
+		encoding: l(i, "content-transfer-encoding"),
+		disposition: u.type || "",
+		filename: m(u.params, "filename") || m(a.params, "name") || "",
+		contentId: f,
+		contentLocation: l(i, "content-location").trim(),
+		ctParams: a.params,
+		isMultipart: !1,
+		parts: [],
+		bodyBytes: null
+	};
+	if (o.startsWith("multipart/") && a.params.boundary && t < 20) {
+		p.isMultipart = !0;
+		for (let e of g(r, a.params.boundary)) p.parts.push(_(e, t + 1));
+	} else p.bodyBytes = h(r, p.encoding);
+	return p;
+}
+function v(e, t) {
+	if (e.isMultipart) for (let n of e.parts) v(n, t);
+	else t.push(e);
+}
+//#endregion
+export { t as bytesToBinary, v as collectLeaves, i as decodeCharset, o as decodeWords, l as getHeader, _ as parseEntity, c as parseHeaders, s as splitHeadersBody };