@l1yp/file-viewer 0.1.0

package/dist/lib/dicomRender.js

@@ -0,0 +1,114 @@
+//#region src/lib/dicomRender.ts
+function e(e) {
+	return e.samplesPerPixel >= 3;
+}
+function t(e, t) {
+	let n = t.rows * t.columns, r = new Float32Array(n), i = e.bytes, a = e.littleEndian, o = t.rescaleSlope, s = t.rescaleIntercept, c = t.bitsStored, l = t.pixelRepresentation === 1, u = 1 << c - 1, d = 1 << c, f = Infinity, p = -Infinity;
+	if (t.bitsAllocated === 16) {
+		let e = c >= 16 ? 65535 : d - 1;
+		for (let t = 0; t < n; t++) {
+			let n = t * 2, c = a ? i[n] | i[n + 1] << 8 : i[n + 1] | i[n] << 8;
+			c &= e, l && c & u && (c -= d);
+			let m = c * o + s;
+			r[t] = m, m < f && (f = m), m > p && (p = m);
+		}
+	} else {
+		let e = c >= 8 ? 255 : d - 1;
+		for (let t = 0; t < n; t++) {
+			let n = i[t] & e;
+			l && n & u && (n -= d);
+			let a = n * o + s;
+			r[t] = a, a < f && (f = a), a > p && (p = a);
+		}
+	}
+	return Number.isFinite(f) || (f = 0, p = 0), {
+		gray: r,
+		min: f,
+		max: p
+	};
+}
+function n(e, t) {
+	let n = t.rows * t.columns, r = new Int32Array(n), i = e.bytes, a = e.littleEndian;
+	if (t.bitsAllocated === 16) for (let e = 0; e < n; e++) {
+		let t = e * 2;
+		r[e] = a ? i[t] | i[t + 1] << 8 : i[t + 1] | i[t] << 8;
+	}
+	else for (let e = 0; e < n; e++) r[e] = i[e];
+	return r;
+}
+function r(e, t) {
+	let n = t.rows * t.columns, r = e.bytes, a = new Uint8Array(n * 3);
+	if (t.planarConfiguration === 1) for (let e = 0; e < n; e++) a[e * 3] = r[e], a[e * 3 + 1] = r[n + e], a[e * 3 + 2] = r[2 * n + e];
+	else a.set(r.subarray(0, n * 3));
+	let o = t.photometric;
+	if (o === "YBR_FULL" || o === "YBR_FULL_422") for (let e = 0; e < n; e++) {
+		let t = e * 3, n = a[t], r = a[t + 1] - 128, o = a[t + 2] - 128;
+		a[t] = i(n + 1.402 * o), a[t + 1] = i(n - .344136 * r - .714136 * o), a[t + 2] = i(n + 1.772 * r);
+	}
+	return a;
+}
+function i(e) {
+	return e < 0 ? 0 : e > 255 ? 255 : e | 0;
+}
+function a(i, a) {
+	let o = {
+		width: a.columns,
+		height: a.rows,
+		minValue: 0,
+		maxValue: 0,
+		monochrome1: a.photometric === "MONOCHROME1"
+	};
+	if (a.photometric === "PALETTE COLOR" && a.palette) return {
+		...o,
+		mode: "palette",
+		indices: n(i, a),
+		palette: a.palette
+	};
+	if (e(a)) return {
+		...o,
+		mode: "rgb",
+		rgb: r(i, a)
+	};
+	let { gray: s, min: c, max: l } = t(i, a);
+	return {
+		...o,
+		mode: "gray",
+		gray: s,
+		minValue: c,
+		maxValue: l
+	};
+}
+function o(e) {
+	let t = Math.max(1, e.maxValue - e.minValue);
+	return {
+		center: (e.maxValue + e.minValue) / 2,
+		width: t
+	};
+}
+function s(e, t) {
+	let { width: n, height: r } = e, i = new Uint8ClampedArray(n * r * 4);
+	if (e.mode === "gray" && e.gray) {
+		let n = t.windowCenter, r = t.windowWidth > 1 ? t.windowWidth : 1, a = n - .5 - (r - 1) / 2, o = n - .5 + (r - 1) / 2, s = r - 1 || 1, c = n - .5, l = t.invert !== e.monochrome1, u = e.gray;
+		for (let e = 0; e < u.length; e++) {
+			let t = u[e], n;
+			n = t <= a ? 0 : t > o ? 255 : ((t - c) / s + .5) * 255, l && (n = 255 - n);
+			let r = e * 4;
+			i[r] = n, i[r + 1] = n, i[r + 2] = n, i[r + 3] = 255;
+		}
+	} else if (e.mode === "palette" && e.indices && e.palette) {
+		let { r: t, g: n, b: r } = e.palette, a = t.length - 1, o = e.indices;
+		for (let e = 0; e < o.length; e++) {
+			let s = o[e] < 0 ? 0 : o[e] > a ? a : o[e], c = e * 4;
+			i[c] = t[s], i[c + 1] = n[s], i[c + 2] = r[s], i[c + 3] = 255;
+		}
+	} else if (e.mode === "rgb" && e.rgb) {
+		let t = e.rgb, a = n * r;
+		for (let e = 0; e < a; e++) {
+			let n = e * 4, r = e * 3;
+			i[n] = t[r], i[n + 1] = t[r + 1], i[n + 2] = t[r + 2], i[n + 3] = 255;
+		}
+	}
+	return new ImageData(i, n, r);
+}
+//#endregion
+export { o as autoWindow, a as buildFramePixels, s as renderToImageData };

