renderpdf-js 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,1092 @@
+import e from "@pdf-lib/fontkit";
+import { PDFArray as t, PDFDict as n, PDFDocument as r, PDFHexString as i, PDFName as a, TextRenderingMode as o, beginText as s, clip as c, endPath as l, endText as u, popGraphicsState as d, pushGraphicsState as f, rectangle as p, rgb as m, setFillingColor as h, setFontAndSize as g, setGraphicsState as _, setTextMatrix as v, setTextRenderingMode as ee, showText as te } from "pdf-lib";
+import { toPng as y } from "html-to-image";
+// src/diagnostics.ts
+var b = class extends Error {
+	code;
+	constructor(e, t, n) {
+		super(t, n), this.code = e, this.name = "RenderPDFError";
+	}
+};
+function x(e) {
+	if (e?.aborted) throw new DOMException("PDF rendering was cancelled.", "AbortError");
+}
+// src/breaks.ts
+var S = /* @__PURE__ */ new Set([
+	"block",
+	"flow-root",
+	"flex",
+	"grid",
+	"table",
+	"table-caption",
+	"table-row",
+	"table-row-group",
+	"table-header-group",
+	"table-footer-group"
+]);
+function C(e, t) {
+	let n = e.getPropertyValue(`break-${t}`).trim(), r = e.getPropertyValue(`page-break-${t}`).trim();
+	return n && n !== "auto" ? n : r || n || "auto";
+}
+function w(e, t) {
+	if (e !== "auto" && e !== "avoid" && e !== "avoid-page" && (t === "inside" || e !== "page" && e !== "always")) throw new b("UNSUPPORTED_CSS", `Unsupported CSS break-${t}: ${e}; only page/always boundaries and avoid/avoid-page preferences are supported.`);
+}
+function T(e, t) {
+	let n = e.getBoundingClientRect();
+	return {
+		x: n.left - t.left,
+		y: n.top - t.top,
+		width: n.width,
+		height: n.height
+	};
+}
+function ne(e) {
+	let t = getComputedStyle(e), n = e.getBoundingClientRect();
+	return t.visibility === "visible" && S.has(t.display) && n.width > 0 && n.height > 0;
+}
+function re(e, t) {
+	let n = t === "previous" ? e.previousElementSibling : e.nextElementSibling;
+	for (; n;) {
+		if (!(n instanceof HTMLElement)) return;
+		let e = getComputedStyle(n);
+		if (e.display !== "none" && e.visibility === "visible") return ne(n) ? n : void 0;
+		n = t === "previous" ? n.previousElementSibling : n.nextElementSibling;
+	}
+}
+function ie(e, t) {
+	let n = Math.min(e.x, t.x), r = Math.min(e.y, t.y);
+	return {
+		x: n,
+		y: r,
+		width: Math.max(e.x + e.width, t.x + t.width) - n,
+		height: Math.max(e.y + e.height, t.y + t.height) - r
+	};
+}
+function ae(e, t) {
+	if (!e.isConnected || e.ownerDocument !== document) throw new b("INVALID_SOURCE", "CSS page-break collection requires a connected source in the current document.");
+	let n = e.getBoundingClientRect(), r = t.operations.filter((e) => e.kind === "raster"), i = /* @__PURE__ */ new Map(), a = [];
+	for (let t of [e, ...e.querySelectorAll("*")]) {
+		if (!(t instanceof HTMLElement)) continue;
+		let e = getComputedStyle(t);
+		if (e.display === "none" || e.visibility !== "visible") continue;
+		let o = t.getBoundingClientRect();
+		if (o.width === 0 && o.height === 0 && t.getClientRects().length === 0) continue;
+		let s = C(e, "before"), c = C(e, "after"), l = C(e, "inside");
+		w(s, "before"), w(c, "after"), w(l, "inside");
+		let u = r.find((e) => e.element.contains(t));
+		if (!u && S.has(e.display) && (e.widows && e.widows !== "2" || e.orphans && e.orphans !== "2")) throw new b("UNSUPPORTED_CSS", "Nondefault CSS widows/orphans are unsupported; this renderer preserves measured text lines without a line-count pagination policy.");
+		if (s === "auto" && c === "auto" && l === "auto") continue;
+		let d = s === "page" || s === "always", f = c === "page" || c === "always";
+		if (u && u.element !== t) {
+			if (d || f) throw new b("PAGINATION_FAILED", "A forced CSS page break lies inside an atomic raster region; move the break outside that region.");
+			continue;
+		}
+		if (!S.has(e.display)) throw new b("UNSUPPORTED_CSS", "Explicit CSS page breaks require a block, table group or table row; inline fragments and table cells are unsupported.");
+		let p = T(t, n);
+		d && a.push(p.y), f && a.push(p.y + p.height), l !== "auto" && !u && i.set(`${p.x}:${p.y}:${p.width}:${p.height}`, p);
+		for (let e of ["previous", "next"]) {
+			let r = e === "previous" ? s : c;
+			if (r !== "avoid" && r !== "avoid-page") continue;
+			let a = re(t, e);
+			if (!a) continue;
+			let o = ie(p, T(a, n));
+			i.set(`${o.x}:${o.y}:${o.width}:${o.height}`, o);
+		}
+	}
+	return {
+		forcedBreaks: a,
+		avoidBreakBounds: [...i.values()]
+	};
+}
+// src/fonts.ts
+var E = /* @__PURE__ */ new WeakMap(), D = /* @__PURE__ */ new WeakMap(), oe = /* @__PURE__ */ new Set([
+	"serif",
+	"sans-serif",
+	"monospace",
+	"cursive",
+	"fantasy",
+	"system-ui",
+	"ui-serif",
+	"ui-sans-serif",
+	"ui-monospace",
+	"ui-rounded",
+	"emoji",
+	"math",
+	"fangsong",
+	"inherit",
+	"initial",
+	"unset",
+	"revert",
+	"revert-layer"
+]);
+function O(e) {
+	if (e.byteLength < 12) throw new b("FONT_LOAD_FAILED", "Provide a complete static TTF/OTF font program.");
+	let t = new DataView(e.buffer, e.byteOffset, e.byteLength), n = t.getUint32(0);
+	if (n !== 65536 && n !== 1330926671) throw new b("FONT_LOAD_FAILED", "Only static TTF/OTF programs are supported; WOFF fonts and font collections are unsupported.");
+	let r = t.getUint16(4);
+	if (r === 0 || 12 + r * 16 > e.byteLength) throw new b("FONT_LOAD_FAILED", "The TTF/OTF font table directory is incomplete.");
+	for (let e = 0; e < r; e += 1) if (t.getUint32(12 + e * 16) === 1719034226) throw new b("FONT_LOAD_FAILED", "Variable fonts are unsupported. Provide an explicitly generated static TTF/OTF instance.");
+}
+function k(e, t, n, r, i) {
+	for (let a of e.fonts) {
+		if (a === i || a.family.replace(/^["']|["']$/g, "").toLowerCase() !== t.toLowerCase() || a.style !== r) continue;
+		let e = a.weight === "normal" ? [400] : a.weight === "bold" ? [700] : a.weight.split(/\s+/).map(Number);
+		if (e[0] === n || e.length === 2 && n >= e[0] && n <= e[1]) throw new b("INVALID_OPTIONS", `Font ${t} ${n} ${r} conflicts with an existing browser font face. Choose a family owned by this registration.`);
+	}
+}
+function A(e) {
+	for (let t of e) {
+		let e = t && typeof t == "object" ? D.get(t) : void 0;
+		if (!e || typeof document > "u" || e.document !== document || !document.fonts.has(e.face)) throw new b("MISSING_FONT", "Provide font handles returned by registerFont() whose browser faces remain registered in the current document.");
+		k(document, t.family, t.weight, t.style, e.face);
+	}
+}
+async function se(e) {
+	if (!e || typeof e != "object" || typeof e.family != "string") throw new b("INVALID_OPTIONS", "Font registration requires a CSS family and font bytes.");
+	let t = e.family.trim(), n = e.weight ?? 400, r = e.style ?? "normal";
+	if (!t || !/^[\w -]+$/.test(t) || oe.has(t.toLowerCase()) || !Number.isInteger(n) || n < 1 || n > 1e3 || r !== "normal" && r !== "italic" || !(e.data instanceof Uint8Array) && !(e.data instanceof ArrayBuffer) || e.data.byteLength === 0) throw new b("INVALID_OPTIONS", "Provide a plain custom CSS family (letters, digits, spaces, hyphens, or underscores), nonempty TTF/OTF bytes, integer weight from 1 to 1000, and normal or italic style.");
+	if (typeof document > "u" || typeof FontFace > "u" || !document.fonts) throw new b("FONT_LOAD_FAILED", "Font registration requires a browser document with FontFace support.");
+	let i = new Uint8Array(e.data instanceof Uint8Array ? e.data : new Uint8Array(e.data));
+	O(i);
+	let a = `${t.toLowerCase()}:${n}:${r}`, o = document, s = E.get(o);
+	s || (s = /* @__PURE__ */ new Map(), E.set(o, s));
+	let c = s.get(a);
+	if (k(o, t, n, r, c?.face), c) {
+		if (c.bytes.length !== i.length || c.bytes.some((e, t) => e !== i[t])) throw new b("INVALID_OPTIONS", `Font ${t} ${n} ${r} is already registered with different bytes.`);
+		return c.promise;
+	}
+	async function l() {
+		try {
+			let e = new FontFace(t, i, {
+				weight: String(n),
+				style: r
+			});
+			await e.load(), k(o, t, n, r), o.fonts.add(e), d.face = e;
+			let a = Object.freeze({
+				family: t,
+				weight: n,
+				style: r,
+				get bytes() {
+					return i.slice();
+				}
+			});
+			return D.set(a, {
+				document: o,
+				face: e
+			}), a;
+		} catch (e) {
+			throw s.delete(a), e instanceof b ? e : new b("FONT_LOAD_FAILED", `Could not load font ${t} ${n} ${r}.`, { cause: e });
+		}
+	}
+	let u = Promise.resolve().then(l), d = {
+		bytes: i,
+		promise: u
+	};
+	return s.set(a, d), u;
+}
+// src/planner.ts
+var j = /^data:image\/(?:png|jpeg|gif|webp|avif);base64,[a-z\d+/=\s]+$/i;
+function M(e) {
+	let t = 0, n = "", r = 0, i = [];
+	for (let a = 0; a < e.length; a += 1) {
+		let o = e[a];
+		o === "\\" ? a += 1 : n ? o === n && (n = "") : o === "\"" || o === "'" ? n = o : o === "(" ? t += 1 : o === ")" ? --t : o === "," && t === 0 && (i.push(e.slice(r, a).trim()), r = a + 1);
+	}
+	return i.push(e.slice(r).trim()), i;
+}
+function N(e) {
+	let t = [];
+	if (e.backgroundImage !== "none") {
+		for (let t of M(e.backgroundImage)) {
+			if (/^(?:repeating-)?(?:linear|radial|conic)-gradient\(/i.test(t)) continue;
+			let e = t.match(/^url\(\s*(["']?)(.*?)\1\s*\)$/i)?.[2];
+			if (!e || !j.test(e)) throw new b("UNSUPPORTED_CSS", "Unsupported CSS: automatic raster backgrounds require gradients or inline bitmap URLs.");
+		}
+		t.push("background-image");
+	}
+	if (e.borderRadius !== "0px" && t.push("border-radius"), e.boxShadow !== "none") {
+		if (M(e.boxShadow).some((e) => !/\binset\b/.test(e))) throw new b("UNSUPPORTED_CSS", "Unsupported CSS: outer shadows require expanded capture bounds; only inset shadows can fall back automatically.");
+		t.push("inset box-shadow");
+	}
+	return e.opacity !== "1" && t.push("opacity"), t.length ? t.join(", ") : void 0;
+}
+function ce(e, t) {
+	if (!(e instanceof HTMLImageElement) && ![
+		"block",
+		"flow-root",
+		"inline-block",
+		"flex",
+		"inline-flex",
+		"grid",
+		"inline-grid"
+	].includes(t.display)) throw new b("UNSUPPORTED_CSS", "Automatic raster fallback requires a rectangular block, flex, grid, inline-block, or image boundary; wrap inline or table-internal effects in a supported block.");
+	if (Array.from(e.getClientRects()).filter((e) => e.width > 0 && e.height > 0).length !== 1) throw new b("UNSUPPORTED_CSS", "Automatic raster fallback cannot capture fragmented inline or multi-column regions.");
+}
+// src/layout.ts
+var le = new Intl.Segmenter("en", { granularity: "grapheme" });
+function P(e, t) {
+	if (![
+		e.x,
+		e.y,
+		e.width,
+		e.height
+	].every(Number.isFinite)) throw new b("INVALID_SOURCE", "Browser geometry must contain only finite CSS pixel values.");
+	return {
+		x: e.left - t.left,
+		y: e.top - t.top,
+		width: e.width,
+		height: e.height
+	};
+}
+function F(e) {
+	let t = e.getRootNode();
+	return e.parentElement ?? (t instanceof ShadowRoot && t.host instanceof HTMLElement ? t.host : null);
+}
+function I(e, t, n = !1) {
+	let r = e instanceof HTMLImageElement, i = [
+		t.position !== "static" && `position: ${t.position}`,
+		t.zIndex !== "auto" && `z-index: ${t.zIndex}`,
+		t.transform !== "none" && "transform",
+		t.filter !== "none" && "filter",
+		t.backdropFilter !== "none" && "backdrop-filter",
+		t.mixBlendMode !== "normal" && "mix-blend-mode",
+		t.opacity !== "1" && !n && "opacity",
+		t.clipPath !== "none" && "clip-path",
+		t.maskImage !== "none" && "mask-image",
+		t.backgroundImage !== "none" && !n && "background-image",
+		t.boxShadow !== "none" && !n && "box-shadow",
+		t.borderRadius !== "0px" && !n && "border-radius",
+		t.overflowX !== "visible" && !(r && t.overflowX === "clip") && "overflow-x",
+		t.overflowY !== "visible" && !(r && t.overflowY === "clip") && "overflow-y",
+		t.cssFloat !== "none" && "float",
+		t.order !== "0" && "order",
+		t.direction !== "ltr" && "direction",
+		t.writingMode !== "horizontal-tb" && "writing-mode",
+		t.textShadow !== "none" && "text-shadow",
+		t.textDecorationLine !== "none" && "text-decoration",
+		t.textTransform !== "none" && "text-transform",
+		t.letterSpacing !== "normal" && t.letterSpacing !== "0px" && "letter-spacing",
+		t.wordSpacing !== "normal" && t.wordSpacing !== "0px" && "word-spacing",
+		t.whiteSpace !== "normal" && "white-space",
+		t.columnCount !== "auto" && t.columnCount !== "1" && "columns",
+		t.outlineStyle !== "none" && "outline",
+		t.borderImageSource !== "none" && "border-image",
+		t.boxDecorationBreak === "clone" && "box-decoration-break: clone",
+		t.zoom !== "1" && "zoom",
+		[
+			"marginTop",
+			"marginRight",
+			"marginBottom",
+			"marginLeft"
+		].some((e) => Number.parseFloat(t.getPropertyValue(e.replace(/[A-Z]/g, (e) => `-${e.toLowerCase()}`))) < 0) && "negative margins"
+	].filter(Boolean);
+	for (let t of ["::before", "::after"]) {
+		let n = getComputedStyle(e, t).content;
+		n !== "none" && n !== "normal" && i.push(`generated content ${t}`);
+	}
+	if (i.length > 0) throw new b("UNSUPPORTED_CSS", `Unsupported CSS on ${e.tagName}: ${i.join(", ")}. Use a bounded data-raster subtree when safe.`);
+	if (e instanceof HTMLTableElement && t.borderCollapse !== "separate") throw new b("UNSUPPORTED_CSS", "Native table snapshots require separate borders; collapsed borders are unsupported.");
+	if ([
+		"THEAD",
+		"TBODY",
+		"TFOOT",
+		"TR",
+		"COL",
+		"COLGROUP"
+	].includes(e.tagName) && t.backgroundColor !== "rgba(0, 0, 0, 0)") throw new b("UNSUPPORTED_CSS", "Native table snapshots require transparent row-group, row, and column backgrounds.");
+	let a = [
+		"Top",
+		"Right",
+		"Bottom",
+		"Left"
+	], o = a.map((e) => t[`border${e}Width`]), s = a.map((e) => t[`border${e}Color`]), c = a.map((e) => t[`border${e}Style`]);
+	if (o.some((e) => e !== o[0]) || o[0] !== "0px" && (s.some((e) => e !== s[0]) || c.some((e) => e !== "solid"))) throw new b("UNSUPPORTED_CSS", "Unsupported CSS: only uniform solid borders are supported.");
+	if (!n && (t.backgroundColor !== "rgba(0, 0, 0, 0)" || o[0] !== "0px") && Array.from(e.getClientRects()).filter((e) => e.width > 0 && e.height > 0).length > 1) throw new b("UNSUPPORTED_CSS", "Fragmented inline backgrounds and borders require an explicit containing raster region.");
+}
+function L(e, t) {
+	if (!(e instanceof HTMLImageElement) && ![
+		"block",
+		"flow-root",
+		"inline",
+		"inline-block",
+		"flex",
+		"inline-flex",
+		"grid",
+		"inline-grid",
+		"table",
+		"inline-table",
+		"table-caption",
+		"table-header-group",
+		"table-row-group",
+		"table-footer-group",
+		"table-row",
+		"table-cell",
+		"table-column-group",
+		"table-column"
+	].includes(t.display)) throw new b("UNSUPPORTED_CSS", `Unsupported CSS display: ${t.display}.`);
+}
+function R(e, t, n, r, i) {
+	let a = e.parentElement;
+	if (!a || !e.data.replace(/[\t\n\r\f ]+/g, "")) return [];
+	let o = getComputedStyle(a), s = o.fontFamily.split(",")[0]?.trim().replace(/^['"]|['"]$/g, ""), c = Number(o.fontWeight), l = n.find((e) => e.family.toLowerCase() === s?.toLowerCase() && e.weight === c && e.style === o.fontStyle);
+	if (!l) throw new b("MISSING_FONT", `No exact registered font face for ${o.fontFamily} ${o.fontWeight} ${o.fontStyle}.`);
+	if (o.direction !== "ltr" || o.writingMode !== "horizontal-tb" || o.textTransform !== "none" || o.whiteSpace !== "normal" || e.data.includes("­") || o.hyphens === "auto" || o.letterSpacing !== "normal" && o.letterSpacing !== "0px" || o.wordSpacing !== "normal" && o.wordSpacing !== "0px" || o.fontVariantCaps !== "normal" || o.fontVariantAlternates !== "normal" || o.fontVariantLigatures !== "normal" || o.fontVariantNumeric !== "normal" || o.fontVariantEastAsian !== "normal" || o.fontVariantPosition !== "normal" || o.fontFeatureSettings !== "normal" || o.fontVariationSettings !== "normal" || o.fontStretch !== "100%" && o.fontStretch !== "normal" || o.fontSizeAdjust !== "none" && o.fontSizeAdjust !== void 0 || !["auto", "geometricPrecision"].includes(o.textRendering)) throw new b("UNSUPPORTED_CSS", "Unsupported CSS: text requires horizontal LTR layout with normal whitespace, spacing, font variants and OpenType features, without automatic hyphenation or soft hyphens.");
+	let u = Number.parseFloat(o.fontSize), d = `${l.style} ${l.weight} ${u}px "${l.family}"`, f = r.fonts.get(d);
+	if (!f) {
+		if (!Array.from(document.fonts).some((e) => {
+			let t = e.weight === "normal" ? 400 : e.weight === "bold" ? 700 : Number(e.weight);
+			return e.family.replace(/^['"]|['"]$/g, "").toLowerCase() === l.family.toLowerCase() && t === l.weight && e.style === l.style && e.status === "loaded";
+		}) || !document.fonts.check(d, e.data)) throw new b("MISSING_FONT", `Browser font is not loaded: ${d}.`);
+		r.context.font = d;
+		let t = r.context.measureText(e.data), n = t.fontBoundingBoxAscent, i = t.fontBoundingBoxDescent;
+		if (!Number.isFinite(n) || !Number.isFinite(i)) throw new b("UNSUPPORTED_CSS", "Font bounding metrics are unavailable in this browser.");
+		f = {
+			ascent: n,
+			descent: i
+		}, r.fonts.set(d, f);
+	}
+	let { ascent: p, descent: m } = f, h = le.segment(e.data), g = document.createRange(), _ = [];
+	for (let t of h) {
+		g.setStart(e, t.index), g.setEnd(e, t.index + t.segment.length);
+		let n = Array.from(g.getClientRects()), r = n.find((e) => e.width > 0 && e.height > 0);
+		if (!r) {
+			if (/[^\t\n\r\f ]/.test(t.segment) && n.some((e) => e.height > 0 && e.width === 0)) throw new b("UNSUPPORTED_CSS", "Text shaping crosses an inline boundary or uses an unsupported zero-width glyph. Keep each shaped word in one text node.");
+			continue;
+		}
+		let i = _.at(-1);
+		i && Math.abs(i.top - r.top) < .5 ? i.end = t.index + t.segment.length : _.push({
+			start: t.index,
+			end: t.index + t.segment.length,
+			top: r.top
+		});
+	}
+	return _.flatMap((n) => {
+		let r = n.start, a = n.end;
+		for (; r < a && /[\t\n\r\f ]/.test(e.data[r]);) r += 1;
+		for (; a > r && /[\t\n\r\f ]/.test(e.data[a - 1]);) --a;
+		if (r === a) return [];
+		g.setStart(e, r), g.setEnd(e, a);
+		let s = e.data.slice(r, a), c = s.replace(/[\t\n\r\f ]+/g, " "), d = P(g.getBoundingClientRect(), t);
+		return [{
+			kind: "text",
+			bounds: d,
+			text: c,
+			runs: Array.from(s.matchAll(/[^\t\n\r\f ]+/g), (n) => {
+				g.setStart(e, r + n.index), g.setEnd(e, r + n.index + n[0].length);
+				let i = P(g.getBoundingClientRect(), t);
+				return {
+					text: n[0],
+					x: i.x,
+					width: i.width
+				};
+			}),
+			baseline: d.y + (d.height - p - m) / 2 + p,
+			fontSize: u,
+			family: l.family,
+			weight: l.weight,
+			style: l.style,
+			kerning: o.fontKerning !== "none",
+			color: o.color,
+			invisible: i
+		}];
+	});
+}
+function z(e, t, n) {
+	if (n !== "auto" && n !== "strict") throw new b("INVALID_OPTIONS", "Raster fallback must be auto or strict.");
+	if (!(e instanceof HTMLElement) || e.ownerDocument !== document || !e.isConnected || t.length === 0) throw new b("INVALID_SOURCE", "A connected source root and registered fonts are required.");
+	if (new Set(t.map((e) => `${e.family.toLowerCase()}:${e.weight}:${e.style}`)).size !== t.length) throw new b("INVALID_OPTIONS", "Registered fonts require unique family/weight/style descriptors.");
+	for (let t = F(e); t; t = F(t)) {
+		let e = getComputedStyle(t);
+		if (e.transform !== "none" || e.filter !== "none" || e.opacity !== "1" || e.clipPath !== "none" || e.maskImage !== "none" || e.mixBlendMode !== "normal" || e.zoom !== "1" || e.overflowX !== "visible" || e.overflowY !== "visible") throw new b("UNSUPPORTED_CSS", "Unsupported CSS: source ancestors must not transform, clip, blend, or fade the source.");
+	}
+}
+function B(e, t, n = {}) {
+	let r = n.fallback ?? "auto";
+	z(e, t, r);
+	let i = e.getBoundingClientRect();
+	if (i.width <= 0 || i.height <= 0) throw new b("INVALID_SOURCE", "The source root must have positive visible dimensions.");
+	let a = document.createElement("canvas").getContext("2d");
+	if (!a) throw new b("INVALID_SOURCE", "Canvas font measurement is unavailable.");
+	let o = {
+		context: a,
+		fonts: /* @__PURE__ */ new Map()
+	}, s = [], c = [], l = [{
+		code: "TEXT_METRICS_APPROXIMATED",
+		message: "Baselines are estimated from Canvas font metrics; browser and PDF shaping engines may still differ for unsupported scripts or font features."
+	}];
+	function u(e, n, a = !1) {
+		let d = getComputedStyle(e);
+		if (d.display === "none") return;
+		if (d.visibility !== "visible") {
+			if (!n || a) throw new b("UNSUPPORTED_CSS", "Unsupported CSS: visibility overrides are not supported.");
+			l.push({
+				code: "RASTER_TEXT_OMITTED",
+				message: `Raster text extraction omitted for visibility-controlled subtree ${e.tagName}.`
+			});
+			return;
+		}
+		if ((!n || a) && !(/* @__PURE__ */ "MAIN.SECTION.ARTICLE.DIV.SPAN.P.H1.H2.H3.H4.H5.H6.STRONG.EM.B.I.IMG.FONT.CENTER.BR.HR.TABLE.THEAD.TBODY.TFOOT.TR.TH.TD.CAPTION.COLGROUP.COL".split(".")).includes(e.tagName)) throw new b("UNSUPPORTED_ELEMENT", `Native snapshots do not support ${e.tagName}.`);
+		let f = !n && e.hasAttribute("data-raster"), p = !n && !f && r === "auto" ? N(d) : void 0, m = a || p !== void 0;
+		if (m && (a && N(d), I(e, d, !0), L(e, d)), n && (d.transform !== "none" || d.writingMode !== "horizontal-tb" || d.direction !== "ltr" || d.opacity === "0" || d.clipPath !== "none" || d.maskImage !== "none" || d.overflowX !== "visible" || d.overflowY !== "visible")) {
+			l.push({
+				code: "RASTER_TEXT_OMITTED",
+				message: `Raster text extraction omitted for transformed, clipped, hidden, masked, or non-LTR subtree ${e.tagName}.`
+			});
+			return;
+		}
+		let h = P(e.getBoundingClientRect(), i);
+		if (!n && (h.x < -.1 || h.y < -.1 || h.x + h.width > i.width + .1 || h.y + h.height > i.height + .1)) throw new b("SOURCE_OVERFLOW", "Source content must fit within the root border box.");
+		let g = f || p !== void 0;
+		if (g) {
+			if (d.position !== "static" || d.transform !== "none" || d.mixBlendMode !== "normal") throw new b("UNSUPPORTED_CSS", "A raster boundary must be static, untransformed, and independently compositable.");
+			if (p !== void 0 && ce(e, d), s.push({
+				kind: "raster",
+				bounds: h,
+				element: e
+			}), l.push({
+				code: "RASTER_FALLBACK",
+				message: `${p === void 0 ? "An explicit raster subtree" : `Automatic raster fallback on ${e.tagName} for ${p}`} uses invisible PDF text for extraction where supported; generated content and clipped or transformed text are not represented.`
+			}), d.overflowX !== "visible" || d.overflowY !== "visible" || d.clipPath !== "none" || d.maskImage !== "none" || d.opacity === "0") {
+				l.push({
+					code: "RASTER_TEXT_OMITTED",
+					message: `Raster text extraction omitted for clipped, masked, or hidden boundary ${e.tagName}.`
+				});
+				return;
+			}
+		} else if (!n) {
+			if (I(e, d), L(e, d), (e instanceof HTMLTableRowElement || e instanceof HTMLTableCellElement && e.rowSpan !== 1) && c.push(h), e instanceof HTMLImageElement) {
+				if (d.objectFit !== "fill" || d.borderTopWidth !== "0px") throw new b("UNSUPPORTED_CSS", "Image boxes require object-fit: fill without borders.");
+				if ([
+					"paddingTop",
+					"paddingRight",
+					"paddingBottom",
+					"paddingLeft"
+				].some((e) => Number.parseFloat(d.getPropertyValue(e.replace(/[A-Z]/g, (e) => `-${e.toLowerCase()}`))) !== 0) || d.backgroundColor !== "rgba(0, 0, 0, 0)") throw new b("UNSUPPORTED_CSS", "Image boxes require zero padding and a transparent background.");
+				s.push({
+					kind: "image",
+					bounds: h,
+					element: e
+				});
+			} else [
+				"BR",
+				"COL",
+				"COLGROUP"
+			].includes(e.tagName) || s.push({
+				kind: "box",
+				bounds: h,
+				background: d.backgroundColor,
+				borderColor: d.borderTopColor,
+				borderWidth: Number.parseFloat(d.borderTopWidth)
+			});
+		}
+		let _ = n || g;
+		if (!_ || m) {
+			let t = Array.from(e.children).filter((e) => e instanceof HTMLElement && getComputedStyle(e).display !== "none" && getComputedStyle(e).visibility !== "hidden").map((e) => e.getBoundingClientRect());
+			for (let e = 0; e < t.length; e += 1) for (let n = e + 1; n < t.length; n += 1) {
+				let r = t[e], i = t[n];
+				if (Math.min(r.right, i.right) - Math.max(r.left, i.left) > .1 && Math.min(r.bottom, i.bottom) - Math.max(r.top, i.top) > .1) throw new b("UNSUPPORTED_CSS", "Overlapping sibling boxes are unsupported; isolate them in one raster subtree.");
+			}
+		}
+		for (let n of e.childNodes) if (n instanceof Text) s.push(...R(n, i, t, o, _));
+		else if (n instanceof HTMLElement) u(n, _, m);
+		else if (n instanceof Element) {
+			if (_) l.push({
+				code: "RASTER_TEXT_OMITTED",
+				message: `Raster text extraction omitted for ${n.tagName}.`
+			});
+			else throw new b("UNSUPPORTED_ELEMENT", `Cannot snapshot ${n.tagName}; use a raster subtree.`);
+		}
+	}
+	u(e, !1);
+	let d = [];
+	for (let e of s) {
+		if (e.kind === "text") {
+			e.invisible || d.push(e);
+			continue;
+		}
+		if (e.kind === "box" && (e.background.startsWith("rgba(") ? Number(e.background.slice(e.background.lastIndexOf(",") + 1, -1)) : 1) === 0 && e.borderWidth === 0) continue;
+		let t = e.bounds;
+		if (d.some((e) => Math.min(e.bounds.x + e.bounds.width, t.x + t.width) - Math.max(e.bounds.x, t.x) > .1 && Math.min(e.bounds.y + e.bounds.height, t.y + t.height) - Math.max(e.bounds.y, t.y) > .1)) throw new b("UNSUPPORTED_CSS", "Text overlaps later visible paint whose CSS paint phases cannot be represented safely; use an explicit containing raster region.");
+	}
+	if (s.some((e) => {
+		if (e.kind === "text" && e.invisible) return !1;
+		let t = e.bounds;
+		return t.x < -.1 || t.y < -.1 || t.x + t.width > i.width + .1 || t.y + t.height > i.height + .1;
+	})) throw new b("SOURCE_OVERFLOW", "Visible source text or paint overflows the root border box.");
+	return {
+		width: i.width,
+		height: i.height,
+		operations: s,
+		warnings: l,
+		atomicBounds: c
+	};
+}
+// src/page.ts
+function V(e) {
+	if (!e || !Array.isArray(e.fonts) || e.fonts.length === 0) throw new b("INVALID_OPTIONS", "Provide at least one explicitly registered font.");
+	let t = {
+		A4: [595.28, 841.89],
+		A3: [841.89, 1190.55],
+		Letter: [612, 792]
+	}, n = e.format ?? "A4";
+	if (typeof n != "object" && !Object.hasOwn(t, n)) throw new b("INVALID_OPTIONS", `Unsupported page format: ${n}.`);
+	let r = e.orientation ?? "portrait";
+	if (r !== "portrait" && r !== "landscape") throw new b("INVALID_OPTIONS", `Unsupported page orientation: ${r}.`);
+	let i = e.margin ?? 24, a = typeof i == "number" ? {
+		top: i,
+		right: i,
+		bottom: i,
+		left: i
+	} : {
+		top: i?.top,
+		right: i?.right,
+		bottom: i?.bottom,
+		left: i?.left
+	};
+	if (Object.values(a).some((e) => !Number.isFinite(e) || e < 0)) throw new b("INVALID_OPTIONS", "Every page margin must be finite and nonnegative.");
+	let o = typeof n == "object" ? [n?.width, n?.height] : t[n].map((e) => e / .75);
+	if (o.some((e) => !Number.isFinite(e) || e <= 0)) throw new b("INVALID_OPTIONS", "Custom page width and height must be finite positive CSS pixel values.");
+	let s = o[r === "portrait" ? 0 : 1], c = o[+(r === "portrait")];
+	if (a.left + a.right >= s || a.top + a.bottom >= c) throw new b("INVALID_OPTIONS", "Page margins leave no positive content area.");
+	if (e.rasterScale !== void 0 && (!Number.isFinite(e.rasterScale) || e.rasterScale <= 0)) throw new b("INVALID_OPTIONS", "Raster scale must be a finite positive number.");
+	if (e.onWarning !== void 0 && typeof e.onWarning != "function") throw new b("INVALID_OPTIONS", "onWarning must be a function.");
+	if (e.fallback !== void 0 && !["auto", "strict"].includes(e.fallback)) throw new b("INVALID_OPTIONS", "fallback must be auto or strict.");
+	if (e.pageBreak !== void 0 && !["auto", "css"].includes(e.pageBreak)) throw new b("INVALID_OPTIONS", "pageBreak must be auto or css.");
+	if (e.signal !== void 0 && !(e.signal instanceof AbortSignal)) throw new b("INVALID_OPTIONS", "signal must be an AbortSignal.");
+	return {
+		width: s,
+		height: c,
+		margin: a
+	};
+}
+// src/pagination.ts
+var H = .01;
+function U(e, t, n) {
+	if (![
+		e.x,
+		e.y,
+		e.width,
+		e.height
+	].every(Number.isFinite) || e.width < 0 || e.height < 0 || e.y < -.01 || e.y + e.height > t + H) throw new b("PAGINATION_FAILED", `${n} geometry must be finite, nonnegative and within the source height.`);
+}
+function W(e, t) {
+	return e.y < t - H && e.y + e.height > t + H;
+}
+function ue(e, t, n) {
+	let r = e;
+	for (;;) {
+		let e = n.reduce((e, t) => W(t, r) ? Math.min(e, t.y) : e, r);
+		if (e === r) return r;
+		if (e <= t + H) throw new b("PAGINATION_FAILED", "Overlapping atomic items cannot fit on one page.");
+		r = e;
+	}
+}
+function de(e, t, n) {
+	if (!Number.isFinite(t) || t <= 0) throw new b("PAGINATION_FAILED", "Page content height must be finite and positive.");
+	if (!Number.isFinite(e.height) || e.height <= 0) throw new b("PAGINATION_FAILED", "Source height must be finite and positive.");
+	let r = [], i = [...e.operations.filter((e) => e.kind !== "box").map((e) => e.bounds), ...e.atomicBounds ?? []];
+	for (let n of i) if (U(n, e.height, "Atomic"), n.height > t + H) throw new b("PAGINATION_FAILED", "An atomic item is taller than one page; this renderer cannot split it.");
+	let a = e.forcedBreaks ?? [];
+	for (let t of a) if (!Number.isFinite(t) || t < 0 || t > e.height) throw new b("PAGINATION_FAILED", "Forced page breaks must lie within the finite source height.");
+	let o = [...new Set(a)].filter((t) => t > H && t < e.height - H).sort((e, t) => e - t).filter((e, t, n) => t === 0 || e - n[t - 1] > H);
+	for (let e of o) if (i.some((t) => W(t, e))) throw new b("PAGINATION_FAILED", "A forced CSS page break crosses an atomic text, image, raster, table row or spanning cell.");
+	let s = !1;
+	function c() {
+		s || (s = !0, n?.({
+			code: "BREAK_AVOID_RELAXED",
+			message: "A CSS break-avoid preference could not fit on one page and was relaxed; native text, images and table rows remain indivisible."
+		}));
+	}
+	let l = [];
+	for (let n of e.avoidBreakBounds ?? []) U(n, e.height, "Preferred break-avoid"), !o.some((e) => W(n, e)) && (n.height > t + H ? c() : l.push(n));
+	let u = [...i, ...l], d = 0, f = 0;
+	for (; d < e.height;) {
+		for (; o[f] !== void 0 && o[f] <= d + H;) f += 1;
+		let n = o[f] ?? e.height, a = Math.min(d + t, n, e.height), s = ue(a, d, i), l = s;
+		if (Math.abs(a - n) > H) for (;;) {
+			let e = u.reduce((e, t) => W(t, l) ? Math.min(e, t.y) : e, l);
+			if (e === l) break;
+			if (e <= d + H) {
+				c(), l = s;
+				break;
+			}
+			l = e;
+		}
+		r.push({
+			start: d,
+			end: l
+		}), d = l;
+	}
+	return r;
+}
+// src/images.ts
+function G() {
+	throw new b("RESOURCE_LOAD_FAILED", "JPEG EXIF orientation must be 1 with valid metadata; normalize the image pixels and remove orientation metadata before exporting.");
+}
+function fe(e, t, n) {
+	let r = new DataView(e.buffer, e.byteOffset + t, n - t);
+	r.byteLength < 8 && G();
+	let i = r.getUint16(0);
+	i !== 18761 && i !== 19789 && G();
+	let a = i === 18761;
+	r.getUint16(2, a) !== 42 && G();
+	let o = r.getUint32(4, a);
+	(o < 8 || o + 2 > r.byteLength) && G();
+	let s = r.getUint16(o, a), c = o + 2 + s * 12;
+	c + 4 > r.byteLength && G();
+	let l = !1;
+	for (let e = 0; e < s; e += 1) {
+		let t = o + 2 + e * 12;
+		r.getUint16(t, a) === 274 && ((l || r.getUint16(t + 2, a) !== 3 || r.getUint32(t + 4, a) !== 1 || r.getUint16(t + 8, a) !== 1) && G(), l = !0);
+	}
+	let u = r.getUint32(c, a);
+	u !== 0 && (u < 8 || u + 2 > r.byteLength) && G();
+}
+function pe(e) {
+	if (e[0] === 137 && e[1] === 80 && e[2] === 78 && e[3] === 71 && e[4] === 13 && e[5] === 10 && e[6] === 26 && e[7] === 10) return "png";
+	if (e[0] !== 255 || e[1] !== 216) throw new b("RESOURCE_LOAD_FAILED", "Native PDF images require PNG or JPEG bytes.");
+	let t = 2;
+	for (; t < e.length;) {
+		for (e[t] !== 255 && G(); e[t] === 255;) t += 1;
+		let n = e[t];
+		if ((n === void 0 || n === 0) && G(), t += 1, n === 217) return "jpeg";
+		if (n === 1 || n >= 208 && n <= 215) continue;
+		t + 2 > e.length && G();
+		let r = e[t] * 256 + e[t + 1], i = t + r;
+		if ((r < 2 || i > e.length) && G(), n === 218) return "jpeg";
+		let a = t + 2;
+		n === 225 && i - a >= 4 && e[a] === 69 && e[a + 1] === 120 && e[a + 2] === 105 && e[a + 3] === 102 && ((i - a < 6 || e[a + 4] !== 0 || e[a + 5] !== 0) && G(), fe(e, a + 6, i)), t = i;
+	}
+	G();
+}
+// src/raster.ts
+var me = 16777216, K = 8192, q = /^data:image\/(?:png|jpeg|gif|webp|avif);base64,[a-z\d+/=\s]+$/i;
+function he(e) {
+	let t = e.bytes;
+	if (!/^[\w -]+$/.test(e.family) || t.byteLength === 0) throw new b("RASTER_FAILED", "Raster capture requires nonempty registered fonts with plain CSS family names.");
+	let n = "";
+	for (let e = 0; e < t.length; e += 8192) n += String.fromCharCode(...t.subarray(e, e + 8192));
+	let r = t[0] === 79 && t[1] === 84 && t[2] === 84 && t[3] === 79;
+	return `@font-face { font-family: "${e.family}"; font-weight: ${e.weight}; font-style: ${e.style}; src: url("data:font/${r ? "otf" : "ttf"};base64,${btoa(n)}") format("${r ? "opentype" : "truetype"}"); }`;
+}
+function ge(e) {
+	for (let t of e) {
+		let n = e.getPropertyValue(t);
+		for (let e of n.matchAll(/url\(\s*(["']?)(.*?)\1\s*\)/gi)) if (!q.test(e[2] ?? "")) throw new b("RASTER_FAILED", `Raster capture requires inline bitmap resources (${t}).`);
+	}
+}
+function _e(e, t) {
+	let n = e.getBoundingClientRect(), r = [e, ...e.querySelectorAll("*")];
+	for (let i of r) {
+		if (!(i instanceof HTMLElement)) throw new b("RASTER_FAILED", "Raster capture supports HTML subtrees only; inline SVG needs a separate experiment.");
+		if (i.shadowRoot || i.tagName.includes("-") || i.tagName === "SLOT") throw new b("RASTER_FAILED", "Raster capture does not inspect shadow trees or distributed slot content in supported renderer.");
+		if (/^(CANVAS|IFRAME|OBJECT|EMBED|VIDEO|AUDIO|INPUT|TEXTAREA|SELECT|SCRIPT|STYLE|LINK)$/.test(i.tagName)) throw new b("RASTER_FAILED", `Raster capture does not support ${i.tagName.toLowerCase()} elements.`);
+		let r = getComputedStyle(i);
+		if (ge(r), r.mixBlendMode !== "normal" || r.backdropFilter !== "none") throw new b("RASTER_FAILED", "Raster capture cannot reproduce blending with pixels outside its subtree.");
+		if (r.position === "fixed" || r.position === "sticky") throw new b("RASTER_FAILED", "Raster capture does not reproduce viewport-dependent positioning.");
+		if (i !== e && r.position === "absolute") throw new b("RASTER_FAILED", "Raster capture does not normalize external containing blocks for positioned descendants.");
+		let a = r.boxShadow.split(/,(?![^(]*\))/);
+		if (r.filter !== "none" || r.boxShadow !== "none" && a.some((e) => !e.includes("inset"))) throw new b("RASTER_FAILED", "Raster capture requires effects contained in the border box; outer shadows and filters need expanded bounds.");
+		if (r.textShadow !== "none" || r.outlineStyle !== "none" && Number.parseFloat(r.outlineWidth) > 0) throw new b("RASTER_FAILED", "Raster capture requires expanded bounds before capturing text shadows or outlines.");
+		if (r.backgroundAttachment.includes("fixed")) throw new b("RASTER_FAILED", "Raster capture does not preserve viewport-dependent background attachment.");
+		if (i === e && r.transform !== "none") throw new b("RASTER_FAILED", "Raster capture does not normalize transformed region coordinates.");
+		if (r.display === "list-item") throw new b("RASTER_FAILED", "Raster capture does not preserve generated list markers in supported renderer.");
+		for (let e of ["::before", "::after"]) {
+			let t = getComputedStyle(i, e).content;
+			if (t !== "none" && t !== "normal") throw new b("RASTER_FAILED", "Raster capture does not support generated pseudo-element content in supported renderer.");
+		}
+		if (i instanceof HTMLImageElement) {
+			if (i.srcset || !q.test(i.currentSrc || i.src)) throw new b("RASTER_FAILED", "Raster capture requires inline bitmap images without srcset.");
+			if (!i.complete || i.naturalWidth === 0) throw new b("RASTER_FAILED", "Raster capture requires successfully decoded images.");
+		}
+		if ([...i.childNodes].some((e) => e.nodeType === Node.TEXT_NODE && !!e.textContent?.trim())) {
+			if (!r.font) throw new b("RASTER_FAILED", "Raster capture requires a serializable computed font shorthand to preserve exact font sizes.");
+			let e = r.fontFamily.split(",")[0]?.trim().replace(/^["']|["']$/g, "");
+			if (!t.some((t) => t.family.toLowerCase() === e?.toLowerCase() && t.weight === Number(r.fontWeight) && t.style === r.fontStyle)) throw new b("RASTER_FAILED", "Raster capture text requires an explicitly registered matching font face.");
+		}
+		let o = i.getBoundingClientRect();
+		if (o.width > 0 && o.height > 0 && (o.left < n.left - .5 || o.top < n.top - .5 || o.right > n.right + .5 || o.bottom > n.bottom + .5)) throw new b("RASTER_FAILED", "Raster capture descendants must stay inside the selected border box.");
+	}
+}
+async function ve(e, t, n, r = {
+	x: 0,
+	y: 0
+}) {
+	if (!e.isConnected || e.ownerDocument !== document) throw new b("RASTER_FAILED", "Raster capture requires a connected element in the current document.");
+	if (!Number.isFinite(n) || n <= 0) throw new b("RASTER_FAILED", "Raster scale must be a finite positive number.");
+	if (!r || ![r.x, r.y].every((e) => Number.isFinite(e) && e >= 0 && e < 1)) throw new b("RASTER_FAILED", "Raster offsets must be finite CSS pixel fractions from zero inclusive to one exclusive.");
+	await document.fonts.ready;
+	let { width: i, height: a } = e.getBoundingClientRect(), o = Math.ceil(i + r.x), s = Math.ceil(a + r.y), c = Math.ceil(o * n), l = Math.ceil(s * n);
+	if (i <= 0 || a <= 0 || c < 1 || l < 1 || c > K || l > K || c * l > me) throw new b("RASTER_FAILED", "Raster region exceeds the supported renderer canvas budget or has empty bounds.");
+	_e(e, t);
+	let u = t.map(he).join("\n"), d = ["font", ...Array.from(getComputedStyle(e)).filter((e) => e !== "font-size")], f = (await y(e, {
+		width: o,
+		height: s,
+		pixelRatio: n,
+		skipAutoScale: !0,
+		fontEmbedCSS: u,
+		includeStyleProperties: d,
+		style: {
+			margin: "0",
+			top: "0",
+			left: "0",
+			right: "auto",
+			bottom: "auto",
+			boxSizing: "border-box",
+			width: `${i}px`,
+			height: `${a}px`,
+			transform: `translate(${r.x}px, ${r.y}px)`
+		}
+	})).match(/^data:image\/png;base64,(.+)$/)?.[1];
+	if (!f) throw new b("RASTER_FAILED", "Raster capture produced an empty or invalid PNG.");
+	let p = atob(f);
+	return Uint8Array.from(p, (e) => e.charCodeAt(0));
+}
+// src/text.ts
+var ye = class {
+	font;
+	program;
+	words = /* @__PURE__ */ new Map();
+	unicode = /* @__PURE__ */ new Map();
+	widths = /* @__PURE__ */ new Map();
+	unitsPerEm;
+	constructor(t, n) {
+		this.font = t, this.program = e.create(n), this.unitsPerEm = this.program.unitsPerEm;
+	}
+	shape(e, t = !0) {
+		let n = `${t ? "1" : "0"}:${e}`, r = this.words.get(n);
+		if (r) return r;
+		let a = this.program.layout(e, { kern: t }), o = this.font.encodeText(e).asString();
+		if (o.length !== a.glyphs.length * 4) throw new b("PDF_WRITE_FAILED", "PDF font encoding disagrees with font shaping.");
+		let s = 0, c = 0, l = a.glyphs.map((e, t) => {
+			let n = o.slice(t * 4, t * 4 + 4);
+			if (Number.parseInt(n, 16) !== e.id) throw new b("PDF_WRITE_FAILED", "PDF glyph identifiers disagree with shaping.");
+			if (e.codePoints.length === 0) throw new b("PDF_WRITE_FAILED", "The font produced a shaped glyph without a Unicode source mapping.");
+			let r = a.positions[t];
+			this.unicode.has(n) || this.unicode.set(n, [...e.codePoints]), this.widths.set(n, e.advanceWidth * 1e3 / this.unitsPerEm);
+			let l = {
+				encoded: i.of(n),
+				x: s + r.xOffset,
+				y: c + r.yOffset
+			};
+			return s += r.xAdvance, c += r.yAdvance, l;
+		});
+		return this.words.set(n, l), l;
+	}
+	async embedUnicode(e) {
+		if (await this.font.embed(), this.unicode.size === 0) return;
+		let r = [...this.unicode].map(([e, t]) => {
+			let n = String.fromCodePoint(...t), r = "";
+			for (let e = 0; e < n.length; e += 1) r += n.charCodeAt(e).toString(16).padStart(4, "0");
+			return `<${e}> <${r}>`;
+		}), i = [];
+		for (let e = 0; e < r.length; e += 100) {
+			let t = r.slice(e, e + 100);
+			i.push(`${t.length} beginbfchar\n${t.join("\n")}\nendbfchar`);
+		}
+		let o = [
+			"/CIDInit /ProcSet findresource begin",
+			"12 dict begin",
+			"begincmap",
+			"/CIDSystemInfo << /Registry (Adobe) /Ordering (UCS) /Supplement 0 >> def",
+			"/CMapName /RenderPDFUnicode def",
+			"/CMapType 2 def",
+			"1 begincodespacerange",
+			"<0000> <ffff>",
+			"endcodespacerange",
+			...i,
+			"endcmap",
+			"CMapName currentdict /CMap defineresource pop",
+			"end",
+			"end"
+		].join("\n"), s = e.context.lookup(this.font.ref, n);
+		s.set(a.of("ToUnicode"), e.context.register(e.context.flateStream(o)));
+		let c = s.lookup(a.of("DescendantFonts"), t).lookup(0, n), l = [...this.widths].sort(([e], [t]) => Number.parseInt(e, 16) - Number.parseInt(t, 16)).flatMap(([e, t]) => [Number.parseInt(e, 16), [t]]);
+		c.set(a.of("W"), e.context.obj(l));
+	}
+}, J = .75;
+function Y(e) {
+	let t = e.match(/^rgba?\(\s*([\d.]+)[, ]+([\d.]+)[, ]+([\d.]+)(?:\s*[,/]\s*([\d.]+))?\s*\)$/);
+	if (!t) throw new b("UNSUPPORTED_CSS", `Unsupported computed color: ${e}`);
+	return {
+		color: m(Number(t[1]) / 255, Number(t[2]) / 255, Number(t[3]) / 255),
+		opacity: Number(t[4] ?? 1)
+	};
+}
+function X(e, t) {
+	let n = t.find(({ definition: t }) => t.family.toLowerCase() === e.family.toLowerCase() && t.weight === e.weight && t.style === e.style);
+	if (!n) throw new b("MISSING_FONT", `Unregistered font face: ${e.family} ${e.weight} ${e.style}`);
+	for (let t of e.text) if (!n.characters.has(t.codePointAt(0))) throw new b("MISSING_GLYPH", `Missing glyph: ${t} (${e.family} ${e.weight} ${e.style})`);
+	return n;
+}
+function be(e, t, n, r, i, a) {
+	let c = Y(t.color), l = a.fonts.get(n.font);
+	if (l || (l = e.node.newFontDictionary(n.font.name, n.font.ref), a.fonts.set(n.font, l)), e.pushOperators(f(), h(c.color)), c.opacity !== 1) {
+		let t = a.opacity.get(c.opacity);
+		t || (t = e.node.newExtGState("TextOpacity", e.doc.context.obj({
+			Type: "ExtGState",
+			ca: c.opacity
+		})), a.opacity.set(c.opacity, t)), e.pushOperators(_(t));
+	}
+	e.pushOperators(s(), g(l, t.fontSize * J), ee(t.invisible ? o.Invisible : o.Fill));
+	let p = t.fontSize * J / n.positioned.unitsPerEm, m = (i.height - i.margin.top - (t.baseline - r)) * J;
+	for (let r of t.runs) {
+		let a = (i.margin.left + r.x) * J;
+		for (let i of n.positioned.shape(r.text, t.kerning ?? !0)) e.pushOperators(v(1, 0, 0, 1, a + i.x * p, m + i.y * p), te(i.encoded));
+	}
+	e.pushOperators(u(), d());
+}
+function Z(e) {
+	let t = Math.floor(e.x), n = Math.floor(e.y);
+	return {
+		x: t,
+		y: n,
+		width: Math.ceil(e.x + e.width) - t,
+		height: Math.ceil(e.y + e.height) - n
+	};
+}
+async function xe(e, t, n) {
+	let r = t.currentSrc || t.src;
+	try {
+		x(n);
+		let t = await fetch(r, {
+			mode: "cors",
+			credentials: "same-origin",
+			...n ? { signal: n } : {}
+		});
+		if (!t.ok) throw Error(`Image request returned HTTP ${t.status}.`);
+		let i = new Uint8Array(await t.arrayBuffer());
+		return x(n), pe(i) === "png" ? await e.embedPng(i) : await e.embedJpg(i);
+	} catch (e) {
+		throw x(n), e instanceof b ? e : new b("RESOURCE_LOAD_FAILED", "The source image could not be embedded; provide a readable PNG/JPEG with same-origin or CORS access.", { cause: e });
+	}
+}
+async function Q(t, n, i, a, o = {}) {
+	try {
+		if (x(o.signal), t.width > i.width - i.margin.left - i.margin.right) throw new b("SOURCE_OVERFLOW", "Source is wider than the PDF content area.");
+		let s = await r.create();
+		x(o.signal), s.registerFontkit(e), s.setTitle("RenderPDF.js");
+		let u = [];
+		for (let e of n) {
+			x(o.signal);
+			let t = await s.embedFont(e.bytes);
+			u.push({
+				definition: e,
+				font: t,
+				characters: new Set(t.getCharacterSet()),
+				positioned: new ye(t, e.bytes)
+			});
+		}
+		for (let e of t.operations) e.kind !== "text" || e.invisible && o.includeRasterText === !1 || X(e, u);
+		let m = /* @__PURE__ */ new Map(), h = /* @__PURE__ */ new Map();
+		for (let e of t.operations) {
+			if (x(o.signal), e.kind === "raster") {
+				let t = Z(e.bounds);
+				try {
+					let r = await ve(e.element, n, o.rasterScale ?? 2, {
+						x: e.bounds.x - t.x,
+						y: e.bounds.y - t.y
+					});
+					x(o.signal), m.set(e, await s.embedPng(r));
+				} catch (e) {
+					throw x(o.signal), e instanceof b ? e : new b("RASTER_FAILED", "The selected local raster region could not be captured.", { cause: e });
+				}
+			}
+			if (e.kind === "image") {
+				let t = e.element.currentSrc || e.element.src, n = h.get(t);
+				n || (n = await xe(s, e.element, o.signal), h.set(t, n)), m.set(e, n);
+			}
+		}
+		for (let e of a) {
+			x(o.signal);
+			let n = s.addPage([i.width * J, i.height * J]), r = {
+				fonts: /* @__PURE__ */ new Map(),
+				opacity: /* @__PURE__ */ new Map()
+			};
+			n.pushOperators(f(), p(i.margin.left * J, (i.height - i.margin.top - (e.end - e.start)) * J, (i.width - i.margin.left - i.margin.right) * J, (e.end - e.start) * J), c(), l());
+			for (let a of t.operations) {
+				let t = a.bounds;
+				if (t.y >= e.end - .01 || t.y + t.height <= e.start + .01) continue;
+				if (a.kind === "text") {
+					a.invisible && o.includeRasterText === !1 || be(n, a, X(a, u), e.start, i, r);
+					continue;
+				}
+				let s = a.kind === "raster" ? Z(t) : t, c = {
+					x: (i.margin.left + s.x) * J,
+					y: (i.height - i.margin.top - (s.y - e.start) - s.height) * J,
+					width: s.width * J,
+					height: s.height * J
+				};
+				if (a.kind === "box") {
+					let e = Y(a.background), t = Y(a.borderColor);
+					if (n.drawRectangle({
+						...c,
+						color: e.color,
+						opacity: e.opacity
+					}), a.borderWidth > 0) {
+						let e = a.borderWidth * J / 2;
+						n.drawRectangle({
+							x: c.x + e,
+							y: c.y + e,
+							width: c.width - e * 2,
+							height: c.height - e * 2,
+							borderWidth: a.borderWidth * J,
+							borderColor: t.color,
+							borderOpacity: t.opacity
+						});
+					}
+				} else n.drawImage(m.get(a), c);
+			}
+			n.pushOperators(d());
+		}
+		x(o.signal);
+		for (let e of u) await e.positioned.embedUnicode(s), x(o.signal);
+		let g = Uint8Array.from(await s.save());
+		return x(o.signal), {
+			bytes: g,
+			slices: a
+		};
+	} catch (e) {
+		throw x(o.signal), e instanceof b ? e : new b("PDF_WRITE_FAILED", "The measured content could not be serialized as a PDF.", { cause: e });
+	}
+}
+// src/prepare.ts
+async function $(e, t) {
+	return x(t), t ? new Promise((n, r) => {
+		let i = () => r(new DOMException("PDF rendering was cancelled.", "AbortError"));
+		t.addEventListener("abort", i, { once: !0 }), e.then(n, r).finally(() => t.removeEventListener("abort", i));
+	}) : e;
+}
+function Se(e, t) {
+	if (x(t), typeof document > "u" || !(e instanceof HTMLElement) || !e.isConnected || e.ownerDocument !== document) throw new b("INVALID_SOURCE", "Provide a connected HTMLElement in the current document.");
+	let n = !1, r, i = /* @__PURE__ */ new Map(), a = new MutationObserver(() => {
+		n = !0;
+	}), o = [];
+	a.observe(e, {
+		subtree: !0,
+		attributes: !0,
+		childList: !0,
+		characterData: !0
+	});
+	let s = e.parentElement, c = e.getRootNode();
+	for (c instanceof ShadowRoot && (a.observe(c, {
+		subtree: !0,
+		attributes: !0,
+		childList: !0,
+		characterData: !0
+	}), s ??= c.host); s;) o.push(s), a.observe(s, { attributes: !0 }), s = s.parentElement ?? (s.getRootNode() instanceof ShadowRoot ? s.getRootNode().host : null);
+	a.observe(document.head, {
+		subtree: !0,
+		attributes: !0,
+		childList: !0,
+		characterData: !0
+	});
+	let l = Array.from(getComputedStyle(document.documentElement)).filter((e) => !e.startsWith("--"));
+	function u() {
+		let t = 2166136261, n = 5381;
+		function r(e) {
+			let r = i.get(e);
+			r === void 0 && (r = i.size + 1, i.set(e, r)), t = Math.imul(t ^ r, 16777619), n = Math.imul(n, 33) ^ r;
+		}
+		function a(e, t) {
+			let n = getComputedStyle(e, t);
+			if (r(t ?? "element"), t && (r(n.content), n.content === "none" || n.content === "normal")) return;
+			let i = n.length, a = i >= l.length ? l : [];
+			r(String(i));
+			for (let e = 0; e < i; e += 1) {
+				let t = a[e] ?? n[e];
+				e >= a.length && r(t), r(n.getPropertyValue(t));
+			}
+		}
+		let s = e.getBoundingClientRect();
+		for (let e of o) a(e);
+		for (let t of [e, ...e.querySelectorAll("*")]) {
+			a(t), a(t, "::before"), a(t, "::after");
+			let e = t.getBoundingClientRect();
+			r(`${e.x - s.x},${e.y - s.y},${e.width},${e.height}`);
+		}
+		return `${t >>> 0}:${n >>> 0}`;
+	}
+	function d() {
+		if (x(t), a.takeRecords().length && (n = !0), !e.isConnected || n || r !== void 0 && u() !== r) throw new b("SOURCE_CHANGED", "The source or its styles changed during PDF rendering. Retry with a stable source.");
+	}
+	function f() {
+		if (d(), [...e.getAnimations({ subtree: !0 }), ...o.flatMap((e) => e.getAnimations())].some((e) => e.playState === "running")) throw new b("UNSUPPORTED_CSS", "Pause source animations before rendering a PDF.");
+		r = u();
+	}
+	async function p() {
+		await $(document.fonts.ready, t);
+		try {
+			await $(Promise.all([...e.querySelectorAll("img"), ...e instanceof HTMLImageElement ? [e] : []].map((e) => e.decode())), t);
+		} catch (e) {
+			throw x(t), new b("RESOURCE_LOAD_FAILED", "A source image could not be decoded.", { cause: e });
+		}
+		d();
+	}
+	return {
+		ready: p,
+		captureBaseline: f,
+		assertUnchanged: d,
+		dispose: () => a.disconnect()
+	};
+}
+// src/result.ts
+function Ce(e, t, n) {
+	let r = Uint8Array.from(e), i = Object.freeze(n.map((e) => Object.freeze({ ...e })));
+	return Object.freeze({
+		pageCount: t,
+		warnings: i,
+		async toUint8Array() {
+			return Uint8Array.from(r);
+		},
+		async toBlob() {
+			return new Blob([r], { type: "application/pdf" });
+		},
+		async download(e = "document.pdf") {
+			if (typeof e != "string" || !e.trim() || /[/\\]/.test(e) || [...e].some((e) => e.codePointAt(0) < 32)) throw new b("INVALID_OPTIONS", "Provide a nonempty PDF filename without path separators or control characters.");
+			let t = URL.createObjectURL(new Blob([r], { type: "application/pdf" }));
+			try {
+				let n = document.createElement("a");
+				n.href = t, n.download = e, n.click();
+			} finally {
+				window.setTimeout(() => URL.revokeObjectURL(t), 1e3);
+			}
+		}
+	});
+}
+// src/render-pdf.ts
+async function we(e, t, n = !0) {
+	let r = V(t), i = [...t.fonts];
+	A(i);
+	let { signal: a, onWarning: o, rasterScale: s = 2, fallback: c = "auto", pageBreak: l = "css" } = t, u = Se(e, a);
+	try {
+		await u.ready(), u.assertUnchanged();
+		let t = B(e, i, { fallback: c });
+		if (u.captureBaseline(), t.width > r.width - r.margin.left - r.margin.right) throw new b("SOURCE_OVERFLOW", "Source is wider than the configured page content area. Set the source width explicitly; no implicit scaling is applied.");
+		l === "css" && Object.assign(t, ae(e, t));
+		let d = [], f = de(t, r.height - r.margin.top - r.margin.bottom, (e) => d.push(e)), p = [...t.warnings, ...d];
+		t.operations.some((e) => e.kind === "text") && !p.some((e) => e.code === "TEXT_METRICS_APPROXIMATED") && p.unshift({
+			code: "TEXT_METRICS_APPROXIMATED",
+			message: "PDF text uses browser word origins and approximate baseline/kerning metrics; full glyph shaping fidelity is not guaranteed."
+		});
+		for (let e of p) o?.(Object.freeze(e));
+		o && u.assertUnchanged();
+		let m = await $(Q(t, i, r, f, {
+			rasterScale: s,
+			includeRasterText: n,
+			...a ? { signal: a } : {}
+		}), a);
+		return u.assertUnchanged(), A(i), x(a), {
+			...m,
+			snapshot: t,
+			warnings: p
+		};
+	} finally {
+		u.dispose();
+	}
+}
+async function Te(e, t) {
+	let n = await we(e, t);
+	return Ce(n.bytes, n.slices.length, n.warnings);
+}
+export { b as RenderPDFError, se as registerFont, Te as renderPDF };