package/dist/lib/dxf.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Hand-rolled, zero-dependency DXF (AutoCAD Drawing Exchange Format) parser for the file viewer — turns an
+ * ASCII DXF into a flat list of drawable primitives the viewer draws as an SVG (in the codebase's hand-rolled
+ * house style, like lib/geo.ts / lib/diagram.ts — no CAD runtime, no CDN).
+ *
+ * DXF is a stream of (group-code, value) line PAIRS grouped into SECTIONS. We read:
+ *   - TABLES → the LAYER table (name → ACI colour + on/off), so entities colour "ByLayer".
+ *   - BLOCKS → reusable geometry, keyed by name, expanded wherever an INSERT references them (with the
+ *     insert's translation / scale / rotation; nested INSERTs are expanded recursively, depth-capped).
+ *   - ENTITIES → the drawing itself.
+ * Supported entities: LINE, LWPOLYLINE (incl. bulge arcs), POLYLINE/VERTEX, CIRCLE, ARC, ELLIPSE (tessellated),
+ * POINT, TEXT / MTEXT, SOLID / 3DFACE / TRACE (filled), SPLINE (fit/control points as a polyline), INSERT.
+ * Anything else (HATCH / DIMENSION / WIPEOUT / …) is skipped — the drawing still renders, minus that entity.
+ *
+ * Coordinates are kept in DXF world space (Y up); the viewer flips Y for SVG. Binary DXF is not supported.
+ */
+export interface DxfLayer {
+    name: string;
+    color: string;
+    on: boolean;
+}
+export type DxfPrim = {
+    kind: 'line';
+    layer: string;
+    color: string;
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+} | {
+    kind: 'polyline';
+    layer: string;
+    color: string;
+    pts: [number, number][];
+    closed: boolean;
+} | {
+    kind: 'circle';
+    layer: string;
+    color: string;
+    cx: number;
+    cy: number;
+    r: number;
+} | {
+    kind: 'arc';
+    layer: string;
+    color: string;
+    cx: number;
+    cy: number;
+    r: number;
+    a0: number;
+    a1: number;
+} | {
+    kind: 'polygon';
+    layer: string;
+    color: string;
+    pts: [number, number][];
+} | {
+    kind: 'text';
+    layer: string;
+    color: string;
+    x: number;
+    y: number;
+    h: number;
+    text: string;
+    rot: number;
+    align: 'l' | 'c' | 'r';
+} | {
+    kind: 'point';
+    layer: string;
+    color: string;
+    x: number;
+    y: number;
+};
+export interface DxfBounds {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}
+export interface ParsedDxf {
+    prims: DxfPrim[];
+    layers: DxfLayer[];
+    bounds: DxfBounds | null;
+    counts: Record<string, number>;
+}
+export declare function parseDxf(text: string): ParsedDxf;

package/dist/lib/dxf.js

@@ -0,0 +1,399 @@
+//#region src/lib/dxf.ts
+var e = {
+	1: "#e03131",
+	2: "#f08c00",
+	3: "#2f9e44",
+	4: "#0c8599",
+	5: "#1971c2",
+	6: "#ae3ec9",
+	7: "#1a1a1a",
+	8: "#868e96",
+	9: "#adb5bd"
+};
+function t(t) {
+	if (e[t]) return e[t];
+	if (t >= 250 && t <= 255) {
+		let e = Math.round(51 + (t - 250) / 5 * 200);
+		return `rgb(${e},${e},${e})`;
+	}
+	return "#1a1a1a";
+}
+function n(e) {
+	let t = e.split(/\r\n|\r|\n/), n = [];
+	for (let e = 0; e + 1 < t.length; e += 2) {
+		let r = Number.parseInt(t[e].trim(), 10);
+		if (Number.isNaN(r)) {
+			--e;
+			continue;
+		}
+		n.push({
+			code: r,
+			value: t[e + 1]
+		});
+	}
+	return n;
+}
+function r(e, t, n) {
+	let r = [], i = null;
+	for (let a = t; a < n; a++) {
+		let t = e[a];
+		t.code === 0 ? (i && r.push(i), i = {
+			type: t.value.trim(),
+			pairs: []
+		}) : i && i.pairs.push(t);
+	}
+	return i && r.push(i), r;
+}
+function i(e, t) {
+	for (let n of e.pairs) if (n.code === t) return n.value;
+}
+function a(e, t, n = 0) {
+	let r = i(e, t);
+	if (r === void 0) return n;
+	let a = Number.parseFloat(r.trim());
+	return Number.isFinite(a) ? a : n;
+}
+function o(e, t, n = 0) {
+	let r = i(e, t);
+	if (r === void 0) return n;
+	let a = Number.parseInt(r.trim(), 10);
+	return Number.isFinite(a) ? a : n;
+}
+function s(e) {
+	let t = /* @__PURE__ */ new Map();
+	for (let n = 0; n + 1 < e.length; n++) if (e[n].code === 0 && e[n].value.trim() === "SECTION" && e[n + 1].code === 2) {
+		let r = e[n + 1].value.trim(), i = n + 2;
+		for (; i < e.length && !(e[i].code === 0 && e[i].value.trim() === "ENDSEC");) i++;
+		t.set(r, [n + 2, i]);
+	}
+	return t;
+}
+function c(e, n) {
+	let a = /* @__PURE__ */ new Map();
+	if (!n) return a;
+	for (let s of r(e, n[0], n[1])) {
+		if (s.type !== "LAYER") continue;
+		let e = (i(s, 2) ?? "").trim();
+		if (!e) continue;
+		let n = o(s, 62, 7);
+		a.set(e, {
+			name: e,
+			color: t(Math.abs(n)),
+			on: n >= 0
+		});
+	}
+	return a;
+}
+var l = {
+	a: 1,
+	b: 0,
+	c: 0,
+	d: 1,
+	e: 0,
+	f: 0
+};
+function u(e, t, n) {
+	return [e.a * t + e.c * n + e.e, e.b * t + e.d * n + e.f];
+}
+function d(e, t) {
+	return {
+		a: e.a * t.a + e.c * t.b,
+		b: e.b * t.a + e.d * t.b,
+		c: e.a * t.c + e.c * t.d,
+		d: e.b * t.c + e.d * t.d,
+		e: e.a * t.e + e.c * t.f + e.e,
+		f: e.b * t.e + e.d * t.f + e.f
+	};
+}
+function f(e) {
+	let t = a(e, 10), n = a(e, 20), r = a(e, 41, 1), i = a(e, 42, 1), o = a(e, 50, 0) * Math.PI / 180, s = Math.cos(o), c = Math.sin(o);
+	return {
+		a: s * r,
+		b: c * r,
+		c: -c * i,
+		d: s * i,
+		e: t,
+		f: n
+	};
+}
+function p(e) {
+	return (Math.hypot(e.a, e.b) + Math.hypot(e.c, e.d)) / 2 || 1;
+}
+function m(e) {
+	return Math.atan2(e.b, e.a) * 180 / Math.PI;
+}
+function h(e, t, n) {
+	if (!n) return [t];
+	let r = 4 * Math.atan(n), i = Math.hypot(t[0] - e[0], t[1] - e[1]);
+	if (i < 1e-9) return [t];
+	let a = i / 2 / Math.sin(Math.abs(r) / 2), o = [(e[0] + t[0]) / 2, (e[1] + t[1]) / 2], s = a * Math.cos(Math.abs(r) / 2), c = [(t[0] - e[0]) / i, (t[1] - e[1]) / i], l = n > 0 ? [c[1], -c[0]] : [-c[1], c[0]], u = o[0] + l[0] * s, d = o[1] + l[1] * s, f = Math.atan2(e[1] - d, e[0] - u), p = Math.max(2, Math.min(64, Math.ceil(Math.abs(r) / (Math.PI * 2) * 48))), m = [];
+	for (let e = 1; e <= p; e++) {
+		let t = f + r * e / p;
+		m.push([u + a * Math.cos(t), d + a * Math.sin(t)]);
+	}
+	return m;
+}
+function g(e) {
+	return e.replace(/\\P/g, "\n").replace(/\\[A-Za-z]+;?/g, "").replace(/[{}]/g, "").replace(/\\([{}\\])/g, "$1").trim();
+}
+function _(e) {
+	let h = n(e), _ = s(h), S = c(h, _.get("TABLES")), C = /* @__PURE__ */ new Map(), w = _.get("BLOCKS");
+	if (w) {
+		let e = r(h, w[0], w[1]), t = null;
+		for (let n of e) n.type === "BLOCK" ? t = {
+			name: (i(n, 2) ?? "").trim(),
+			base: [a(n, 10), a(n, 20)],
+			ents: []
+		} : n.type === "ENDBLK" ? (t && t.name && C.set(t.name, {
+			base: t.base,
+			ents: t.ents
+		}), t = null) : t && t.ents.push(n);
+	}
+	let T = [], E = {}, D = (e) => S.get(e)?.color ?? "#1a1a1a", O = (e, n, r) => {
+		let i = o(e, 62, 256);
+		return i === 0 || i === 256 ? i === 0 ? r : D(n) : t(Math.abs(i));
+	};
+	function k(e, t, n, r) {
+		for (let s = 0; s < e.length; s++) {
+			let c = e[s], h = c.type, _ = (i(c, 8) ?? "0").trim(), S = O(c, _, n), w = (e, n) => u(t, e, n);
+			switch (h) {
+				case "LINE": {
+					let [e, t] = w(a(c, 10), a(c, 20)), [n, r] = w(a(c, 11), a(c, 21));
+					T.push({
+						kind: "line",
+						layer: _,
+						color: S,
+						x1: e,
+						y1: t,
+						x2: n,
+						y2: r
+					});
+					break;
+				}
+				case "LWPOLYLINE": {
+					let e = y(v(c)), t = (o(c, 70, 0) & 1) == 1;
+					T.push({
+						kind: "polyline",
+						layer: _,
+						color: S,
+						pts: e.map(([e, t]) => w(e, t)),
+						closed: t
+					});
+					break;
+				}
+				case "POLYLINE": {
+					let t = [], n = s + 1;
+					for (; n < e.length && e[n].type === "VERTEX";) t.push({
+						pt: [a(e[n], 10), a(e[n], 20)],
+						bulge: a(e[n], 42, 0)
+					}), n++;
+					n < e.length && e[n].type === "SEQEND" && n++, s = n - 1;
+					let r = y(t.map((e) => ({
+						x: e.pt[0],
+						y: e.pt[1],
+						bulge: e.bulge
+					}))), i = (o(c, 70, 0) & 1) == 1;
+					r.length && T.push({
+						kind: "polyline",
+						layer: _,
+						color: S,
+						pts: r.map(([e, t]) => w(e, t)),
+						closed: i
+					});
+					break;
+				}
+				case "CIRCLE": {
+					let [e, n] = w(a(c, 10), a(c, 20));
+					T.push({
+						kind: "circle",
+						layer: _,
+						color: S,
+						cx: e,
+						cy: n,
+						r: a(c, 40) * p(t)
+					});
+					break;
+				}
+				case "ARC": {
+					let [e, n] = w(a(c, 10), a(c, 20)), r = m(t);
+					T.push({
+						kind: "arc",
+						layer: _,
+						color: S,
+						cx: e,
+						cy: n,
+						r: a(c, 40) * p(t),
+						a0: a(c, 50) + r,
+						a1: a(c, 51) + r
+					});
+					break;
+				}
+				case "ELLIPSE":
+					T.push({
+						kind: "polyline",
+						layer: _,
+						color: S,
+						pts: b(c, w),
+						closed: !1
+					});
+					break;
+				case "POINT": {
+					let [e, t] = w(a(c, 10), a(c, 20));
+					T.push({
+						kind: "point",
+						layer: _,
+						color: S,
+						x: e,
+						y: t
+					});
+					break;
+				}
+				case "TEXT": {
+					let e = (i(c, 1) ?? "").trim();
+					if (e) {
+						let [n, r] = w(a(c, 10), a(c, 20)), i = o(c, 72, 0);
+						T.push({
+							kind: "text",
+							layer: _,
+							color: S,
+							x: n,
+							y: r,
+							h: a(c, 40, 2.5) * p(t),
+							text: e,
+							rot: a(c, 50, 0) + m(t),
+							align: i === 1 ? "c" : i === 2 ? "r" : "l"
+						});
+					}
+					break;
+				}
+				case "MTEXT": {
+					let e = g(c.pairs.filter((e) => e.code === 1 || e.code === 3).map((e) => e.value).join(""));
+					if (e) {
+						let [n, r] = w(a(c, 10), a(c, 20)), i = o(c, 71, 1);
+						T.push({
+							kind: "text",
+							layer: _,
+							color: S,
+							x: n,
+							y: r,
+							h: a(c, 40, 2.5) * p(t),
+							text: e,
+							rot: a(c, 50, 0) + m(t),
+							align: i % 3 == 2 ? "c" : i % 3 == 0 ? "r" : "l"
+						});
+					}
+					break;
+				}
+				case "SOLID":
+				case "TRACE":
+				case "3DFACE": {
+					let e = w(a(c, 10), a(c, 20)), t = w(a(c, 11), a(c, 21)), n = w(a(c, 12), a(c, 22)), r = w(a(c, 13), a(c, 23)), i = h === "3DFACE" ? [
+						e,
+						t,
+						n,
+						r
+					] : [
+						e,
+						t,
+						r,
+						n
+					];
+					T.push({
+						kind: "polygon",
+						layer: _,
+						color: S,
+						pts: i
+					});
+					break;
+				}
+				case "SPLINE": {
+					let e = x(c, w);
+					e.length >= 2 && T.push({
+						kind: "polyline",
+						layer: _,
+						color: S,
+						pts: e,
+						closed: !1
+					});
+					break;
+				}
+				case "INSERT": {
+					if (r > 12) break;
+					let e = (i(c, 2) ?? "").trim(), n = C.get(e);
+					if (n) {
+						let e = {
+							...l,
+							e: -n.base[0],
+							f: -n.base[1]
+						}, i = d(f(c), e);
+						k(n.ents, d(t, i), S, r + 1);
+					}
+					break;
+				}
+				default: break;
+			}
+			h && h !== "VERTEX" && h !== "SEQEND" && (E[h] = (E[h] ?? 0) + 1);
+		}
+	}
+	let A = _.get("ENTITIES");
+	A && k(r(h, A[0], A[1]), l, "#1a1a1a", 0);
+	let j = Infinity, M = Infinity, N = -Infinity, P = -Infinity, F = (e, t) => {
+		e < j && (j = e), e > N && (N = e), t < M && (M = t), t > P && (P = t);
+	};
+	for (let e of T) if (e.kind === "line") F(e.x1, e.y1), F(e.x2, e.y2);
+	else if (e.kind === "polyline" || e.kind === "polygon") for (let [t, n] of e.pts) F(t, n);
+	else e.kind === "circle" || e.kind === "arc" ? (F(e.cx - e.r, e.cy - e.r), F(e.cx + e.r, e.cy + e.r)) : F(e.x, e.y);
+	let I = Number.isFinite(j) ? {
+		minX: j,
+		minY: M,
+		maxX: N,
+		maxY: P
+	} : null, L = new Set(T.map((e) => e.layer)), R = [];
+	for (let e of L) {
+		let t = S.get(e);
+		R.push(t ?? {
+			name: e,
+			color: "#1a1a1a",
+			on: !0
+		});
+	}
+	return R.sort((e, t) => e.name.localeCompare(t.name)), {
+		prims: T,
+		layers: R,
+		bounds: I,
+		counts: E
+	};
+}
+function v(e) {
+	let t = [], n = null;
+	for (let r of e.pairs) r.code === 10 ? (n && t.push(n), n = {
+		x: Number.parseFloat(r.value),
+		y: 0,
+		bulge: 0
+	}) : r.code === 20 && n ? n.y = Number.parseFloat(r.value) : r.code === 42 && n && (n.bulge = Number.parseFloat(r.value));
+	return n && t.push(n), t;
+}
+function y(e) {
+	if (!e.length) return [];
+	let t = [[e[0].x, e[0].y]];
+	for (let n = 0; n + 1 < e.length; n++) {
+		let r = [e[n].x, e[n].y], i = [e[n + 1].x, e[n + 1].y];
+		for (let a of h(r, i, e[n].bulge)) t.push(a);
+	}
+	return t;
+}
+function b(e, t) {
+	let n = a(e, 10), r = a(e, 20), i = a(e, 11), o = a(e, 21), s = a(e, 40, 1), c = a(e, 41, 0), l = a(e, 42, Math.PI * 2), u = Math.hypot(i, o), d = u * s, f = Math.atan2(o, i), p = Math.cos(f), m = Math.sin(f), h = l - c <= 0 ? l - c + Math.PI * 2 : l - c, g = Math.max(8, Math.min(96, Math.ceil(h / (Math.PI * 2) * 72))), _ = [];
+	for (let e = 0; e <= g; e++) {
+		let i = c + h * e / g, a = Math.cos(i) * u, o = Math.sin(i) * d;
+		_.push(t(n + a * p - o * m, r + a * m + o * p));
+	}
+	return _;
+}
+function x(e, t) {
+	let n = [], r = [], i = null;
+	for (let a of e.pairs) a.code === 11 ? i = Number.parseFloat(a.value) : a.code === 21 && i !== null ? (n.push(t(i, Number.parseFloat(a.value))), i = null) : a.code === 10 ? i = Number.parseFloat(a.value) : a.code === 20 && i !== null && (r.push(t(i, Number.parseFloat(a.value))), i = null);
+	return n.length ? n : r;
+}
+//#endregion
+export { _ as parseDxf };

package/dist/lib/eml.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Hand-rolled EML email parser — the email-specific flattening on top of the shared MIME core (lib/mime.ts).
+ *
+ * An `.eml` file is a MIME message; lib/mime.ts parses the container into an {@link Entity} tree and decodes
+ * each leaf. Here we flatten that tree into a render-ready shape for EmlViewer.vue: the header fields, the
+ * best body (HTML preferred, plain-text fallback), and the attachment + inline-image leaves. Email inline
+ * images are referenced from the HTML body by `cid:` (Content-ID), so we also index them by content-id.
+ */
+/** A non-body leaf: an attachment or an inline (cid-referenced) resource. */
+export interface EmlAttachment {
+    filename: string;
+    contentType: string;
+    size: number;
+    bytes: Uint8Array;
+    /** disposition:inline, or an image carrying a Content-ID (referenced from the HTML body via `cid:`). */
+    isInline: boolean;
+    /** Content-ID without the angle brackets, '' if none — the key the HTML body's `cid:` refs resolve to. */
+    contentId: string;
+}
+/** Flattened, render-ready view of a parsed email. */
+export interface ParsedEmail {
+    subject: string;
+    from: string;
+    to: string;
+    cc: string;
+    bcc: string;
+    replyTo: string;
+    /** Raw `Date:` header value (the viewer formats it for display). */
+    date: string;
+    /** Decoded text/html body, or null when the message has no HTML alternative. */
+    htmlBody: string | null;
+    /** Decoded text/plain body, or null when the message has no plain alternative. */
+    textBody: string | null;
+    /** Attachments + inline resources (inline ones are also indexed in {@link inlineById}). */
+    attachments: EmlAttachment[];
+    /** contentId → resource, for resolving `cid:` references in the HTML body to data URLs. */
+    inlineById: Map<string, EmlAttachment>;
+}
+/** Parse raw `.eml` bytes into a flattened {@link ParsedEmail}. */
+export declare function parseEml(bytes: Uint8Array): ParsedEmail;

package/dist/lib/eml.js

@@ -0,0 +1,46 @@
+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/eml.ts
+function c(e, t) {
+	let n = e.split("/")[1]?.replace(/[^a-z0-9.+-]/gi, "") || "bin";
+	return `attachment-${t + 1}.${n}`;
+}
+function l(l) {
+	let u = e(l), d = a(u), f = o(s(u)[0]), p = [];
+	t(d, p);
+	let m = null, h = null, g = [], _ = /* @__PURE__ */ new Map();
+	for (let e of p) {
+		let t = e.bodyBytes ?? new Uint8Array(), r = e.disposition === "attachment" || !!e.filename;
+		if (!r && e.contentType === "text/html" && m === null) {
+			m = n(t, e.charset);
+			continue;
+		}
+		if (!r && e.contentType === "text/plain" && h === null) {
+			h = n(t, e.charset);
+			continue;
+		}
+		let i = {
+			filename: e.filename || c(e.contentType, g.length),
+			contentType: e.contentType,
+			size: t.length,
+			bytes: t,
+			isInline: e.disposition === "inline" || !!e.contentId && e.contentType.startsWith("image/"),
+			contentId: e.contentId
+		};
+		g.push(i), e.contentId && _.set(e.contentId, i);
+	}
+	return {
+		subject: r(i(f, "subject")),
+		from: r(i(f, "from")),
+		to: r(i(f, "to")),
+		cc: r(i(f, "cc")),
+		bcc: r(i(f, "bcc")),
+		replyTo: r(i(f, "reply-to")),
+		date: i(f, "date"),
+		htmlBody: m,
+		textBody: h,
+		attachments: g,
+		inlineById: _
+	};
+}
+//#endregion
+export { l as parseEml };