modern-pdf-lib 0.34.0 → 0.36.0

package/dist/{src-CiUkSS81.mjs → src-4wfgzZvz.mjs}

@@ -1,8 +1,8 @@
-import { A as encodeUTCTime, Bn as restoreState, Br as lineTo, C as encodeInteger, E as encodeOctetString, F as parseDerTlv, Hr as rectangle, Ht as PageSizes, I as toBuffer, Ir as fill, Jn as applyFillColor, M as extractIssuerAndSerial, N as extractSubjectPublicKeyInfo, O as encodeSequence, P as getSubtle, Qr as moveText, S as encodeContextTag, T as encodeOID, Un as saveState, Ur as setDashPattern, V as findSignatures, Vr as moveTo, W as mergePdfs, Xr as beginText, Yn as applyStrokeColor, Yr as stroke, Zn as cmykToRgb, Zr as endText, b as detectKeyAlgorithm, ci as setWordSpacing, gn as PdfAnnotation, k as encodeSet, li as showText$1, n as StandardFonts, ni as setFont, qr as setLineWidth, r as createPdf, s as setPageLabels, st as sha256, t as PdfDocument, vn as buildAnnotationDict, vt as PdfParseError, wn as formatPdfDate, x as detectNamedCurve, y as decodeOidBytes, z as computeSignatureHash } from "./pdfDocument-EcHxUnR6.mjs";
-import { c as PdfRef, i as PdfName, l as PdfStream, n as PdfBool, o as PdfNumber, r as PdfDict, t as PdfArray, u as PdfString } from "./pdfObjects-CB7TEdbW.mjs";
+import { $r as beginText, A as encodeUTCTime, C as encodeInteger, Dn as formatPdfDate, E as encodeOctetString, F as parseDerTlv, Gr as rectangle, Gt as PageSizes, I as toBuffer, Kn as saveState, Kr as setDashPattern, M as extractIssuerAndSerial, N as extractSubjectPublicKeyInfo, O as encodeSequence, P as getSubtle, Qn as applyStrokeColor, Qr as stroke, S as encodeContextTag, T as encodeOID, Tn as buildInfoDict, Un as restoreState, Ur as lineTo, Ut as serializePdf, V as findSignatures, W as mergePdfs, Wr as moveTo, Xr as setLineWidth, Zn as applyFillColor, ai as setFont, b as detectKeyAlgorithm, bt as PdfLexer, di as setWordSpacing, ei as endText, er as cmykToRgb, fi as showText$1, k as encodeSet, n as StandardFonts, nt as loadPdf, r as createPdf, rt as PdfEncryptionHandler, s as setPageLabels, st as sha256, t as PdfDocument, ti as moveText, vt as XrefParser, x as detectNamedCurve, xn as buildAnnotationDict, xt as PdfParseError, y as decodeOidBytes, yn as PdfAnnotation, yt as PdfObjectParser, z as computeSignatureHash, zr as fill } from "./pdfDocument-Q0wrwKEZ.mjs";
+import { c as PdfRef, i as PdfName, l as PdfStream, n as PdfBool, o as PdfNumber, r as PdfDict, s as PdfObjectRegistry, t as PdfArray, u as PdfString } from "./pdfObjects-CB7TEdbW.mjs";
 import { n as decodeStreamData, r as getStreamFilters } from "./streamDecode-DCpgTocN.mjs";
 import { g as FieldFlags, v as numVal } from "./pdfForm-CfLnlsj-.mjs";
-import { i as parseContentStream } from "./compressionAnalysis-BEd_745I.mjs";
+import { i as parseContentStream, o as extractTextWithPositions } from "./compressionAnalysis-BEd_745I.mjs";
 import { n as decodeJpegWasm } from "./bridge-7dhURZj7.mjs";
 import { r as detectRuntime } from "./loader-DkrXz-h4.mjs";
 import { deflateSync, inflateSync, unzlibSync } from "fflate";
@@ -277,7 +277,7 @@ function compressStream(stream, level) {
 * @returns              The incremental save result.
 */
 async function saveDocumentIncremental(originalBytes, doc, options) {
-	const { buildDocumentStructure } = await import("./pdfDocument-EcHxUnR6.mjs").then((n) => n.Tn);
+	const { buildDocumentStructure } = await import("./pdfDocument-Q0wrwKEZ.mjs").then((n) => n.On);
 	const registry = doc.getRegistry();
 	const structure = buildDocumentStructure(doc.getInternalPages().map((p) => p.finalize()), {
 		producer: doc.getProducer(),
@@ -28081,6 +28081,2452 @@ function buildCertPath(leafCertDer, intermediates, anchors) {
 	};
 }
 //#endregion
+//#region src/security/threatScanner.ts
+/** Numeric rank for severities so we can take a maximum. */
+const SEVERITY_RANK = {
+	low: 1,
+	medium: 2,
+	high: 3
+};
+/** Reverse lookup from rank back to severity. */
+const RANK_SEVERITY = [
+	"low",
+	"medium",
+	"high"
+];
+/**
+* File-name extensions that denote directly executable / script payloads.
+* An attachment ending in one of these is treated as high severity because a
+* viewer's "open attachment" (or a `/Launch` action targeting it) can run it.
+*/
+const EXECUTABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+	"exe",
+	"com",
+	"scr",
+	"pif",
+	"cpl",
+	"msi",
+	"msp",
+	"mst",
+	"dll",
+	"sys",
+	"drv",
+	"ocx",
+	"bat",
+	"cmd",
+	"ps1",
+	"psm1",
+	"vbs",
+	"vbe",
+	"vb",
+	"wsf",
+	"wsh",
+	"js",
+	"jse",
+	"jar",
+	"class",
+	"sh",
+	"bash",
+	"zsh",
+	"ksh",
+	"csh",
+	"command",
+	"app",
+	"dmg",
+	"pkg",
+	"lnk",
+	"url",
+	"reg",
+	"hta",
+	"gadget",
+	"inf",
+	"scf",
+	"apk",
+	"deb",
+	"rpm",
+	"run",
+	"bin",
+	"elf",
+	"so",
+	"dylib",
+	"py",
+	"pyc",
+	"pyw",
+	"rb",
+	"pl",
+	"php"
+]);
+/** Read a `PdfName` value (without the leading `/`) from a dict entry. */
+function nameValue$1(obj) {
+	if (obj !== void 0 && obj.kind === "name") {
+		const v = obj.value;
+		return v.startsWith("/") ? v.slice(1) : v;
+	}
+}
+/** Read a `PdfString` value from a dict entry. */
+function stringValue(obj) {
+	if (obj !== void 0 && obj.kind === "string") return obj.value;
+}
+/** Format a `PdfRef` as the canonical `"N G R"` string, if available. */
+function refString(ref) {
+	return ref ? `${ref.objectNumber} ${ref.generationNumber} R` : void 0;
+}
+/** Lower-case file extension of a name, or `''` when there is none. */
+function extensionOf(name) {
+	const base = name.replace(/[\\/]+/g, "/").split("/").pop() ?? name;
+	const dot = base.lastIndexOf(".");
+	if (dot < 0 || dot === base.length - 1) return "";
+	return base.slice(dot + 1).toLowerCase();
+}
+/**
+* Scan a PDF for hostile constructs and return a {@link ThreatReport}.
+*
+* The scan never executes any document content. It parses the PDF and walks
+* the parsed object graph (see the module header for the precise method and
+* ISO 32000 references). When parsing fails, a guarded raw-byte fallback runs.
+*
+* @param pdf  Raw PDF bytes.
+* @returns    A report of findings plus the aggregate `riskLevel`.
+*/
+async function scanPdfThreats(pdf) {
+	const findings = [];
+	let scannedGraph = false;
+	try {
+		scanObjectGraph((await loadPdf(pdf, { ignoreEncryption: true })).getRegistry(), findings);
+		scannedGraph = true;
+	} catch {
+		scannedGraph = false;
+	}
+	if (!scannedGraph) scanRawBytesFallback(pdf, findings);
+	return {
+		findings,
+		riskLevel: aggregateRisk(findings)
+	};
+}
+/**
+* Walk every registered object and emit findings.
+*
+* We iterate the registry (every resolved indirect object). For each
+* dictionary (including stream dictionaries) we inspect that dict's *own
+* keys* and, where relevant, the resolved action-subtype `/S` *name*. Content
+* streams' raw bytes are never substring-scanned here, which is what makes the
+* scan precise (drawn text that merely says "JavaScript" is not a finding).
+*/
+function scanObjectGraph(registry, findings) {
+	for (const entry of registry) {
+		const obj = entry.object;
+		const refStr = refString(entry.ref);
+		let dict;
+		if (obj.kind === "dict") dict = obj;
+		else if (obj.kind === "stream") dict = obj.dict;
+		if (dict === void 0) continue;
+		inspectDict(dict, refStr, findings);
+	}
+}
+/**
+* Inspect a single dictionary's keys/values for dangerous constructs.
+*
+* @param dict     The dictionary (or stream dictionary).
+* @param refStr   The owning object's `"N G R"` string, if known.
+* @param findings Accumulator.
+*/
+function inspectDict(dict, refStr, findings) {
+	if (dict.has("/OpenAction")) findings.push({
+		category: "OpenAction",
+		severity: "medium",
+		detail: "Document defines an /OpenAction that runs automatically when the PDF is opened (ISO 32000 §12.6.3).",
+		objectRef: refStr
+	});
+	if (dict.has("/AA")) findings.push({
+		category: "AA",
+		severity: "medium",
+		detail: "Document or object defines /AA additional actions that fire on viewer events such as open/close/print/save (ISO 32000 §12.6.2).",
+		objectRef: refStr
+	});
+	if (dict.has("/JavaScript")) findings.push({
+		category: "JavaScript",
+		severity: "high",
+		detail: "A /JavaScript name tree (catalog /Names → /JavaScript) is present; these scripts execute automatically on open (ISO 32000 §12.6.4.16, §7.7.4).",
+		objectRef: refStr
+	});
+	const subtype = nameValue$1(dict.get("/S"));
+	if (subtype !== void 0) inspectActionSubtype(subtype, dict, refStr, findings);
+	if (dict.has("/XFA")) findings.push({
+		category: "XFA",
+		severity: "low",
+		detail: "Document contains an XFA form (/AcroForm → /XFA, ISO 32000 §12.7.8); XFA carries its own scripting and data-binding model.",
+		objectRef: refStr
+	});
+	const annotSubtype = nameValue$1(dict.get("/Subtype"));
+	if (annotSubtype === "RichMedia") findings.push({
+		category: "RichMedia",
+		severity: "low",
+		detail: "Rich-media annotation (/Subtype /RichMedia, ISO 32000-2 §13.6) embeds interactive multimedia (e.g. Flash/video).",
+		objectRef: refStr
+	});
+	else if (annotSubtype === "Movie") findings.push({
+		category: "Movie",
+		severity: "low",
+		detail: "Movie annotation (/Subtype /Movie, ISO 32000 §13.4) embeds video/animation content.",
+		objectRef: refStr
+	});
+	else if (annotSubtype === "Sound") findings.push({
+		category: "Sound",
+		severity: "low",
+		detail: "Sound annotation (/Subtype /Sound, ISO 32000 §13.3) embeds audio content.",
+		objectRef: refStr
+	});
+	if (dict.has("/RichMedia") && annotSubtype !== "RichMedia") findings.push({
+		category: "RichMedia",
+		severity: "low",
+		detail: "Object references rich-media content via a /RichMedia entry (ISO 32000-2 §13.6).",
+		objectRef: refStr
+	});
+	if (dict.has("/Movie") && annotSubtype !== "Movie") findings.push({
+		category: "Movie",
+		severity: "low",
+		detail: "Object references movie content via a /Movie entry (ISO 32000 §13.4).",
+		objectRef: refStr
+	});
+	if (dict.has("/Sound") && annotSubtype !== "Sound" && subtype !== "Sound") findings.push({
+		category: "Sound",
+		severity: "low",
+		detail: "Object references sound content via a /Sound entry (ISO 32000 §13.3).",
+		objectRef: refStr
+	});
+	if (nameValue$1(dict.get("/Type")) === "Filespec" || dict.has("/EF")) {
+		const fileName = stringValue(dict.get("/UF")) ?? stringValue(dict.get("/F"));
+		if (fileName !== void 0) {
+			const ext = extensionOf(fileName);
+			if (ext !== "" && EXECUTABLE_EXTENSIONS.has(ext)) findings.push({
+				category: "EmbeddedFile",
+				severity: "high",
+				detail: `Embedded file "${fileName}" has an executable/script extension ".${ext}" (ISO 32000 §7.11.3/§7.11.4); opening it can run code.`,
+				objectRef: refStr
+			});
+		}
+	}
+}
+/**
+* Flag a dangerous action `/S` subtype. Subtypes are ISO 32000 §12.6.4 /
+* §12.7.5 action types.
+*/
+function inspectActionSubtype(subtype, dict, refStr, findings) {
+	switch (subtype) {
+		case "JavaScript":
+			findings.push({
+				category: "JavaScript",
+				severity: "high",
+				detail: "JavaScript action (/S /JavaScript, ISO 32000 §12.6.4.16) executes script in the viewer.",
+				objectRef: refStr
+			});
+			break;
+		case "Launch":
+			findings.push({
+				category: "Launch",
+				severity: "high",
+				detail: "Launch action (/S /Launch, ISO 32000 §12.6.4.5) can run an external application or open a file.",
+				objectRef: refStr
+			});
+			break;
+		case "URI":
+			findings.push({
+				category: "URI",
+				severity: "medium",
+				detail: `URI action (/S /URI, ISO 32000 §12.6.4.7) opens a remote URL ${describeUri(dict)}.`,
+				objectRef: refStr
+			});
+			break;
+		case "SubmitForm":
+			findings.push({
+				category: "SubmitForm",
+				severity: "medium",
+				detail: "SubmitForm action (/S /SubmitForm, ISO 32000 §12.7.5.2) sends form data to a URL (potential data exfiltration).",
+				objectRef: refStr
+			});
+			break;
+		case "ImportData":
+			findings.push({
+				category: "ImportData",
+				severity: "low",
+				detail: "ImportData action (/S /ImportData, ISO 32000 §12.7.5.4) imports external form data.",
+				objectRef: refStr
+			});
+			break;
+		case "GoToR":
+			findings.push({
+				category: "GoToR",
+				severity: "low",
+				detail: "Remote Go-To action (/S /GoToR, ISO 32000 §12.6.4.3) targets an external document.",
+				objectRef: refStr
+			});
+			break;
+		case "Movie":
+			findings.push({
+				category: "Movie",
+				severity: "low",
+				detail: "Movie action (/S /Movie, ISO 32000 §12.6.4.10) plays embedded video.",
+				objectRef: refStr
+			});
+			break;
+		case "Sound":
+			findings.push({
+				category: "Sound",
+				severity: "low",
+				detail: "Sound action (/S /Sound, ISO 32000 §12.6.4.8) plays embedded audio.",
+				objectRef: refStr
+			});
+			break;
+		default: break;
+	}
+}
+/** Append the target URL of a /URI action to the detail string, if present. */
+function describeUri(dict) {
+	const uri = stringValue(dict.get("/URI"));
+	return uri !== void 0 ? `→ "${uri}"` : "";
+}
+/**
+* Best-effort raw-byte fallback used only when the PDF cannot be parsed.
+*
+* To stay precise we match constructs only in their *structural* dictionary
+* form — action subtypes as `/S /Type` (optionally without the inner space)
+* and `/OpenAction`/`/AA`/`/JavaScript` as dictionary keys (a `/` immediately
+* followed by the token and then a PDF delimiter). This avoids flagging the
+* same words when they appear as content-stream text or inside a literal
+* string. It is heuristic and clearly less reliable than the graph walk.
+*/
+function scanRawBytesFallback(pdf, findings) {
+	const text = new TextDecoder("latin1").decode(pdf);
+	const keyForm = (key) => new RegExp(`/${key}(?=[\\s/(<\\[\\]>]|$)`);
+	if (keyForm("OpenAction").test(text)) findings.push({
+		category: "OpenAction",
+		severity: "medium",
+		detail: "Raw scan: /OpenAction key present (ISO 32000 §12.6.3)."
+	});
+	if (keyForm("AA").test(text)) findings.push({
+		category: "AA",
+		severity: "medium",
+		detail: "Raw scan: /AA additional-actions key present (ISO 32000 §12.6.2)."
+	});
+	if (keyForm("JavaScript").test(text) || /\/S\s*\/JavaScript\b/.test(text)) findings.push({
+		category: "JavaScript",
+		severity: "high",
+		detail: "Raw scan: JavaScript action/name tree present (ISO 32000 §12.6.4.16)."
+	});
+	if (/\/S\s*\/Launch\b/.test(text)) findings.push({
+		category: "Launch",
+		severity: "high",
+		detail: "Raw scan: /S /Launch action present (ISO 32000 §12.6.4.5)."
+	});
+	if (/\/S\s*\/URI\b/.test(text)) findings.push({
+		category: "URI",
+		severity: "medium",
+		detail: "Raw scan: /S /URI action present (ISO 32000 §12.6.4.7)."
+	});
+	if (/\/S\s*\/SubmitForm\b/.test(text)) findings.push({
+		category: "SubmitForm",
+		severity: "medium",
+		detail: "Raw scan: /S /SubmitForm action present (ISO 32000 §12.7.5.2)."
+	});
+	if (/\/S\s*\/ImportData\b/.test(text)) findings.push({
+		category: "ImportData",
+		severity: "low",
+		detail: "Raw scan: /S /ImportData action present (ISO 32000 §12.7.5.4)."
+	});
+	if (/\/S\s*\/GoToR\b/.test(text)) findings.push({
+		category: "GoToR",
+		severity: "low",
+		detail: "Raw scan: /S /GoToR remote go-to present (ISO 32000 §12.6.4.3)."
+	});
+	if (/\/Subtype\s*\/RichMedia\b/.test(text) || keyForm("RichMedia").test(text)) findings.push({
+		category: "RichMedia",
+		severity: "low",
+		detail: "Raw scan: RichMedia annotation present (ISO 32000-2 §13.6)."
+	});
+	if (/\/Subtype\s*\/Movie\b/.test(text) || /\/S\s*\/Movie\b/.test(text)) findings.push({
+		category: "Movie",
+		severity: "low",
+		detail: "Raw scan: Movie content/action present (ISO 32000 §13.4)."
+	});
+	if (/\/Subtype\s*\/Sound\b/.test(text) || /\/S\s*\/Sound\b/.test(text)) findings.push({
+		category: "Sound",
+		severity: "low",
+		detail: "Raw scan: Sound content/action present (ISO 32000 §13.3)."
+	});
+	if (keyForm("XFA").test(text)) findings.push({
+		category: "XFA",
+		severity: "low",
+		detail: "Raw scan: /XFA form present (ISO 32000 §12.7.8)."
+	});
+}
+/** Maximum severity across findings, or `'none'` when there are none. */
+function aggregateRisk(findings) {
+	let maxRank = 0;
+	for (const f of findings) {
+		const rank = SEVERITY_RANK[f.severity];
+		if (rank > maxRank) maxRank = rank;
+	}
+	if (maxRank === 0) return "none";
+	return RANK_SEVERITY[maxRank - 1];
+}
+//#endregion
+//#region src/security/sanitize.ts
+/**
+* @module security/sanitize
+*
+* PDF sanitizer — produce a cleaned copy of a PDF with active / hidden
+* content neutralised.
+*
+* The sanitizer removes four classes of potentially dangerous or
+* privacy-leaking content from a document, each independently toggleable:
+*
+* - **javascript** — document-level JavaScript: the catalog's
+*   `/Names → /JavaScript` name tree (ISO 32000-1 §7.7.4 / §12.6.4.16)
+*   and the catalog's `/AA` (document additional-actions) dictionary
+*   (§12.6.3) plus any page-level `/AA`.
+* - **openActions** — the catalog's auto-run `/OpenAction` (§12.3.4 / §12.6.4).
+* - **embeddedFiles** — embedded file attachments: the catalog's
+*   `/Names → /EmbeddedFiles` name tree (§7.7.4 / §7.11.4) and the
+*   PDF 2.0 catalog `/AF` (associated files) array (§7.11.4).
+* - **metadata** — the XMP `/Metadata` stream (§14.3.2) and the document
+*   information `/Info` dictionary (§14.3.3).
+*
+* Implementation strategy (verified against this library's parser/writer):
+* the cleaned bytes are produced by mutating the *parsed object graph* in
+* place and re-serializing the registry directly through
+* {@link serializePdf}, **without** rebuilding the catalog. This is what
+* lets a disabled option genuinely preserve its content — the original
+* catalog (minus the removed references) is written verbatim.
+*
+* Removing a reference from the catalog is not sufficient on its own: the
+* underlying object (a JavaScript action dictionary, an `/EmbeddedFile`
+* stream, an XMP metadata stream, …) would otherwise remain physically
+* present in the output as an orphan. To guarantee the payload bytes are
+* actually gone, after deleting references this module runs the registry's
+* reachability filter from the catalog + info roots, dropping every object
+* no longer referenced.
+*
+* @packageDocumentation
+*/
+/**
+* Resolve a {@link PdfObject} that may be an indirect reference to its
+* underlying value using the registry. Non-refs are returned as-is.
+* Returns `undefined` if a ref cannot be resolved.
+*/
+function resolve$2(obj, registry) {
+	if (obj === void 0) return void 0;
+	if (obj instanceof PdfRef) return registry.resolve(obj);
+	return obj;
+}
+/** Resolve `obj` and return it only if it is a {@link PdfDict}. */
+function asDict(obj, registry) {
+	const resolved = resolve$2(obj, registry);
+	return resolved instanceof PdfDict ? resolved : void 0;
+}
+/** Read a {@link PdfString} value, resolving an indirect reference if needed. */
+function asStringValue(obj, registry) {
+	const resolved = resolve$2(obj, registry);
+	return resolved instanceof PdfString ? resolved.value : void 0;
+}
+/**
+* Collect every distinct `/Type /Catalog` dictionary registered in the
+* document, paired with its reference. A well-formed PDF has exactly one,
+* but malformed or incrementally-updated files can register more than one;
+* sanitizing all of them is the conservative, correct choice. The first
+* entry is treated as the document root.
+*/
+function findCatalogEntries(registry) {
+	const byObjNum = /* @__PURE__ */ new Map();
+	for (const { ref, object } of registry) if (object instanceof PdfDict) {
+		const type = object.get("/Type");
+		if (type instanceof PdfName && type.value === "/Catalog") {
+			if (!byObjNum.has(ref.objectNumber)) byObjNum.set(ref.objectNumber, {
+				ref,
+				dict: object
+			});
+		}
+	}
+	return [...byObjNum.values()];
+}
+/** Collect every distinct `/Type /Page` dictionary in the registry. */
+function findPages(registry) {
+	const pages = /* @__PURE__ */ new Set();
+	for (const { object } of registry) if (object instanceof PdfDict) {
+		const type = object.get("/Type");
+		if (type instanceof PdfName && type.value === "/Page") pages.add(object);
+	}
+	return [...pages];
+}
+/**
+* Determine whether a PDF name tree (ISO 32000-1 §7.7.4) contains at least
+* one entry. A name-tree node holds either a `/Names` array of
+* `[key value key value …]` pairs (leaf) or a `/Kids` array of child node
+* references (intermediate). The tree is walked recursively with a visited
+* guard against cyclic references in malformed files.
+*/
+function nameTreeHasEntries(node, registry, visited = /* @__PURE__ */ new Set()) {
+	const dict = asDict(node, registry);
+	if (dict === void 0 || visited.has(dict)) return false;
+	visited.add(dict);
+	const names = resolve$2(dict.get("/Names"), registry);
+	if (names instanceof PdfArray && names.length >= 2) return true;
+	const kids = resolve$2(dict.get("/Kids"), registry);
+	if (kids instanceof PdfArray) {
+		for (const kid of kids.items) if (nameTreeHasEntries(kid, registry, visited)) return true;
+	}
+	return false;
+}
+/** Return the catalog's resolved `/Names` sub-dictionary, if present. */
+function getNamesDict(catalog, registry) {
+	return asDict(catalog.get("/Names"), registry);
+}
+/**
+* Determine whether an additional-actions (`/AA`) dictionary contains any
+* action whose `/S` (action type) is `/JavaScript`. Each value in an `/AA`
+* dictionary is itself an action dictionary (§12.6.3).
+*/
+function aaHasJavaScript(aa, registry) {
+	if (aa === void 0) return false;
+	for (const [, value] of aa) {
+		const action = asDict(value, registry);
+		if (action === void 0) continue;
+		const s = action.get("/S");
+		if (s instanceof PdfName && s.value === "/JavaScript") return true;
+	}
+	return false;
+}
+/**
+* Descriptive `/Info` keys that constitute identifying metadata. The
+* auto-generated `/Producer`, `/CreationDate`, and `/ModDate` are NOT
+* treated as "present" for reporting purposes: a freshly created document
+* carries those by default and must still be considered clean. (When
+* metadata removal runs, the entire `/Info` dict is dropped regardless.)
+*/
+const DESCRIPTIVE_INFO_KEYS = [
+	"/Title",
+	"/Author",
+	"/Subject",
+	"/Keywords",
+	"/Creator"
+];
+/**
+* Locate the trailer's `/Info` dictionary in the registry. The parser does
+* not expose the trailer publicly, so the Info dict is identified
+* structurally: it is a dictionary that is NOT a catalog/page/pages node
+* and carries at least one recognised document-information key.
+*/
+function findInfoDict(registry, catalogs) {
+	const catalogDicts = new Set(catalogs.map((c) => c.dict));
+	const INFO_KEYS = [
+		"/Title",
+		"/Author",
+		"/Subject",
+		"/Keywords",
+		"/Creator",
+		"/Producer",
+		"/CreationDate",
+		"/ModDate",
+		"/Trapped"
+	];
+	for (const { object } of registry) {
+		if (!(object instanceof PdfDict) || catalogDicts.has(object)) continue;
+		const type = object.get("/Type");
+		if (type instanceof PdfName) {
+			const v = type.value;
+			if (v === "/Catalog" || v === "/Pages" || v === "/Page" || v === "/Font") continue;
+		}
+		if (INFO_KEYS.some((k) => object.has(k))) return object;
+	}
+}
+/** Read descriptive metadata from an `/Info` dict into a typed bag. */
+function readInfoMetadata(info, registry) {
+	const meta = {};
+	if (info === void 0) return meta;
+	const title = asStringValue(info.get("/Title"), registry);
+	if (title !== void 0) meta.title = title;
+	const author = asStringValue(info.get("/Author"), registry);
+	if (author !== void 0) meta.author = author;
+	const subject = asStringValue(info.get("/Subject"), registry);
+	if (subject !== void 0) meta.subject = subject;
+	const keywords = asStringValue(info.get("/Keywords"), registry);
+	if (keywords !== void 0) meta.keywords = keywords;
+	const creator = asStringValue(info.get("/Creator"), registry);
+	if (creator !== void 0) meta.creator = creator;
+	const producer = asStringValue(info.get("/Producer"), registry);
+	if (producer !== void 0) meta.producer = producer;
+	return meta;
+}
+/**
+* Produce a cleaned copy of a PDF with active / hidden content neutralised.
+*
+* Loads the PDF, removes each enabled class of content from the parsed
+* object graph, prunes the orphaned objects, re-serializes the cleaned
+* document, and returns the new bytes alongside a report listing the
+* classes that were actually present and removed.
+*
+* @param pdf      The source PDF bytes.
+* @param options  Which classes to remove (each defaults to `true`).
+* @returns        The cleaned PDF bytes and a {@link SanitizeReport}.
+*
+* @example
+* ```ts
+* const { pdf, report } = await sanitizePdf(bytes);
+* // report.removed === ['javascript', 'embeddedFiles', 'metadata']
+* ```
+*/
+async function sanitizePdf(pdf, options) {
+	const removeJavaScript = options?.javascript ?? true;
+	const removeOpenActions = options?.openActions ?? true;
+	const removeEmbeddedFiles = options?.embeddedFiles ?? true;
+	const removeMetadata = options?.metadata ?? true;
+	const registry = (await loadPdf(pdf)).getRegistry();
+	const catalogs = findCatalogEntries(registry);
+	if (catalogs.length === 0) return {
+		pdf,
+		report: { removed: [] }
+	};
+	const pages = findPages(registry);
+	const infoDict = findInfoDict(registry, catalogs);
+	const removed = /* @__PURE__ */ new Set();
+	if (removeJavaScript) {
+		for (const { dict: catalog } of catalogs) {
+			const names = getNamesDict(catalog, registry);
+			if (names !== void 0 && nameTreeHasEntries(names.get("/JavaScript"), registry)) removed.add("javascript");
+			if (aaHasJavaScript(asDict(catalog.get("/AA"), registry), registry)) removed.add("javascript");
+		}
+		for (const page of pages) if (aaHasJavaScript(asDict(page.get("/AA"), registry), registry)) removed.add("javascript");
+		for (const { dict: catalog } of catalogs) {
+			const names = getNamesDict(catalog, registry);
+			if (names !== void 0) {
+				names.delete("/JavaScript");
+				if (names.size === 0) catalog.delete("/Names");
+			}
+			catalog.delete("/AA");
+		}
+		for (const page of pages) page.delete("/AA");
+	}
+	if (removeOpenActions) {
+		for (const { dict: catalog } of catalogs) if (catalog.has("/OpenAction")) {
+			removed.add("openActions");
+			catalog.delete("/OpenAction");
+		}
+	}
+	if (removeEmbeddedFiles) {
+		for (const { dict: catalog } of catalogs) {
+			const names = getNamesDict(catalog, registry);
+			if (names !== void 0 && nameTreeHasEntries(names.get("/EmbeddedFiles"), registry)) removed.add("embeddedFiles");
+			const af = resolve$2(catalog.get("/AF"), registry);
+			if (af instanceof PdfArray && af.length > 0) removed.add("embeddedFiles");
+		}
+		for (const { dict: catalog } of catalogs) {
+			const names = getNamesDict(catalog, registry);
+			if (names !== void 0) {
+				names.delete("/EmbeddedFiles");
+				if (names.size === 0) catalog.delete("/Names");
+			}
+			catalog.delete("/AF");
+		}
+	}
+	const preservedMeta = readInfoMetadata(infoDict, registry);
+	if (removeMetadata) {
+		let metadataPresent = false;
+		for (const { dict: catalog } of catalogs) if (resolve$2(catalog.get("/Metadata"), registry) instanceof PdfStream) metadataPresent = true;
+		if (infoDict !== void 0 && DESCRIPTIVE_INFO_KEYS.some((k) => infoDict.has(k))) metadataPresent = true;
+		if (metadataPresent) removed.add("metadata");
+		for (const { dict: catalog } of catalogs) catalog.delete("/Metadata");
+		if (infoDict !== void 0) for (const [key] of [...infoDict]) infoDict.delete(key);
+	}
+	const root = catalogs[0];
+	const pagesRef = root.dict.get("/Pages");
+	let infoRef;
+	if (removeMetadata) infoRef = buildInfoDict({}, registry);
+	else infoRef = buildInfoDict(preservedMeta, registry);
+	const structure = {
+		catalogRef: root.ref,
+		infoRef,
+		pagesRef: pagesRef instanceof PdfRef ? pagesRef : root.ref
+	};
+	registry.filterReachable([structure.catalogRef, structure.infoRef]);
+	return {
+		pdf: await serializePdf(registry, structure, { compress: true }),
+		report: { removed: [...removed] }
+	};
+}
+//#endregion
+//#region src/security/redactionVerifier.ts
+/**
+* @module security/redactionVerifier
+*
+* Detect FAILED / fake redactions — text that is still extractable underneath
+* a redaction region.
+*
+* A *secure* redaction physically removes the underlying text-showing
+* operators from the page content stream (see `redactRegions` in
+* `../render/redactContent.js`), so the redacted text cannot be recovered by
+* copy/paste, text extraction, or raw stream inspection.  A *fake* redaction
+* merely paints an opaque black box on top of the page while the original text
+* remains in the byte stream — a genuine, well-documented security failure
+* (the "select-all-and-copy" leak).  This verifier finds those leaks.
+*
+* ## How it works
+*
+* For each page named by a region:
+* 1. The page's content stream is decoded
+*    (`PdfPage.getContentStream()`) and parsed (`parseContentStream`).
+* 2. `extractTextWithPositions` replays the text/graphics-state machine and
+*    yields one positioned {@link import('../parser/textExtractor.js').TextItem}
+*    per shown text run, with its page-space origin and size.
+* 3. Every text item whose bounding box intersects a region rectangle is
+*    reported as a leak.  `clean` is true iff there are no leaks.
+*
+* ## Coordinate / encoding conventions (confirmed, not assumed)
+*
+* - **Space:** PDF user space — the coordinate space produced by
+*   `extractTextWithPositions`.  Origin is **bottom-left**, the y-axis points
+*   **up**, and units are **PDF points** (1/72 inch).  This matches
+*   `RedactRect` in `../render/redactContent.js` ("page space, PDF points,
+*   y-up, lower-left origin"), so a {@link RedactionRegion} uses exactly the
+*   same convention: `(x, y)` is the lower-left corner and `width` / `height`
+*   extend in the +x / +y directions.
+* - **Glyph box:** a `TextItem` reports `(x, y)` = the text origin
+*   (baseline-left), `width` extending +x, and `height` (equal to the font
+*   size) extending +y.  The run's axis-aligned box is therefore
+*   `[x, y, x + width, y + height]`.  Note `width`/`height` are heuristic
+*   estimates from `extractTextWithPositions` (0.5·fontSize per character;
+*   height = fontSize) because per-glyph font metrics are not available there;
+*   intersection testing tolerates this by treating any overlap as a leak.
+* - **Text decoding:** strings are decoded by `extractTextWithPositions` using
+*   the font's `/ToUnicode` CMap when present, else WinAnsiEncoding (1-byte) or
+*   2-byte Identity-H for CID fonts — see `../parser/textExtractor.js`.
+*
+* ## Region auto-detection is intentionally NOT performed
+*
+* The `regions` argument is **required**.  Deriving candidate regions from the
+* PDF itself is not reliable through the public API and is not fabricated here:
+*   - Filled black rectangles in the content stream are indistinguishable from
+*     legitimate black-filled graphics (chart bars, rules, design elements), so
+*     a heuristic would produce false positives/negatives.
+*   - `/Redact` annotations (ISO 32000-2 §12.5.6.23) *do* carry explicit
+*     `/Rect` / `/QuadPoints` regions, but a loaded page's original annotation
+*     dictionaries are not exposed through a stable public `PdfPage` accessor,
+*     so reading them here is not possible without reaching into private state.
+* Callers must therefore pass the regions they redacted (or believe were
+* redacted).  When `regions` is omitted or empty, {@link verifyRedactions}
+* throws.
+*
+* @packageDocumentation
+*/
+/**
+* Axis-aligned bounding box of a text run in page space (bottom-left origin).
+* `width`/`height` may be zero (empty text); such runs never intersect.
+*/
+function itemBox(item) {
+	const x0 = item.x;
+	const y0 = item.y;
+	const x1 = item.x + item.width;
+	const y1 = item.y + item.height;
+	return {
+		minX: Math.min(x0, x1),
+		minY: Math.min(y0, y1),
+		maxX: Math.max(x0, x1),
+		maxY: Math.max(y0, y1)
+	};
+}
+/**
+* Whether a text run's box overlaps a region rectangle.
+*
+* Uses the standard separating-axis test for axis-aligned rectangles: they
+* overlap unless one is entirely to the left/right/above/below the other.
+* Touching edges count as overlap (inclusive bounds), matching the intersection
+* test in `../render/redactContent.js`.
+*/
+function intersects$1(box, region) {
+	const rMinX = region.x;
+	const rMinY = region.y;
+	const rMaxX = region.x + region.width;
+	const rMaxY = region.y + region.height;
+	return box.minX <= rMaxX && box.maxX >= rMinX && box.minY <= rMaxY && box.maxY >= rMinY;
+}
+/**
+* Verify that the given regions of a PDF contain no still-extractable text,
+* detecting fake / failed redactions.
+*
+* For each region, the corresponding page's text is extracted with positions
+* and any text run whose bounding box intersects the region is reported as a
+* {@link RedactionLeak}.  A clean result means no text was found under any
+* region (the redactions truly removed the content, or there was none to begin
+* with).
+*
+* @param pdf      The PDF file bytes to inspect.
+* @param regions  The regions to check (REQUIRED — see the module docs for why
+*                 automatic region detection is not performed).  Coordinates are
+*                 in PDF user space: origin bottom-left, y-up, units in points;
+*                 `(x, y)` is the lower-left corner.
+* @returns        A report listing every leak; `clean` is true iff there are
+*                 none.
+* @throws         `TypeError` if `regions` is omitted or empty.
+*
+* @example
+* ```ts
+* const report = await verifyRedactions(pdfBytes, [
+*   { page: 0, x: 45, y: 545, width: 120, height: 25 },
+* ]);
+* if (!report.clean) {
+*   for (const leak of report.leaks) {
+*     console.warn(`Leak on page ${leak.page}: "${leak.text}"`);
+*   }
+* }
+* ```
+*/
+async function verifyRedactions(pdf, regions) {
+	if (regions === void 0 || regions.length === 0) throw new TypeError("verifyRedactions requires an explicit, non-empty `regions` array. Automatic redaction-region detection is not performed: black-filled rectangles are indistinguishable from legitimate graphics, and a loaded page's original /Redact annotations are not exposed through a stable public API. Pass the regions you redacted (PDF points, bottom-left origin, y-up).");
+	const doc = await loadPdf(pdf);
+	const pageCount = doc.getPageCount();
+	const itemsByPage = /* @__PURE__ */ new Map();
+	const getItems = (pageIndex) => {
+		const cached = itemsByPage.get(pageIndex);
+		if (cached !== void 0) return cached;
+		let items = [];
+		if (pageIndex >= 0 && pageIndex < pageCount) {
+			const page = doc.getPage(pageIndex);
+			items = extractTextWithPositions(parseContentStream(page.getContentStream()), page.getOriginalResources());
+		}
+		itemsByPage.set(pageIndex, items);
+		return items;
+	};
+	const leaks = [];
+	for (const region of regions) {
+		if (region.width <= 0 || region.height <= 0) continue;
+		const items = getItems(region.page);
+		for (const item of items) {
+			if (item.text.length === 0) continue;
+			const box = itemBox(item);
+			if (box.maxX === box.minX && box.maxY === box.minY) continue;
+			if (intersects$1(box, region)) leaks.push({
+				page: region.page,
+				text: item.text,
+				x: item.x,
+				y: item.y
+			});
+		}
+	}
+	return {
+		leaks,
+		clean: leaks.length === 0,
+		regionsChecked: regions.length
+	};
+}
+//#endregion
+//#region src/security/encryptionInspector.ts
+const BIT_PRINT = 4;
+const BIT_MODIFY = 8;
+const BIT_COPY = 16;
+const BIT_ANNOTATE = 32;
+const BIT_FILL_FORMS = 256;
+const BIT_ASSEMBLE = 1024;
+const BIT_PRINT_HIGH_RES = 2048;
+/**
+* Inspect a PDF's encryption + permission posture.
+*
+* @param pdf  The raw PDF file bytes.
+* @returns    A {@link EncryptionReport}.  If the trailer has no
+*             `/Encrypt` entry (or the file is unparseable) the report is
+*             `{ encrypted: false }`.
+*/
+async function inspectEncryption(pdf) {
+	const located = await locateEncryptDict(pdf);
+	if (located === void 0) return { encrypted: false };
+	const { encryptDict, fileId, encryptRef } = located;
+	const filterName = getName(encryptDict, "/Filter");
+	let handler;
+	if (filterName === "/Standard") handler = "password";
+	else if (filterName === "/Adobe.PubSec") handler = "publicKey";
+	const version = getNumber(encryptDict, "/V");
+	const revision = getNumber(encryptDict, "/R");
+	const { method, keyBits } = decodeAlgorithm(encryptDict, version);
+	let permissions;
+	const pValue = getNumber(encryptDict, "/P");
+	if (handler === "password" && pValue !== void 0) permissions = decodePermissionBits(pValue);
+	let emptyUserPassword;
+	if (handler === "password") emptyUserPassword = await testEmptyUserPassword(encryptDict, fileId);
+	const report = { encrypted: true };
+	if (method !== void 0) report.method = method;
+	if (keyBits !== void 0) report.keyBits = keyBits;
+	if (version !== void 0) report.version = version;
+	if (revision !== void 0) report.revision = revision;
+	if (handler !== void 0) report.handler = handler;
+	if (emptyUserPassword !== void 0) report.emptyUserPassword = emptyUserPassword;
+	if (permissions !== void 0) report.permissions = permissions;
+	return report;
+}
+/**
+* Parse just enough of the PDF (header + xref + trailer) to resolve the
+* `/Encrypt` dictionary and the first element of the `/ID` array.
+*
+* Returns `undefined` when the file has no `/Encrypt` entry or when it
+* cannot be parsed far enough to find one.
+*/
+async function locateEncryptDict(pdf) {
+	if (pdf.length < 8) return void 0;
+	let encryptRef;
+	let fileIdFirst;
+	let entry;
+	let objectParser;
+	try {
+		objectParser = new PdfObjectParser(new PdfLexer(pdf), new PdfObjectRegistry());
+		const { entries, trailer } = await new XrefParser(pdf, objectParser).parseXref();
+		encryptRef = trailer.encryptRef;
+		if (encryptRef === void 0) return void 0;
+		fileIdFirst = trailer.id?.[0] ?? /* @__PURE__ */ new Uint8Array(0);
+		entry = entries.get(encryptRef.objectNumber);
+	} catch {
+		return;
+	}
+	if (entry === void 0 || entry.type !== "in-use") return void 0;
+	let encryptObj;
+	try {
+		const { object } = objectParser.parseIndirectObjectAt(entry.offset);
+		encryptObj = object;
+	} catch {
+		return;
+	}
+	if (encryptObj.kind !== "dict") return void 0;
+	return {
+		encryptDict: encryptObj,
+		encryptRef,
+		fileId: fileIdFirst
+	};
+}
+/**
+* Decode the bulk cipher and key length from an encryption dictionary.
+*
+* - V=1: 40-bit RC4 (Table 20/21).
+* - V=2: RC4 with `/Length` bits.
+* - V=4: inspect the crypt filter `/CFM` of the filter named by `/StmF`
+*   (falling back to `/StdCF`): `/V2` → RC4, `/AESV2` → 128-bit AES,
+*   `/AESV3` → 256-bit AES, `/Identity`/`/None` → no encryption.
+* - V=5: 256-bit AES (`/AESV3`).
+*/
+function decodeAlgorithm(dict, version) {
+	const lengthBits = getNumber(dict, "/Length");
+	if (version === 1) return {
+		method: "rc4",
+		keyBits: 40
+	};
+	if (version === 2) return {
+		method: "rc4",
+		keyBits: lengthBits ?? 40
+	};
+	if (version === 5) return {
+		method: "aes",
+		keyBits: 256
+	};
+	if (version === 4) {
+		const cfm = resolveCryptFilterMethod(dict);
+		if (cfm === "/AESV3") return {
+			method: "aes",
+			keyBits: 256
+		};
+		if (cfm === "/AESV2") return {
+			method: "aes",
+			keyBits: lengthBits ?? 128
+		};
+		if (cfm === "/V2") return {
+			method: "rc4",
+			keyBits: lengthBits ?? 128
+		};
+		return {
+			method: void 0,
+			keyBits: lengthBits ?? void 0
+		};
+	}
+	return {
+		method: void 0,
+		keyBits: lengthBits ?? void 0
+	};
+}
+/**
+* For V=4 documents, resolve the `/CFM` (crypt filter method) name of the
+* stream crypt filter.  Looks up `/StmF` in `/CF`, then falls back to the
+* conventional `/StdCF` entry.
+*/
+function resolveCryptFilterMethod(dict) {
+	const cf = dict.get("/CF");
+	if (cf === void 0 || cf.kind !== "dict") return void 0;
+	const cfDict = cf;
+	let filterName = getName(dict, "/StmF");
+	if (filterName === "/Identity") return "/Identity";
+	let stdCf = filterName !== void 0 ? cfDict.get(filterName) : void 0;
+	if (stdCf === void 0 || stdCf.kind !== "dict") {
+		stdCf = cfDict.get("/StdCF");
+		filterName = "/StdCF";
+	}
+	if (stdCf === void 0 || stdCf.kind !== "dict") return void 0;
+	return getName(stdCf, "/CFM");
+}
+/**
+* Decode the 32-bit `/P` integer into individual permission flags.
+*
+* The `/P` value is a *signed* 32-bit integer; bitwise AND in JavaScript
+* operates on the 32-bit two's-complement representation, so masks apply
+* correctly even when `/P` is negative (the usual case, since reserved
+* high bits are set to 1).
+*/
+function decodePermissionBits(p) {
+	const has = (mask) => (p & mask) !== 0;
+	const copy = has(BIT_COPY);
+	return {
+		print: has(BIT_PRINT),
+		modify: has(BIT_MODIFY),
+		copy,
+		annotate: has(BIT_ANNOTATE),
+		fillForms: has(BIT_FILL_FORMS),
+		extract: copy,
+		assemble: has(BIT_ASSEMBLE),
+		printHighRes: has(BIT_PRINT_HIGH_RES)
+	};
+}
+/**
+* Test whether the empty user password (`""`) authenticates against the
+* standard security handler.  Reuses {@link PdfEncryptionHandler.fromEncryptDict},
+* which throws when the password is incorrect; a successful return means
+* the empty password derived a valid file key.
+*
+* Returns `undefined` when the test cannot be performed (e.g. the handler
+* implementation does not support the document's /V/R).
+*/
+async function testEmptyUserPassword(dict, fileId) {
+	try {
+		await PdfEncryptionHandler.fromEncryptDict(dict, fileId, "");
+		return true;
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		if (/password/i.test(message)) return false;
+		return;
+	}
+}
+/** Read a `/Name` value (including the leading `/`) from a dict. */
+function getName(dict, key) {
+	const obj = dict.get(key);
+	if (obj !== void 0 && obj.kind === "name") return obj.value;
+}
+/** Read a numeric value from a dict. */
+function getNumber(dict, key) {
+	const obj = dict.get(key);
+	if (obj !== void 0 && obj.kind === "number") return obj.value;
+}
+//#endregion
+//#region src/text/bidi.ts
+/** UAX #9 §3.3.2: the maximum explicit embedding depth. */
+const MAX_DEPTH = 125;
+/**
+* Classify a Unicode scalar value into its {@link BC} Bidi_Class.
+*
+* Range-based subset of DerivedBidiClass.txt (Unicode 16.0.0). Covers Latin,
+* Hebrew, Arabic, the digit groups, neutrals/weaks and all explicit-format and
+* isolate characters. Anything outside the listed ranges falls back to the
+* Unicode default class for that area (`R`/`AL` in the default-RTL blocks,
+* else `L`).
+*
+* @param cp Unicode scalar value (code point).
+* @returns The character's Bidi_Class.
+*/
+function bidiClass(cp) {
+	switch (cp) {
+		case 8234: return "LRE";
+		case 8235: return "RLE";
+		case 8237: return "LRO";
+		case 8238: return "RLO";
+		case 8236: return "PDF";
+		case 8294: return "LRI";
+		case 8295: return "RLI";
+		case 8296: return "FSI";
+		case 8297: return "PDI";
+		default: break;
+	}
+	if (cp < 128) {
+		if (cp === 10 || cp === 13 || cp === 28 || cp === 29 || cp === 30 || cp === 133) return "B";
+		if (cp === 9 || cp === 11 || cp === 31) return "S";
+		if (cp === 12 || cp === 32) return "WS";
+		if (cp >= 48 && cp <= 57) return "EN";
+		if (cp === 43 || cp === 45) return "ES";
+		if (cp === 35 || cp === 36 || cp === 37) return "ET";
+		if (cp === 44 || cp === 46 || cp === 47 || cp === 58) return "CS";
+		if (cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122) return "L";
+		return "ON";
+	}
+	if (cp === 133) return "B";
+	if (cp === 160) return "CS";
+	if (cp === 163 || cp === 164 || cp === 165 || cp === 176 || cp === 177) return "ET";
+	if (cp === 171 || cp === 187) return "ON";
+	if (cp >= 1425 && cp <= 1469) return "NSM";
+	if (cp === 1471 || cp === 1473 || cp === 1474 || cp === 1476 || cp === 1477 || cp === 1479) return "NSM";
+	if (cp >= 1424 && cp <= 1535) return "R";
+	if (cp >= 1536 && cp <= 1541) return "AN";
+	if (cp >= 1632 && cp <= 1641) return "AN";
+	if (cp === 1643 || cp === 1644) return "AN";
+	if (cp === 1642) return "ET";
+	if (cp >= 1776 && cp <= 1785) return "EN";
+	if (cp >= 1552 && cp <= 1562) return "NSM";
+	if (cp >= 1611 && cp <= 1631) return "NSM";
+	if (cp === 1648) return "NSM";
+	if (cp >= 1750 && cp <= 1756) return "NSM";
+	if (cp >= 1759 && cp <= 1764) return "NSM";
+	if (cp === 1767 || cp === 1768) return "NSM";
+	if (cp >= 1770 && cp <= 1773) return "NSM";
+	if (cp >= 1536 && cp <= 1791) return "AL";
+	if (cp >= 1792 && cp <= 1871) return "AL";
+	if (cp >= 1872 && cp <= 1919) return "AL";
+	if (cp >= 1920 && cp <= 1983) return "AL";
+	if (cp === 8232) return "WS";
+	if (cp === 8233) return "B";
+	if (cp >= 8192 && cp <= 8202) return "WS";
+	if (cp === 8203) return "BN";
+	if (cp === 8206) return "L";
+	if (cp === 8207) return "R";
+	if (cp === 1564) return "AL";
+	if (cp === 8239) return "CS";
+	if (cp === 8287) return "WS";
+	if (cp === 12288) return "WS";
+	if (cp === 65279) return "BN";
+	if (cp >= 768 && cp <= 879) return "NSM";
+	if (cp >= 8400 && cp <= 8447) return "NSM";
+	return "L";
+}
+/**
+* Map of opening bracket → closing bracket and vice versa for UAX #9 N0
+* (paired brackets). Subset of BidiBrackets.txt (Unicode 16.0.0) covering the
+* ASCII and common CJK/typographic pairs. Canonical-equivalent singletons
+* (U+2329/U+232A) are folded onto their canonical forms per BD16.
+*/
+const BRACKET_PAIRS = /* @__PURE__ */ new Map([
+	[40, {
+		other: 41,
+		open: true
+	}],
+	[41, {
+		other: 40,
+		open: false
+	}],
+	[91, {
+		other: 93,
+		open: true
+	}],
+	[93, {
+		other: 91,
+		open: false
+	}],
+	[123, {
+		other: 125,
+		open: true
+	}],
+	[125, {
+		other: 123,
+		open: false
+	}],
+	[3898, {
+		other: 3899,
+		open: true
+	}],
+	[3899, {
+		other: 3898,
+		open: false
+	}],
+	[3900, {
+		other: 3901,
+		open: true
+	}],
+	[3901, {
+		other: 3900,
+		open: false
+	}],
+	[5787, {
+		other: 5788,
+		open: true
+	}],
+	[5788, {
+		other: 5787,
+		open: false
+	}],
+	[8261, {
+		other: 8262,
+		open: true
+	}],
+	[8262, {
+		other: 8261,
+		open: false
+	}],
+	[8317, {
+		other: 8318,
+		open: true
+	}],
+	[8318, {
+		other: 8317,
+		open: false
+	}],
+	[8333, {
+		other: 8334,
+		open: true
+	}],
+	[8334, {
+		other: 8333,
+		open: false
+	}],
+	[9001, {
+		other: 9002,
+		open: true
+	}],
+	[9002, {
+		other: 9001,
+		open: false
+	}],
+	[10088, {
+		other: 10089,
+		open: true
+	}],
+	[10089, {
+		other: 10088,
+		open: false
+	}],
+	[10090, {
+		other: 10091,
+		open: true
+	}],
+	[10091, {
+		other: 10090,
+		open: false
+	}],
+	[10092, {
+		other: 10093,
+		open: true
+	}],
+	[10093, {
+		other: 10092,
+		open: false
+	}],
+	[10094, {
+		other: 10095,
+		open: true
+	}],
+	[10095, {
+		other: 10094,
+		open: false
+	}],
+	[10096, {
+		other: 10097,
+		open: true
+	}],
+	[10097, {
+		other: 10096,
+		open: false
+	}],
+	[10098, {
+		other: 10099,
+		open: true
+	}],
+	[10099, {
+		other: 10098,
+		open: false
+	}],
+	[10100, {
+		other: 10101,
+		open: true
+	}],
+	[10101, {
+		other: 10100,
+		open: false
+	}],
+	[10214, {
+		other: 10215,
+		open: true
+	}],
+	[10215, {
+		other: 10214,
+		open: false
+	}],
+	[10216, {
+		other: 10217,
+		open: true
+	}],
+	[10217, {
+		other: 10216,
+		open: false
+	}],
+	[10218, {
+		other: 10219,
+		open: true
+	}],
+	[10219, {
+		other: 10218,
+		open: false
+	}],
+	[10220, {
+		other: 10221,
+		open: true
+	}],
+	[10221, {
+		other: 10220,
+		open: false
+	}],
+	[10222, {
+		other: 10223,
+		open: true
+	}],
+	[10223, {
+		other: 10222,
+		open: false
+	}],
+	[10627, {
+		other: 10628,
+		open: true
+	}],
+	[10628, {
+		other: 10627,
+		open: false
+	}],
+	[12296, {
+		other: 12297,
+		open: true
+	}],
+	[12297, {
+		other: 12296,
+		open: false
+	}],
+	[12298, {
+		other: 12299,
+		open: true
+	}],
+	[12299, {
+		other: 12298,
+		open: false
+	}],
+	[12300, {
+		other: 12301,
+		open: true
+	}],
+	[12301, {
+		other: 12300,
+		open: false
+	}],
+	[12302, {
+		other: 12303,
+		open: true
+	}],
+	[12303, {
+		other: 12302,
+		open: false
+	}],
+	[12304, {
+		other: 12305,
+		open: true
+	}],
+	[12305, {
+		other: 12304,
+		open: false
+	}],
+	[12308, {
+		other: 12309,
+		open: true
+	}],
+	[12309, {
+		other: 12308,
+		open: false
+	}],
+	[12310, {
+		other: 12311,
+		open: true
+	}],
+	[12311, {
+		other: 12310,
+		open: false
+	}],
+	[12312, {
+		other: 12313,
+		open: true
+	}],
+	[12313, {
+		other: 12312,
+		open: false
+	}],
+	[12314, {
+		other: 12315,
+		open: true
+	}],
+	[12315, {
+		other: 12314,
+		open: false
+	}]
+]);
+/** BD16 canonical-equivalence folding for bracket matching. */
+function canonicalBracket(cp) {
+	if (cp === 12296) return 9001;
+	if (cp === 12297) return 9002;
+	return cp;
+}
+/** True if `bc` is a removed-by-X9 explicit/BN type. */
+function isRemovedByX9(bc) {
+	return bc === "RLE" || bc === "LRE" || bc === "RLO" || bc === "LRO" || bc === "PDF" || bc === "BN";
+}
+/** Strong direction (0 = L, 1 = R) implied by an embedding level's parity. */
+function dirFromLevel(level) {
+	return level % 2 === 0 ? "L" : "R";
+}
+/**
+* Compute the first-strong base level over `types`, skipping the contents of
+* isolate initiators (LRI/RLI/FSI ... matching PDI) per UAX #9 P2/P3, X5c.
+* Returns 0 (LTR) when no strong character is found.
+*/
+function computeBaseLevel(types) {
+	let isolateDepth = 0;
+	for (const t of types) if (t === "LRI" || t === "RLI" || t === "FSI") isolateDepth++;
+	else if (t === "PDI") {
+		if (isolateDepth > 0) isolateDepth--;
+	} else if (isolateDepth === 0) {
+		if (t === "L") return 0;
+		if (t === "R" || t === "AL") return 1;
+	}
+	return 0;
+}
+/**
+* Resolve explicit embedding levels and per-character override directions
+* (UAX #9 X1–X8 plus the isolate rules X5a/X5b/X5c/X6a). Mutates `levels` and
+* returns an array of resolved working types (with overrides applied and X9
+* removals tagged as BN).
+*/
+function resolveExplicit(types, baseLevel, levels) {
+	const result = types.slice();
+	const stack = [{
+		level: baseLevel,
+		override: "neutral",
+		isolate: false
+	}];
+	let overflowIsolate = 0;
+	let overflowEmbedding = 0;
+	let validIsolate = 0;
+	const n = types.length;
+	const matchingPDI = computeMatchingPDI(types);
+	for (let i = 0; i < n; i++) {
+		const t = types[i];
+		const top = stack[stack.length - 1];
+		switch (t) {
+			case "RLE":
+			case "LRE":
+			case "RLO":
+			case "LRO": {
+				levels[i] = top.level;
+				result[i] = "BN";
+				const newLevel = t === "RLE" || t === "RLO" ? nextOddLevel(top.level) : nextEvenLevel(top.level);
+				if (newLevel <= MAX_DEPTH && overflowIsolate === 0 && overflowEmbedding === 0) stack.push({
+					level: newLevel,
+					override: t === "RLO" ? "R" : t === "LRO" ? "L" : "neutral",
+					isolate: false
+				});
+				else if (overflowIsolate === 0) overflowEmbedding++;
+				break;
+			}
+			case "RLI":
+			case "LRI":
+			case "FSI": {
+				levels[i] = top.level;
+				if (top.override !== "neutral") result[i] = top.override;
+				let isRTL = t === "RLI";
+				if (t === "FSI") {
+					const pdi = matchingPDI[i];
+					isRTL = computeBaseLevel(types.slice(i + 1, pdi)) === 1;
+				}
+				const newLevel = isRTL ? nextOddLevel(top.level) : nextEvenLevel(top.level);
+				if (newLevel <= MAX_DEPTH && overflowIsolate === 0 && overflowEmbedding === 0) {
+					validIsolate++;
+					stack.push({
+						level: newLevel,
+						override: "neutral",
+						isolate: true
+					});
+				} else overflowIsolate++;
+				break;
+			}
+			case "PDI": {
+				if (overflowIsolate > 0) overflowIsolate--;
+				else if (validIsolate > 0) {
+					overflowEmbedding = 0;
+					while (!stack[stack.length - 1].isolate) stack.pop();
+					stack.pop();
+					validIsolate--;
+				}
+				const after = stack[stack.length - 1];
+				levels[i] = after.level;
+				if (after.override !== "neutral") result[i] = after.override;
+				break;
+			}
+			case "PDF":
+				levels[i] = top.level;
+				result[i] = "BN";
+				if (overflowIsolate > 0) {} else if (overflowEmbedding > 0) overflowEmbedding--;
+				else if (!top.isolate && stack.length >= 2) stack.pop();
+				break;
+			case "B":
+				stack.length = 1;
+				stack[0] = {
+					level: baseLevel,
+					override: "neutral",
+					isolate: false
+				};
+				overflowIsolate = 0;
+				overflowEmbedding = 0;
+				validIsolate = 0;
+				levels[i] = baseLevel;
+				break;
+			case "BN":
+				levels[i] = top.level;
+				break;
+			default:
+				levels[i] = top.level;
+				if (top.override !== "neutral") result[i] = top.override;
+				break;
+		}
+	}
+	return result;
+}
+/** Next odd level strictly greater than `level` (for RTL embeddings). */
+function nextOddLevel(level) {
+	return level % 2 === 0 ? level + 1 : level + 2;
+}
+/** Next even level strictly greater than `level` (for LTR embeddings). */
+function nextEvenLevel(level) {
+	return level % 2 === 0 ? level + 2 : level + 1;
+}
+/**
+* BD9: for each isolate initiator, find the index of its matching PDI (or `n`
+* if unmatched). Non-initiator positions map to `-1`.
+*/
+function computeMatchingPDI(types) {
+	const n = types.length;
+	const out = new Array(n).fill(-1);
+	for (let i = 0; i < n; i++) {
+		const t = types[i];
+		if (t === "LRI" || t === "RLI" || t === "FSI") {
+			let depth = 1;
+			let j = i + 1;
+			for (; j < n; j++) {
+				const tj = types[j];
+				if (tj === "LRI" || tj === "RLI" || tj === "FSI") depth++;
+				else if (tj === "PDI") {
+					depth--;
+					if (depth === 0) break;
+				}
+			}
+			out[i] = j;
+		}
+	}
+	return out;
+}
+/**
+* Build the isolating run sequences (UAX #9 X10 / BD13) from the resolved
+* levels, skipping characters removed by X9. Computes each sequence's sos/eos
+* boundary directions from the higher of the adjacent levels (rule X10).
+*/
+function buildIsolatingRunSequences(types, levels, baseLevel) {
+	const n = types.length;
+	const retained = [];
+	for (let i = 0; i < n; i++) if (!isRemovedByX9(types[i])) retained.push(i);
+	const levelRuns = [];
+	let cur = [];
+	let curLevel = -1;
+	for (const i of retained) {
+		if (levels[i] !== curLevel) {
+			if (cur.length > 0) levelRuns.push(cur);
+			cur = [];
+			curLevel = levels[i];
+		}
+		cur.push(i);
+	}
+	if (cur.length > 0) levelRuns.push(cur);
+	const runByStart = /* @__PURE__ */ new Map();
+	for (let r = 0; r < levelRuns.length; r++) runByStart.set(levelRuns[r][0], r);
+	const matchingPDI = computeMatchingPDI(types);
+	const matchingInitiator = new Array(n).fill(-1);
+	for (let i = 0; i < n; i++) {
+		const t = types[i];
+		if ((t === "LRI" || t === "RLI" || t === "FSI") && matchingPDI[i] < n) matchingInitiator[matchingPDI[i]] = i;
+	}
+	const used = new Array(levelRuns.length).fill(false);
+	const sequences = [];
+	for (let r = 0; r < levelRuns.length; r++) {
+		if (used[r]) continue;
+		const first = levelRuns[r][0];
+		if (types[first] === "PDI" && matchingInitiator[first] >= 0) continue;
+		const seqIndices = [];
+		let runIdx = r;
+		for (;;) {
+			used[runIdx] = true;
+			const run = levelRuns[runIdx];
+			for (const idx of run) seqIndices.push(idx);
+			const last = run[run.length - 1];
+			const t = types[last];
+			if ((t === "LRI" || t === "RLI" || t === "FSI") && matchingPDI[last] < n) {
+				const next = runByStart.get(matchingPDI[last]);
+				if (next === void 0 || used[next]) break;
+				runIdx = next;
+			} else break;
+		}
+		const seqLevel = levels[seqIndices[0]];
+		const startPos = retained.indexOf(seqIndices[0]);
+		const endPos = retained.indexOf(seqIndices[seqIndices.length - 1]);
+		const prevLevel = startPos > 0 ? levels[retained[startPos - 1]] : baseLevel;
+		const lastType = types[seqIndices[seqIndices.length - 1]];
+		const nextLevel = (lastType === "LRI" || lastType === "RLI" || lastType === "FSI") && matchingPDI[seqIndices[seqIndices.length - 1]] >= n || endPos === retained.length - 1 ? baseLevel : levels[retained[endPos + 1]];
+		sequences.push({
+			indices: seqIndices,
+			sos: dirFromLevel(Math.max(seqLevel, prevLevel)),
+			eos: dirFromLevel(Math.max(seqLevel, nextLevel))
+		});
+	}
+	return sequences;
+}
+/** Apply the weak-type rules W1–W7 to one isolating run sequence in place. */
+function resolveWeak(seq, types) {
+	const idx = seq.indices;
+	const m = idx.length;
+	for (let k = 0; k < m; k++) {
+		const i = idx[k];
+		if (types[i] === "NSM") if (k === 0) types[i] = seq.sos;
+		else {
+			const prev = types[idx[k - 1]];
+			types[i] = prev === "LRI" || prev === "RLI" || prev === "FSI" || prev === "PDI" ? "ON" : prev;
+		}
+	}
+	for (let k = 0; k < m; k++) {
+		const i = idx[k];
+		if (types[i] === "EN") {
+			let strong = seq.sos;
+			for (let j = k - 1; j >= 0; j--) {
+				const tj = types[idx[j]];
+				if (tj === "R" || tj === "L" || tj === "AL") {
+					strong = tj;
+					break;
+				}
+			}
+			if (strong === "AL") types[i] = "AN";
+		}
+	}
+	for (let k = 0; k < m; k++) {
+		const i = idx[k];
+		if (types[i] === "AL") types[i] = "R";
+	}
+	for (let k = 1; k < m - 1; k++) {
+		const i = idx[k];
+		const prev = types[idx[k - 1]];
+		const next = types[idx[k + 1]];
+		if (types[i] === "ES" && prev === "EN" && next === "EN") types[i] = "EN";
+		else if (types[i] === "CS" && prev === next && (prev === "EN" || prev === "AN")) types[i] = prev;
+	}
+	for (let k = 0; k < m; k++) {
+		if (types[idx[k]] !== "ET") continue;
+		let end = k;
+		while (end < m && types[idx[end]] === "ET") end++;
+		const before = k > 0 ? types[idx[k - 1]] : seq.sos;
+		const after = end < m ? types[idx[end]] : seq.eos;
+		if (before === "EN" || after === "EN") for (let j = k; j < end; j++) types[idx[j]] = "EN";
+		k = end - 1;
+	}
+	for (let k = 0; k < m; k++) {
+		const i = idx[k];
+		if (types[i] === "ES" || types[i] === "ET" || types[i] === "CS") types[i] = "ON";
+	}
+	for (let k = 0; k < m; k++) {
+		const i = idx[k];
+		if (types[i] === "EN") {
+			let strong = seq.sos;
+			for (let j = k - 1; j >= 0; j--) {
+				const tj = types[idx[j]];
+				if (tj === "R" || tj === "L") {
+					strong = tj;
+					break;
+				}
+			}
+			if (strong === "L") types[i] = "L";
+		}
+	}
+}
+/** True if a working type counts as a "neutral or isolate formatting" char (NI). */
+function isNI(t) {
+	return t === "B" || t === "S" || t === "WS" || t === "ON" || t === "FSI" || t === "LRI" || t === "RLI" || t === "PDI";
+}
+/** Apply N0 (paired brackets) then N1/N2 to one isolating run sequence. */
+function resolveNeutral(seq, types, levels, codepoints) {
+	const idx = seq.indices;
+	const m = idx.length;
+	const e = dirFromLevel(levels[idx[0]]);
+	resolveBrackets(seq, types, codepoints, e);
+	let k = 0;
+	while (k < m) {
+		if (!isNI(types[idx[k]])) {
+			k++;
+			continue;
+		}
+		let end = k;
+		while (end < m && isNI(types[idx[end]])) end++;
+		const beforeRaw = k > 0 ? types[idx[k - 1]] : seq.sos;
+		const afterRaw = end < m ? types[idx[end]] : seq.eos;
+		const before = beforeRaw === "EN" || beforeRaw === "AN" ? "R" : beforeRaw;
+		const resolved = before === (afterRaw === "EN" || afterRaw === "AN" ? "R" : afterRaw) && (before === "L" || before === "R") ? before : e;
+		for (let j = k; j < end; j++) types[idx[j]] = resolved;
+		k = end;
+	}
+}
+/** N0 paired-bracket resolution (UAX #9 N0 with BD16 pairing). */
+function resolveBrackets(seq, types, codepoints, e) {
+	const idx = seq.indices;
+	const m = idx.length;
+	const stack = [];
+	const pairs = [];
+	for (let k = 0; k < m; k++) {
+		const i = idx[k];
+		if (types[i] !== "ON") continue;
+		const cp = canonicalBracket(codepoints[i]);
+		const info = BRACKET_PAIRS.get(codepoints[i]);
+		if (!info) continue;
+		if (info.open) {
+			if (stack.length >= 63) break;
+			stack.push({
+				bracket: canonicalBracket(info.other),
+				seqPos: k
+			});
+		} else for (let s = stack.length - 1; s >= 0; s--) if (stack[s].bracket === cp) {
+			pairs.push({
+				open: stack[s].seqPos,
+				close: k
+			});
+			stack.length = s;
+			break;
+		}
+	}
+	pairs.sort((a, b) => a.open - b.open);
+	for (const pair of pairs) {
+		let foundE = false;
+		let foundOpposite = false;
+		const opposite = e === "L" ? "R" : "L";
+		for (let k = pair.open + 1; k < pair.close; k++) {
+			const t = strongClass(types[idx[k]]);
+			if (t === e) {
+				foundE = true;
+				break;
+			}
+			if (t === opposite) foundOpposite = true;
+		}
+		let setDir = null;
+		if (foundE) setDir = e;
+		else if (foundOpposite) {
+			let context = seq.sos;
+			for (let k = pair.open - 1; k >= 0; k--) {
+				const t = strongClass(types[idx[k]]);
+				if (t === "L" || t === "R") {
+					context = t;
+					break;
+				}
+			}
+			setDir = context === opposite ? opposite : e;
+		}
+		if (setDir) {
+			types[idx[pair.open]] = setDir;
+			types[idx[pair.close]] = setDir;
+			for (let k = pair.open + 1; k < m; k++) if (originalIsNSM(idx[k], codepoints)) types[idx[k]] = setDir;
+			else break;
+			for (let k = pair.close + 1; k < m; k++) if (originalIsNSM(idx[k], codepoints)) types[idx[k]] = setDir;
+			else break;
+		}
+	}
+}
+/** Reduce a working type to the strong direction it counts as for N0 (EN/AN→R). */
+function strongClass(t) {
+	if (t === "L") return "L";
+	if (t === "R" || t === "EN" || t === "AN") return "R";
+	return null;
+}
+/** True if the original code point at logical index `i` has Bidi_Class NSM. */
+function originalIsNSM(i, codepoints) {
+	return bidiClass(codepoints[i]) === "NSM";
+}
+/** Resolve implicit embedding levels (UAX #9 I1/I2) for one sequence. */
+function resolveImplicit(seq, types, levels) {
+	for (const i of seq.indices) {
+		const level = levels[i];
+		const t = types[i];
+		if (level % 2 === 0) {
+			if (t === "R") levels[i] = level + 1;
+			else if (t === "AN" || t === "EN") levels[i] = level + 2;
+		} else if (t === "L" || t === "EN" || t === "AN") levels[i] = level + 1;
+	}
+}
+/**
+* L1: reset to the paragraph level (1) segment/paragraph separators, and
+* (2) any sequence of whitespace / isolate formatting chars preceding a
+* separator or the end of the line. Operates on a single line (= the whole
+* paragraph here, since we do not perform line breaking).
+*/
+function resetWhitespaceLevels(originalTypes, levels, baseLevel) {
+	const n = levels.length;
+	let resetFrom = n;
+	for (let i = n - 1; i >= 0; i--) {
+		const t = originalTypes[i];
+		if (t === "B" || t === "S") {
+			levels[i] = baseLevel;
+			for (let j = i + 1; j < resetFrom; j++) levels[j] = baseLevel;
+			resetFrom = i;
+		} else if (t === "WS" || t === "FSI" || t === "LRI" || t === "RLI" || t === "PDI" || isRemovedByX9(t)) {} else {
+			if (resetFrom === n) {}
+			resetFrom = i + 1 > resetFrom ? resetFrom : i + 1;
+			resetFrom = i + 1;
+		}
+	}
+	for (let i = n - 1; i >= 0; i--) {
+		const t = originalTypes[i];
+		if (t === "WS" || t === "FSI" || t === "LRI" || t === "RLI" || t === "PDI" || isRemovedByX9(t)) levels[i] = baseLevel;
+		else break;
+	}
+}
+/** L2: reorder code-unit indices into visual order from the resolved levels. */
+function reorderLevels(levels) {
+	const n = levels.length;
+	const order = Array.from({ length: n }, (_, i) => i);
+	if (n === 0) return order;
+	let highest = 0;
+	let lowestOdd = 127;
+	for (const l of levels) {
+		if (l > highest) highest = l;
+		if (l % 2 === 1 && l < lowestOdd) lowestOdd = l;
+	}
+	for (let level = highest; level >= lowestOdd; level--) {
+		let i = 0;
+		while (i < n) if (levels[order[i]] >= level) {
+			let j = i;
+			while (j < n && levels[order[j]] >= level) j++;
+			for (let a = i, b = j - 1; a < b; a++, b--) {
+				const tmp = order[a];
+				order[a] = order[b];
+				order[b] = tmp;
+			}
+			i = j;
+		} else i++;
+	}
+	return order;
+}
+/**
+* Run the Unicode Bidirectional Algorithm (UAX #9) over `text`.
+*
+* Indices in the result refer to UTF-16 code units of the input string (the
+* same units JavaScript's `string[i]` and `.length` use). Astral characters
+* (surrogate pairs) are classified by their scalar value but occupy two code
+* units, both assigned the same level.
+*
+* @param text The logical-order input string.
+* @param base Paragraph direction: `'ltr'` / `'rtl'` force the base level;
+*   `'auto'` (the default) derives it from the first strong character (P2/P3).
+* @returns The resolved levels, same-level runs, visual order and base level.
+*/
+function resolveBidi(text, base = "auto") {
+	const n = text.length;
+	const codepoints = new Array(n);
+	for (let i = 0; i < n; i++) {
+		const c = text.charCodeAt(i);
+		if (c >= 55296 && c <= 56319 && i + 1 < n) {
+			const c2 = text.charCodeAt(i + 1);
+			if (c2 >= 56320 && c2 <= 57343) {
+				const scalar = (c - 55296) * 1024 + (c2 - 56320) + 65536;
+				codepoints[i] = scalar;
+				codepoints[i + 1] = scalar;
+				i++;
+				continue;
+			}
+		}
+		codepoints[i] = c;
+	}
+	const originalTypes = codepoints.map(bidiClass);
+	let baseLevel;
+	if (base === "ltr") baseLevel = 0;
+	else if (base === "rtl") baseLevel = 1;
+	else baseLevel = computeBaseLevel(originalTypes);
+	const levels = new Array(n).fill(baseLevel);
+	if (n === 0) return {
+		runs: [],
+		levels: [],
+		visualOrder: [],
+		baseLevel
+	};
+	const workingTypes = resolveExplicit(originalTypes, baseLevel, levels);
+	const sequences = buildIsolatingRunSequences(workingTypes, levels, baseLevel);
+	for (const seq of sequences) {
+		resolveWeak(seq, workingTypes);
+		resolveNeutral(seq, workingTypes, levels, codepoints);
+		resolveImplicit(seq, workingTypes, levels);
+	}
+	resetWhitespaceLevels(originalTypes, levels, baseLevel);
+	const visualOrder = reorderLevels(levels);
+	const runs = [];
+	let start = 0;
+	while (start < n) {
+		const level = levels[start];
+		let end = start + 1;
+		while (end < n && levels[end] === level) end++;
+		runs.push({
+			text: text.slice(start, end),
+			level,
+			direction: dirFromLevel(level) === "L" ? "ltr" : "rtl",
+			start,
+			length: end - start
+		});
+		start = end;
+	}
+	return {
+		runs,
+		levels,
+		visualOrder,
+		baseLevel
+	};
+}
+/**
+* Convenience wrapper that returns `text` reordered into visual (left-to-right)
+* order via {@link resolveBidi}'s L2 result.
+*
+* Note: this performs pure reordering of code units. It does not apply Arabic
+* cursive shaping or mirror neutral glyphs; callers that need shaped glyphs
+* should pass the resolved runs to a shaping engine.
+*
+* @param text The logical-order input string.
+* @param base Paragraph direction (see {@link resolveBidi}).
+* @returns The visually reordered string.
+*/
+function reorderVisual(text, base = "auto") {
+	const { visualOrder } = resolveBidi(text, base);
+	let out = "";
+	for (const i of visualOrder) out += text[i];
+	return out;
+}
+//#endregion
+//#region src/assets/font/variableFont.ts
+function readTableDirectory$1(data) {
+	if (data.length < 12) return null;
+	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	const numTables = view.getUint16(4, false);
+	const dirEnd = 12 + numTables * 16;
+	if (numTables === 0 || dirEnd > data.length) return null;
+	const tables = /* @__PURE__ */ new Map();
+	for (let i = 0; i < numTables; i++) {
+		const recOff = 12 + i * 16;
+		const tag = String.fromCharCode(data[recOff], data[recOff + 1], data[recOff + 2], data[recOff + 3]);
+		const offset = view.getUint32(recOff + 8, false);
+		const length = view.getUint32(recOff + 12, false);
+		tables.set(tag, {
+			offset,
+			length
+		});
+	}
+	return tables;
+}
+/**
+* Read a Fixed (16.16 signed) value: a big-endian int32 divided by 65536.
+* Used by 'fvar' for axis min/default/max and instance coordinates.
+*/
+function readFixed(view, off) {
+	return view.getInt32(off, false) / 65536;
+}
+/**
+* Read an F2DOT14 (2.14 signed) value: a big-endian int16 divided by 16384.
+* Used by 'avar' for AxisValueMap from/to coordinates.
+*/
+function readF2Dot14(view, off) {
+	return view.getInt16(off, false) / 16384;
+}
+function parseAvar(data, rec, expectedAxisCount) {
+	if (rec.offset + 8 > data.length) return void 0;
+	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	if (view.getUint16(rec.offset, false) !== 1) return void 0;
+	const axisCount = view.getUint16(rec.offset + 6, false);
+	if (axisCount !== expectedAxisCount) return void 0;
+	const segmentMaps = [];
+	let cursor = rec.offset + 8;
+	const tableEnd = rec.offset + rec.length;
+	for (let a = 0; a < axisCount; a++) {
+		if (cursor + 2 > data.length || cursor + 2 > tableEnd) return void 0;
+		const positionMapCount = view.getUint16(cursor, false);
+		cursor += 2;
+		const recordsBytes = positionMapCount * 4;
+		if (cursor + recordsBytes > data.length || cursor + recordsBytes > tableEnd) return;
+		const maps = [];
+		for (let i = 0; i < positionMapCount; i++) {
+			const from = readF2Dot14(view, cursor);
+			const to = readF2Dot14(view, cursor + 2);
+			maps.push({
+				fromCoordinate: from,
+				toCoordinate: to
+			});
+			cursor += 4;
+		}
+		segmentMaps.push(maps);
+	}
+	return segmentMaps;
+}
+/**
+* Parse the variable-font model from raw OpenType/TrueType font bytes.
+*
+* If the font has no 'fvar' table (or it is malformed / has zero axes), the
+* font is treated as non-variable and
+* `{ isVariable: false, axes: [], namedInstances: [] }` is returned.
+*
+* @param fontData Raw font file bytes (sfnt: TrueType 0x00010000 or 'OTTO' CFF).
+* @returns The parsed {@link VariableFontInfo}.
+*/
+function parseVariableFont(fontData) {
+	const notVariable = {
+		isVariable: false,
+		axes: [],
+		namedInstances: []
+	};
+	const tables = readTableDirectory$1(fontData);
+	if (!tables) return notVariable;
+	const fvar = tables.get("fvar");
+	if (!fvar) return notVariable;
+	if (fvar.offset + 16 > fontData.length) return notVariable;
+	const view = new DataView(fontData.buffer, fontData.byteOffset, fontData.byteLength);
+	if (view.getUint16(fvar.offset, false) !== 1) return notVariable;
+	const axesArrayOffset = view.getUint16(fvar.offset + 4, false);
+	const axisCount = view.getUint16(fvar.offset + 8, false);
+	const axisSize = view.getUint16(fvar.offset + 10, false);
+	const instanceCount = view.getUint16(fvar.offset + 12, false);
+	const instanceSize = view.getUint16(fvar.offset + 14, false);
+	if (axisCount === 0) return notVariable;
+	if (axisSize < 20) return notVariable;
+	const axes = [];
+	const axesStart = fvar.offset + axesArrayOffset;
+	const axesBytes = axisCount * axisSize;
+	if (axesStart + axesBytes > fontData.length) return notVariable;
+	for (let i = 0; i < axisCount; i++) {
+		const recOff = axesStart + i * axisSize;
+		const tag = String.fromCharCode(view.getUint8(recOff), view.getUint8(recOff + 1), view.getUint8(recOff + 2), view.getUint8(recOff + 3));
+		const minValue = readFixed(view, recOff + 4);
+		const defaultValue = readFixed(view, recOff + 8);
+		const maxValue = readFixed(view, recOff + 12);
+		const flags = view.getUint16(recOff + 16, false);
+		axes.push({
+			tag,
+			minValue,
+			defaultValue,
+			maxValue,
+			flags,
+			name: void 0
+		});
+	}
+	const coordsBytes = axisCount * 4;
+	const baseInstanceSize = coordsBytes + 4;
+	const hasPostScriptName = instanceSize >= baseInstanceSize + 2;
+	const namedInstances = [];
+	const instancesStart = axesStart + axesBytes;
+	if (instanceSize >= baseInstanceSize) {
+		if (instancesStart + instanceCount * instanceSize <= fontData.length) for (let i = 0; i < instanceCount; i++) {
+			const recOff = instancesStart + i * instanceSize;
+			const subfamilyNameID = view.getUint16(recOff, false);
+			const coordinates = {};
+			for (let a = 0; a < axisCount; a++) {
+				const value = readFixed(view, recOff + 4 + a * 4);
+				const axis = axes[a];
+				coordinates[axis.tag] = value;
+			}
+			const instance = {
+				nameId: subfamilyNameID,
+				coordinates,
+				name: void 0
+			};
+			if (hasPostScriptName) {
+				const psNameId = view.getUint16(recOff + 4 + coordsBytes, false);
+				instance.postScriptNameId = psNameId === 65535 ? void 0 : psNameId;
+			}
+			namedInstances.push(instance);
+		}
+	}
+	let avar;
+	const avarRec = tables.get("avar");
+	if (avarRec) avar = parseAvar(fontData, avarRec, axisCount);
+	const info = {
+		isVariable: true,
+		axes,
+		namedInstances
+	};
+	if (avar) info.avar = avar;
+	return info;
+}
+/**
+* Apply an 'avar' segment map to a default-normalized coordinate.
+*
+* The segment map is an ordered list of (from, to) pairs in normalized space.
+* The input is located between two consecutive `fromCoordinate` nodes and the
+* output is linearly interpolated between the corresponding `toCoordinate`
+* values. Per spec, a valid map includes the mandatory nodes (-1,-1), (0,0),
+* (1,1); if it does not span the input, the input is clamped to the map's
+* endpoints.
+*/
+function applyAvarSegmentMap(value, segmentMap) {
+	const n = segmentMap.length;
+	if (n === 0) return value;
+	const first = segmentMap[0];
+	if (value <= first.fromCoordinate) return first.toCoordinate;
+	const last = segmentMap[n - 1];
+	if (value >= last.fromCoordinate) return last.toCoordinate;
+	for (let i = 1; i < n; i++) {
+		const lo = segmentMap[i - 1];
+		const hi = segmentMap[i];
+		if (value >= lo.fromCoordinate && value <= hi.fromCoordinate) {
+			const span = hi.fromCoordinate - lo.fromCoordinate;
+			if (span <= 0) return lo.toCoordinate;
+			const t = (value - lo.fromCoordinate) / span;
+			return lo.toCoordinate + t * (hi.toCoordinate - lo.toCoordinate);
+		}
+	}
+	return value;
+}
+/**
+* Normalize a user-scale coordinate for an axis to the normalized [-1, 0, +1]
+* scale, per the OpenType default-normalization algorithm.
+*
+* Steps:
+*  1. Clamp `userValue` to the axis's [minValue, maxValue].
+*  2. Map to normalized space: minValue→-1, defaultValue→0, maxValue→+1, with
+*     linear interpolation on each side of the default (note: the slopes on the
+*     two sides differ unless the default is exactly centered).
+*  3. If an 'avar' `segmentMap` is supplied, apply it to the result; otherwise
+*     no avar adjustment is made (the caller can pass `info.avar[axisIndex]`).
+*
+* @param axis       The axis whose user-scale bounds define the normalization.
+* @param userValue  The user-scale coordinate (e.g. 250 for a 'wght' axis).
+* @param avar       Optional 'avar' segment map for this axis.
+* @returns The normalized coordinate in [-1, 1].
+*/
+function normalizeAxisCoordinate(axis, userValue, avar) {
+	const { minValue, defaultValue, maxValue } = axis;
+	let v = userValue;
+	if (v < minValue) v = minValue;
+	else if (v > maxValue) v = maxValue;
+	let normalized;
+	if (v < defaultValue) {
+		const denom = defaultValue - minValue;
+		normalized = denom === 0 ? 0 : -(defaultValue - v) / denom;
+	} else if (v > defaultValue) {
+		const denom = maxValue - defaultValue;
+		normalized = denom === 0 ? 0 : (v - defaultValue) / denom;
+	} else normalized = 0;
+	if (normalized < -1) normalized = -1;
+	else if (normalized > 1) normalized = 1;
+	if (avar && avar.length > 0) normalized = applyAvarSegmentMap(normalized, avar);
+	return normalized;
+}
+/**
+* Resolve a named instance's coordinates against the font's axes.
+*
+* Produces a complete axis-tag → user-scale-coordinate map covering every axis
+* in the font: any axis the instance does not specify is filled with that
+* axis's `defaultValue`, and any specified coordinate is clamped to the axis's
+* [minValue, maxValue] range (per the fvar "Variation Instance Selection"
+* rules). Coordinates for tags not present on any axis are ignored.
+*
+* @param info     The parsed variable-font model.
+* @param instance The named instance to resolve.
+* @returns A validated axis-tag → user-scale coordinate map.
+*/
+function resolveInstanceCoordinates(info, instance) {
+	const resolved = {};
+	for (const axis of info.axes) {
+		let value = instance.coordinates[axis.tag] ?? axis.defaultValue;
+		if (value < axis.minValue) value = axis.minValue;
+		else if (value > axis.maxValue) value = axis.maxValue;
+		resolved[axis.tag] = value;
+	}
+	return resolved;
+}
+//#endregion
+//#region src/assets/font/colorFont.ts
+/**
+* @module assets/font/colorFont
+*
+* COLR v0 + CPAL color-font parsing (layered color glyphs).
+*
+* This module reads the two OpenType tables that together describe simple,
+* layered color glyphs:
+*
+* - **CPAL** (Color Palette Table): one or more palettes, each a list of
+*   sRGB colors. Color records are stored on disk as **BGRA** bytes and are
+*   exposed here as **RGBA** (0..255 per channel).
+* - **COLR** v0 (Color Table, version 0): maps a *base* glyph to an ordered
+*   list of *layers*. Each layer is another glyph (a monochrome outline) plus
+*   a CPAL palette-entry index giving its color.
+*
+* A renderer paints a color glyph by drawing each layer's outline glyph filled
+* with that layer's resolved palette color, bottom layer first.
+*
+* ## Verified against the OpenType 1.9.1 specification
+*
+* - CPAL header v0 / v1 and the BGRA ColorRecord byte order:
+*   https://learn.microsoft.com/en-us/typography/opentype/spec/cpal
+*   - CPAL v0 header (big-endian): version(u16)\@0, numPaletteEntries(u16)\@2,
+*     numPalettes(u16)\@4, numColorRecords(u16)\@6,
+*     colorRecordsArrayOffset(Offset32)\@8, colorRecordIndices[numPalettes]
+*     (u16 each)\@12.
+*   - "Each color record specifies a color ... using 8-bit BGRA (blue, green,
+*     red, alpha) representation." ColorRecord = blue(u8), green(u8), red(u8),
+*     alpha(u8).
+*   - "colorRecordIndex = colorRecordIndices[paletteIndex] + paletteEntryIndex".
+* - COLR v0 header and records:
+*   https://learn.microsoft.com/en-us/typography/opentype/spec/colr
+*   - COLR v0 header (big-endian): version(u16)\@0, numBaseGlyphRecords(u16)\@2,
+*     baseGlyphRecordsOffset(Offset32)\@4, layerRecordsOffset(Offset32)\@8,
+*     numLayerRecords(u16)\@12.
+*   - BaseGlyph record (6 bytes): glyphID(u16), firstLayerIndex(u16),
+*     numLayers(u16). "The BaseGlyph records must be sorted in increasing
+*     glyphID order ... a binary search can be used" — we binary-search them.
+*   - Layer record (4 bytes): glyphID(u16), paletteIndex(u16).
+*
+* ## Scope
+*
+* - Only **COLR version 0** (flat layered glyphs) is parsed. **COLR version 1**
+*   (PaintColrLayers, gradients, affine transforms, compositing) is OUT OF
+*   SCOPE and intentionally not parsed here.
+* - The CPAL `paletteIndex` special value `0xFFFF` ("use the current text
+*   foreground color") is preserved on each layer via `paletteIndex` but cannot
+*   be resolved to an RGBA value here (there is no palette entry for it); such a
+*   layer is reported with `rgba = [0, 0, 0, 255]` as a neutral fallback. A
+*   renderer should substitute the active foreground color when it sees
+*   `paletteIndex === 0xFFFF`.
+* - This module exposes the *layer + palette model only*. Actually RENDERING or
+*   EMBEDDING color glyphs into a PDF (e.g. as a Type3 font) is OUT OF SCOPE and
+*   left to a consuming renderer.
+*
+* No external dependencies. No Buffer — uses Uint8Array and DataView.
+*/
+/** The CPAL special palette index meaning "use the text foreground color". */
+const FOREGROUND_PALETTE_INDEX = 65535;
+/**
+* Read the sfnt table directory. The directory is at offset 12 as a sequence
+* of 16-byte records: { tag[4], checksum[4], offset[4], length[4] }, all
+* big-endian. Supports sfnt version 0x00010000 (TrueType) and 'OTTO' (CFF);
+* the actual sfnt version value is not needed beyond reaching the directory.
+*
+* @returns A map from 4-char table tag to its offset/length, or `undefined`
+*   if the data is too small to contain a valid directory.
+*/
+function readTableDirectory(data) {
+	if (data.length < 12) return void 0;
+	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	const numTables = view.getUint16(4, false);
+	const requiredLen = 12 + numTables * 16;
+	if (data.length < requiredLen) return void 0;
+	const tables = /* @__PURE__ */ new Map();
+	for (let i = 0; i < numTables; i++) {
+		const off = 12 + i * 16;
+		const tag = String.fromCharCode(data[off], data[off + 1], data[off + 2], data[off + 3]);
+		const offset = view.getUint32(off + 8, false);
+		const length = view.getUint32(off + 12, false);
+		tables.set(tag, {
+			offset,
+			length
+		});
+	}
+	return tables;
+}
+/**
+* Return a `DataView` bounded to a single table, or `undefined` if the table
+* is absent or its declared extent falls outside the font data.
+*/
+function tableView(data, tables, tag) {
+	const rec = tables.get(tag);
+	if (rec === void 0) return void 0;
+	if (rec.offset + rec.length > data.length) return void 0;
+	return new DataView(data.buffer, data.byteOffset + rec.offset, rec.length);
+}
+/**
+* Parse the CPAL table into palettes of RGBA colors.
+*
+* Handles CPAL versions 0 and 1 (the v1 trailing offset arrays are ignored —
+* they only carry optional UI labels and palette-type flags). Color records
+* are read as BGRA bytes and converted to RGBA.
+*
+* @returns The parsed palettes, or `undefined` if the table is malformed.
+*/
+function parseCpal(view) {
+	if (view.byteLength < 12) return void 0;
+	const numPaletteEntries = view.getUint16(2, false);
+	const numPalettes = view.getUint16(4, false);
+	const numColorRecords = view.getUint16(6, false);
+	const colorRecordsArrayOffset = view.getUint32(8, false);
+	const indicesStart = 12;
+	if (indicesStart + numPalettes * 2 > view.byteLength) return void 0;
+	if (colorRecordsArrayOffset + numColorRecords * 4 > view.byteLength) return;
+	const colorRecordIndices = [];
+	for (let i = 0; i < numPalettes; i++) colorRecordIndices.push(view.getUint16(indicesStart + i * 2, false));
+	const palettes = [];
+	for (let p = 0; p < numPalettes; p++) {
+		const firstRecord = colorRecordIndices[p];
+		const colors = [];
+		for (let e = 0; e < numPaletteEntries; e++) {
+			const recIndex = firstRecord + e;
+			if (recIndex >= numColorRecords) break;
+			const recOff = colorRecordsArrayOffset + recIndex * 4;
+			const blue = view.getUint8(recOff + 0);
+			const green = view.getUint8(recOff + 1);
+			const red = view.getUint8(recOff + 2);
+			const alpha = view.getUint8(recOff + 3);
+			colors.push([
+				red,
+				green,
+				blue,
+				alpha
+			]);
+		}
+		palettes.push({ colors });
+	}
+	return palettes;
+}
+/**
+* Read the COLR v0 header. Returns `undefined` if the table is too small or
+* its declared offsets/counts fall outside the table.
+*/
+function readColrV0(view) {
+	if (view.byteLength < 14) return void 0;
+	const numBaseGlyphRecords = view.getUint16(2, false);
+	const baseGlyphRecordsOffset = view.getUint32(4, false);
+	const layerRecordsOffset = view.getUint32(8, false);
+	const numLayerRecords = view.getUint16(12, false);
+	if (baseGlyphRecordsOffset + numBaseGlyphRecords * 6 > view.byteLength || layerRecordsOffset + numLayerRecords * 4 > view.byteLength) return;
+	return {
+		baseGlyphRecordsOffset,
+		numBaseGlyphRecords,
+		layerRecordsOffset,
+		numLayerRecords,
+		view
+	};
+}
+/**
+* Binary-search the base-glyph records (sorted by glyphID, per spec) for the
+* record matching `glyphId`.
+*
+* @returns `{ firstLayerIndex, numLayers }` or `undefined` if not a base glyph.
+*/
+function findBaseGlyph(colr, glyphId) {
+	const { view, baseGlyphRecordsOffset } = colr;
+	let lo = 0;
+	let hi = colr.numBaseGlyphRecords - 1;
+	while (lo <= hi) {
+		const mid = lo + hi >> 1;
+		const recOff = baseGlyphRecordsOffset + mid * 6;
+		const gid = view.getUint16(recOff, false);
+		if (gid === glyphId) return {
+			firstLayerIndex: view.getUint16(recOff + 2, false),
+			numLayers: view.getUint16(recOff + 4, false)
+		};
+		if (gid < glyphId) lo = mid + 1;
+		else hi = mid - 1;
+	}
+}
+/**
+* Parse a font's color capability and CPAL palettes.
+*
+* `hasColor` is true iff the font contains a 'COLR' table. The palettes come
+* from the 'CPAL' table (which is required whenever 'COLR' is present, per the
+* OpenType spec). Color records are returned as RGBA (converted from the on-disk
+* BGRA layout).
+*
+* @param fontData - Raw sfnt font bytes (TrueType 0x00010000 or 'OTTO').
+* @returns Color info; `{ hasColor: false, numPalettes: 0, palettes: [] }` if
+*   the font has no COLR/CPAL tables or cannot be parsed.
+*/
+function parseColorFont(fontData) {
+	const empty = {
+		hasColor: false,
+		numPalettes: 0,
+		palettes: []
+	};
+	const tables = readTableDirectory(fontData);
+	if (tables === void 0) return empty;
+	const hasColor = tables.has("COLR");
+	const cpalView = tableView(fontData, tables, "CPAL");
+	if (cpalView === void 0) return {
+		hasColor,
+		numPalettes: 0,
+		palettes: []
+	};
+	const palettes = parseCpal(cpalView);
+	if (palettes === void 0) return {
+		hasColor,
+		numPalettes: 0,
+		palettes: []
+	};
+	return {
+		hasColor,
+		numPalettes: palettes.length,
+		palettes
+	};
+}
+/**
+* Resolve the COLR v0 layers of a base glyph into colored layers.
+*
+* For each layer of the requested base glyph, the layer's outline glyph id is
+* returned together with its CPAL palette-entry index and the RGBA color that
+* index resolves to in the selected palette.
+*
+* A glyph that is **not** a COLR base glyph (or a font with no COLR/CPAL table)
+* returns `[]` — such a glyph is drawn as a normal monochrome glyph.
+*
+* The special palette index `0xFFFF` ("foreground color") is preserved on the
+* layer's `paletteIndex` but, having no palette entry, resolves to the neutral
+* fallback `[0, 0, 0, 255]`; a renderer should substitute the active text color.
+*
+* @param fontData - Raw sfnt font bytes.
+* @param glyphId - The base glyph id to expand.
+* @param paletteIndex - Which CPAL palette to resolve colors from. Defaults to
+*   palette 0 (the default palette). Out-of-range values fall back to palette 0.
+* @returns The ordered (bottom-first) list of colored layers, or `[]`.
+*/
+function getColorGlyphLayers(fontData, glyphId, paletteIndex = 0) {
+	const tables = readTableDirectory(fontData);
+	if (tables === void 0) return [];
+	const colrView = tableView(fontData, tables, "COLR");
+	if (colrView === void 0) return [];
+	const colr = readColrV0(colrView);
+	if (colr === void 0) return [];
+	const base = findBaseGlyph(colr, glyphId);
+	if (base === void 0) return [];
+	const cpalView = tableView(fontData, tables, "CPAL");
+	const palettes = cpalView !== void 0 ? parseCpal(cpalView) : void 0;
+	const selectedPalette = palettes !== void 0 && palettes.length > 0 ? palettes[paletteIndex] ?? palettes[0] : void 0;
+	const layers = [];
+	const { view, layerRecordsOffset, numLayerRecords } = colr;
+	for (let i = 0; i < base.numLayers; i++) {
+		const layerIndex = base.firstLayerIndex + i;
+		if (layerIndex >= numLayerRecords) break;
+		const recOff = layerRecordsOffset + layerIndex * 4;
+		const layerGid = view.getUint16(recOff, false);
+		const layerPaletteIndex = view.getUint16(recOff + 2, false);
+		let rgba = [
+			0,
+			0,
+			0,
+			255
+		];
+		if (layerPaletteIndex !== FOREGROUND_PALETTE_INDEX && selectedPalette !== void 0 && layerPaletteIndex < selectedPalette.colors.length) {
+			const c = selectedPalette.colors[layerPaletteIndex];
+			rgba = [
+				c[0],
+				c[1],
+				c[2],
+				c[3]
+			];
+		}
+		layers.push({
+			glyphId: layerGid,
+			paletteIndex: layerPaletteIndex,
+			rgba
+		});
+	}
+	return layers;
+}
+//#endregion
 //#region src/render/matrix.ts
 /** The identity transform. */
 function identity() {
@@ -31889,15 +34335,15 @@ async function initWasm(options) {
 	if (wasmInitialized) return;
 	const inits = [];
 	if (options.deflate || options.deflateWasm) inits.push((async () => {
-		const { initDeflateWasm } = await import("./pdfDocument-EcHxUnR6.mjs").then((n) => n.Vt);
+		const { initDeflateWasm } = await import("./pdfDocument-Q0wrwKEZ.mjs").then((n) => n.Wt);
 		await initDeflateWasm(options.deflateWasm);
 	})());
 	if (options.png || options.pngWasm) inits.push((async () => {
-		const { initPngWasm } = await import("./pdfDocument-EcHxUnR6.mjs").then((n) => n.Mt);
+		const { initPngWasm } = await import("./pdfDocument-Q0wrwKEZ.mjs").then((n) => n.Ft);
 		await initPngWasm(options.pngWasm);
 	})());
 	if (options.fonts || options.fontWasm) inits.push((async () => {
-		const { initSubsetWasm } = await import("./pdfDocument-EcHxUnR6.mjs").then((n) => n.It);
+		const { initSubsetWasm } = await import("./pdfDocument-Q0wrwKEZ.mjs").then((n) => n.zt);
 		await initSubsetWasm(options.fontWasm);
 	})());
 	if (options.jpeg || options.jpegWasm) inits.push((async () => {
@@ -31908,6 +34354,6 @@ async function initWasm(options) {
 	wasmInitialized = true;
 }
 //#endregion
-export { buildCertPath as $, PdfPolygonAnnotation as $a, getProfile as $i, metadataPlugin as $n, readCode39 as $r, gtsPdfVtVersion as $t, buildSoftMaskNone as A, MdpPermission as Aa, webpToJpeg as Ai, reconstructParagraphs as An, RichTextFieldReadError as Ar, checkCertificateStatus as At, redactRegions as B, buildTimestampRequest as Ba, optimizeImage as Bi, toSarif as Bn, ellipsisText as Br, AFDate_FormatEx as Bt, tagTableHeaderCell as C, addCounterSignature as Ca, encodeCode128Values as Ci, buildType5Halftone as Cn, ChangeTracker as Co, InvalidColorError as Cr, decodeTileRegion as Ct, buildImageSoftMask as D, buildFieldLockDict as Da, embedTiffDirect as Di, markdownToPdf as Dn, NoSuchFieldError as Dr, downloadCrl as Dt, buildColorKeyMask as E, addFieldLock as Ea, canDirectEmbed as Ei, evaluateFunction as En, MissingOnValueCheckError as Er, TrustStore as Et, attachAssociatedFiles as F, appendIncrementalUpdate as Fa, extractJpegMetadata as Fi, buildLab as Fn, formatDate$1 as Fr, setFieldValue as Ft, extractImages as G, PdfCaretAnnotation as Ga, generatePdfAXmpBytes as Gi, buildPieceInfo as Gn, applyPreset as Gr, decodeWoff as Gt, compareImages as H, requestTimestamp as Ha, applyRedaction as Hi, PDF2_NAMESPACE as Hn, shrinkFontSize as Hr, parseAcrobatDate as Ht, registerEmbeddedFile as I, findExistingSignatures as Ia, injectJpegMetadata as Ii, labToRgb as In, replaceTemplateVariables as Ir, addVisibilityAction as It, renderPageToCanvas as J, PdfInkAnnotation as Ja, buildAfArray as Ji, buildDPartRoot as Jn, minimalPreset as Jr, readWoffHeader as Jt, generateThumbnail as K, PdfPopupAnnotation as Ka, countOccurrences as Ki, buildRequirement as Kn, applyTablePreset as Kr, isWoff as Kt, RenderCache as L, parseExistingTrailer as La, analyzeJpegMarkers as Li, DEFAULT_SARIF_TOOL_NAME as Ln, toAlpha as Lr, setFieldVisibility as Lt, buildUnencryptedWrapper as M, getCertificationLevel as Ma, convertTiffCmykToRgb as Mi, buildDocTimeStampDict as Mn, UnexpectedFieldTypeError as Mr, createSandbox as Mt, attachOutputIntents as N, setCertificationLevel as Na, embedTiffCmyk as Ni, buildCalGray as Nn, applyHeaderFooter as Nr, getFieldValue as Nt, buildStencilMask as O, getFieldLocks as Oa, encodePngFromPixels as Oi, buildCollection as On, PluginError as Or, extractCrlUrls as Ot, buildPageOutputIntent as P, validateSignatureChain as Pa, isCmykTiff as Pi, buildCalRGB as Pn, applyHeaderFooterToPage as Pr, resolveFieldReference as Pt, interpretPage as Q, PdfPolyLineAnnotation as Qa, validateXmpMetadata as Qi, accessibilityPlugin as Qn, readCode128 as Qr, buildVtDpm as Qt, computeTileGrid as R, saveIncrementalWithSignaturePreservation as Ra, downscaleImage as Ri, SARIF_SCHEMA_URI as Rn, toRoman as Rr, validateFieldValue as Rt, tagTableDataCell as S, hasLtvData as Sa, encodeCode128 as Si, buildType1Halftone as Sn, buildSeparationColorSpace as So, ForeignPageError as Sr, decodeTile as St, buildBlackPointCompensationExtGState as T, diffSignedContent as Ta, PdfWorker as Ti, nameHalftone as Tn, saveIncremental as To, InvalidPageSizeError as Tr, verifySignatureDetailed as Tt, comparePages as U, searchTextItems as Ua, enforcePdfAFull as Ui, buildNamespace as Un, truncateText as Ur, AFNumber_Format as Ut, applyOcr as V, parseTimestampResponse as Va, recompressImage as Vi, MATHML_NAMESPACE as Vn, estimateTextWidth as Vr, formatDate as Vt, extractFonts as W, PdfFileAttachmentAnnotation as Wa, generatePdfAXmp as Wi, buildNamespacesArray as Wn, wrapText$2 as Wr, formatNumber$1 as Wt, renderPageToImage as X, PdfCircleAnnotation as Xa, extractXmpMetadata as Xi, tableToCsv as Xn, stripedPreset as Xr, createWorkerPool as Xt, rasterize as Y, PdfStampAnnotation as Ya, createAssociatedFile as Yi, extractTables as Yn, professionalPreset as Yr, signDeferred as Yt, interpretContentStream as Z, PdfLineAnnotation as Za, parseXmpMetadata as Zi, tableToJson as Zn, readBarcode as Zr, buildPdfVtDParts as Zt, tagLink as _, computeObjectHash as _a, itfToOperators as _i, buildPdfX6OutputIntent as _n, buildXmpMetadata as _o, EncryptedPdfError as _r, normalizeComponentDepth as _t, assembleFacturX as a, getToUnicodeCmap as aa, pdf417ToOperators as ai, generateOrderX as an, PdfFreeTextAnnotation as ao, batchFlatten as ar, validateKeyUsage as at, tagParagraph as b, buildDssDictionary as ba, encodeCode39 as bi, buildSampledTransferFunction as bn, PDFOperator as bo, FieldExistsAsNonTerminalError as br, upscale8To16 as bt, buildWtpdfIdentificationXmp as c, generateSrgbIccProfile as ca, calculateUpcCheckDigit as ci, pdfA4Rules as cn, generateHighlightAppearance as co, addBookmark as cr, findHyphenationPoints as ct, autoTagPage as d, enforcePdfA as da, calculateEanCheckDigit as di, didYouMean as dn, generateSquareAppearance as do, removeBookmark as dr, layoutTextFlow as dt, getSupportedLevels as ea, readEan13 as ei, h as en, PdfSquareAnnotation as eo, timestampPlugin as er, extractEmbeddedRevocationData as et, buildPdfUa2Xmp as f, validatePdfA as fa, ean13ToOperators as fi, levenshtein as fn, generateSquigglyAppearance as fo, flattenField as fr, buildPdfXOutputIntent as ft, tagHeading as g, linearizePdf as ga, encodeItf as gi, buildGtsPdfxVersion as gn, PdfTextAnnotation as go, CombedTextLayoutError as gr, getComponentDepths as gt, tagFigure as h, isLinearized as ha, encodeEan8 as hi, buildBoxDict as hn, PdfLinkAnnotation as ho, BatchProcessingError as hr, downscale16To8 as ht, validateEn16931 as i, generateZapfDingbatsToUnicodeCmap as ia, encodePdf417 as ii, splitByScript as in, PdfUnderlineAnnotation as io, validatePdfUa as ir, validateExtendedKeyUsage as it, buildEncryptedPayload as j, buildDocMdpReference as ja, webpToPng as ji, DEFAULT_DOC_TIMESTAMP_CONTENTS_SIZE as jn, StreamingParseError as jr, extractOcspUrl as jt, buildSoftMaskGroupExtGState as k, detectModifications as ka, recompressWebP as ki, reconstructLines as kn, RemovePageFromEmptyDocumentError as kr, isCertificateRevoked as kt, convertPdfAConformanceXmp as l, detectTransparency as la, encodeUpcA as li, buildFunctionShading as ln, generateInkAppearance as lo, getBookmarks as lr, layoutColumns as lt, LIST_NUMBERING_KEY as m, getLinearizationInfo as ma, encodeEan13 as mi, generateCiiXml as mn, generateUnderlineAppearance as mo, flattenForm as mr, validatePdfX as mt, detectFacturXProfile as n, generateSymbolToUnicodeCmap as na, calculateBarcodeDimensions as ni, createRangeFetcher as nn, PdfSquigglyAnnotation as no, PdfDocumentBuilder as nr, EKU_OIDS as nt, buildFacturXXmp as o, buildOutputIntent as oa, dataMatrixToOperators as oi, generateXRechnungCii as on, generateCircleAppearance as oo, batchMerge as or, buildCertificateChain as ot, validatePdfUa2 as p, delinearizePdf as pa, ean8ToOperators as pi, renderCodeFrame as pn, generateStrikeOutAppearance as po, flattenFields as pr, enforcePdfX as pt, renderDisplayListToCanvas as q, PdfRedactAnnotation as qa, stripProhibitedFeatures as qi, buildRequirements as qn, borderedPreset as qr, isWoff2 as qt, parseCiiXml as r, generateWinAnsiToUnicodeCmap as ra, renderStyledBarcode as ri, resolveFallback as rn, PdfStrikeOutAnnotation as ro, enforcePdfUa as rr, validateCertificatePolicy as rt, buildPdfRIdentificationXmp as s, SRGB_ICC_PROFILE as sa, encodeDataMatrix as si, buildPdfA4Xmp as sn, generateFreeTextAppearance as so, processBatch as sr, validateCertificateChain as st, initWasm as t, isValidLevel as ta, readEan8 as ti, renderToPdf as tn, PdfHighlightAnnotation as to, StreamingPdfParser as tr, verifyOfflineRevocation as tt, preflightPdfA as u, flattenTransparency as ua, upcAToOperators as ui, sampleShadingColor as un, generateLineAppearance as uo, removeAllBookmarks as ur, layoutParagraph as ut, tagList as v, findChangedObjects as va, code39ToOperators as vi, validateBoxGeometry as vn, createXmpStream as vo, ExceededMaxLengthError as vr, offsetSignedToUnsigned as vt, tagTableRow as w, getCounterSignatures as wa, valuesToModules as wi, identityTransferFunction as wn, saveDocumentIncremental as wo, InvalidFieldNamePartError as wr, parseTileInfo as wt, tagTable as x, embedLtvData as xa, code128ToOperators as xi, buildThresholdHalftone as xn, buildDeviceNColorSpace as xo, FontNotEmbeddedError as xr, assembleTiles as xt, tagListItem as y, optimizeIncrementalSave as ya, computeCode39CheckDigit as yi, STANDARD_SPOT_FUNCTIONS as yn, parseXmpMetadata$1 as yo, FieldAlreadyExistsError as yr, summarizeBitDepth as yt, renderPageTile as z, validateByteRangeIntegrity as za, estimateJpegQuality as zi, toJsonReport as zn, applyOverflow as zr, AFSpecial_Format as zt };
+export { getColorGlyphLayers as $, requestTimestamp as $a, applyRedaction as $i, PDF2_NAMESPACE as $n, shrinkFontSize as $r, parseAcrobatDate as $t, buildSoftMaskNone as A, optimizeIncrementalSave as Aa, computeCode39CheckDigit as Ai, STANDARD_SPOT_FUNCTIONS as An, parseXmpMetadata$1 as Ao, FieldAlreadyExistsError as Ar, summarizeBitDepth as At, redactRegions as B, detectModifications as Ba, recompressWebP as Bi, reconstructLines as Bn, RemovePageFromEmptyDocumentError as Br, isCertificateRevoked as Bt, tagTableHeaderCell as C, validatePdfA as Ca, ean13ToOperators as Ci, levenshtein as Cn, generateSquigglyAppearance as Co, flattenField as Cr, buildPdfXOutputIntent as Ct, buildImageSoftMask as D, linearizePdf as Da, encodeItf as Di, buildGtsPdfxVersion as Dn, PdfTextAnnotation as Do, CombedTextLayoutError as Dr, getComponentDepths as Dt, buildColorKeyMask as E, isLinearized as Ea, encodeEan8 as Ei, buildBoxDict as En, PdfLinkAnnotation as Eo, BatchProcessingError as Er, downscale16To8 as Et, attachAssociatedFiles as F, getCounterSignatures as Fa, valuesToModules as Fi, identityTransferFunction as Fn, saveDocumentIncremental as Fo, InvalidFieldNamePartError as Fr, parseTileInfo as Ft, extractImages as G, validateSignatureChain as Ga, isCmykTiff as Gi, buildCalRGB as Gn, applyHeaderFooterToPage as Gr, resolveFieldReference as Gt, compareImages as H, buildDocMdpReference as Ha, webpToPng as Hi, DEFAULT_DOC_TIMESTAMP_CONTENTS_SIZE as Hn, StreamingParseError as Hr, extractOcspUrl as Ht, registerEmbeddedFile as I, diffSignedContent as Ia, PdfWorker as Ii, nameHalftone as In, saveIncremental as Io, InvalidPageSizeError as Ir, verifySignatureDetailed as It, renderPageToCanvas as J, parseExistingTrailer as Ja, analyzeJpegMarkers as Ji, DEFAULT_SARIF_TOOL_NAME as Jn, toAlpha as Jr, setFieldVisibility as Jt, generateThumbnail as K, appendIncrementalUpdate as Ka, extractJpegMetadata as Ki, buildLab as Kn, formatDate$1 as Kr, setFieldValue as Kt, RenderCache as L, addFieldLock as La, canDirectEmbed as Li, evaluateFunction as Ln, MissingOnValueCheckError as Lr, TrustStore as Lt, buildUnencryptedWrapper as M, embedLtvData as Ma, code128ToOperators as Mi, buildThresholdHalftone as Mn, buildDeviceNColorSpace as Mo, FontNotEmbeddedError as Mr, assembleTiles as Mt, attachOutputIntents as N, hasLtvData as Na, encodeCode128 as Ni, buildType1Halftone as Nn, buildSeparationColorSpace as No, ForeignPageError as Nr, decodeTile as Nt, buildStencilMask as O, computeObjectHash as Oa, itfToOperators as Oi, buildPdfX6OutputIntent as On, buildXmpMetadata as Oo, EncryptedPdfError as Or, normalizeComponentDepth as Ot, buildPageOutputIntent as P, addCounterSignature as Pa, encodeCode128Values as Pi, buildType5Halftone as Pn, ChangeTracker as Po, InvalidColorError as Pr, decodeTileRegion as Pt, interpretPage as Q, parseTimestampResponse as Qa, recompressImage as Qi, MATHML_NAMESPACE as Qn, estimateTextWidth as Qr, formatDate as Qt, computeTileGrid as R, buildFieldLockDict as Ra, embedTiffDirect as Ri, markdownToPdf as Rn, NoSuchFieldError as Rr, downloadCrl as Rt, tagTableDataCell as S, enforcePdfA as Sa, calculateEanCheckDigit as Si, didYouMean as Sn, generateSquareAppearance as So, removeBookmark as Sr, layoutTextFlow as St, buildBlackPointCompensationExtGState as T, getLinearizationInfo as Ta, encodeEan13 as Ti, generateCiiXml as Tn, generateUnderlineAppearance as To, flattenForm as Tr, validatePdfX as Tt, comparePages as U, getCertificationLevel as Ua, convertTiffCmykToRgb as Ui, buildDocTimeStampDict as Un, UnexpectedFieldTypeError as Ur, createSandbox as Ut, applyOcr as V, MdpPermission as Va, webpToJpeg as Vi, reconstructParagraphs as Vn, RichTextFieldReadError as Vr, checkCertificateStatus as Vt, extractFonts as W, setCertificationLevel as Wa, embedTiffCmyk as Wi, buildCalGray as Wn, applyHeaderFooter as Wr, getFieldValue as Wt, renderPageToImage as X, validateByteRangeIntegrity as Xa, estimateJpegQuality as Xi, toJsonReport as Xn, applyOverflow as Xr, AFSpecial_Format as Xt, rasterize as Y, saveIncrementalWithSignaturePreservation as Ya, downscaleImage as Yi, SARIF_SCHEMA_URI as Yn, toRoman as Yr, validateFieldValue as Yt, interpretContentStream as Z, buildTimestampRequest as Za, optimizeImage as Zi, toSarif as Zn, ellipsisText as Zr, AFDate_FormatEx as Zt, tagLink as _, buildOutputIntent as _a, dataMatrixToOperators as _i, generateXRechnungCii as _n, generateCircleAppearance as _o, batchMerge as _r, buildCertificateChain as _t, assembleFacturX as a, buildAfArray as aa, minimalPreset as ai, readWoffHeader as an, PdfInkAnnotation as ao, buildDPartRoot as ar, resolveBidi as at, tagParagraph as b, detectTransparency as ba, encodeUpcA as bi, buildFunctionShading as bn, generateInkAppearance as bo, getBookmarks as br, layoutColumns as bt, buildWtpdfIdentificationXmp as c, parseXmpMetadata as ca, readBarcode as ci, buildPdfVtDParts as cn, PdfLineAnnotation as co, tableToJson as cr, sanitizePdf as ct, autoTagPage as d, getSupportedLevels as da, readEan13 as di, h as dn, PdfSquareAnnotation as do, timestampPlugin as dr, extractEmbeddedRevocationData as dt, enforcePdfAFull as ea, truncateText as ei, AFNumber_Format as en, searchTextItems as eo, buildNamespace as er, parseColorFont as et, buildPdfUa2Xmp as f, isValidLevel as fa, readEan8 as fi, renderToPdf as fn, PdfHighlightAnnotation as fo, StreamingPdfParser as fr, verifyOfflineRevocation as ft, tagHeading as g, getToUnicodeCmap as ga, pdf417ToOperators as gi, generateOrderX as gn, PdfFreeTextAnnotation as go, batchFlatten as gr, validateKeyUsage as gt, tagFigure as h, generateZapfDingbatsToUnicodeCmap as ha, encodePdf417 as hi, splitByScript as hn, PdfUnderlineAnnotation as ho, validatePdfUa as hr, validateExtendedKeyUsage as ht, validateEn16931 as i, stripProhibitedFeatures as ia, borderedPreset as ii, isWoff2 as in, PdfRedactAnnotation as io, buildRequirements as ir, reorderVisual as it, buildEncryptedPayload as j, buildDssDictionary as ja, encodeCode39 as ji, buildSampledTransferFunction as jn, PDFOperator as jo, FieldExistsAsNonTerminalError as jr, upscale8To16 as jt, buildSoftMaskGroupExtGState as k, findChangedObjects as ka, code39ToOperators as ki, validateBoxGeometry as kn, createXmpStream as ko, ExceededMaxLengthError as kr, offsetSignedToUnsigned as kt, convertPdfAConformanceXmp as l, validateXmpMetadata as la, readCode128 as li, buildVtDpm as ln, PdfPolyLineAnnotation as lo, accessibilityPlugin as lr, scanPdfThreats as lt, LIST_NUMBERING_KEY as m, generateWinAnsiToUnicodeCmap as ma, renderStyledBarcode as mi, resolveFallback as mn, PdfStrikeOutAnnotation as mo, enforcePdfUa as mr, validateCertificatePolicy as mt, detectFacturXProfile as n, generatePdfAXmpBytes as na, applyPreset as ni, decodeWoff as nn, PdfCaretAnnotation as no, buildPieceInfo as nr, parseVariableFont as nt, buildFacturXXmp as o, createAssociatedFile as oa, professionalPreset as oi, signDeferred as on, PdfStampAnnotation as oo, extractTables as or, inspectEncryption as ot, validatePdfUa2 as p, generateSymbolToUnicodeCmap as pa, calculateBarcodeDimensions as pi, createRangeFetcher as pn, PdfSquigglyAnnotation as po, PdfDocumentBuilder as pr, EKU_OIDS as pt, renderDisplayListToCanvas as q, findExistingSignatures as qa, injectJpegMetadata as qi, labToRgb as qn, replaceTemplateVariables as qr, addVisibilityAction as qt, parseCiiXml as r, countOccurrences as ra, applyTablePreset as ri, isWoff as rn, PdfPopupAnnotation as ro, buildRequirement as rr, resolveInstanceCoordinates as rt, buildPdfRIdentificationXmp as s, extractXmpMetadata as sa, stripedPreset as si, createWorkerPool as sn, PdfCircleAnnotation as so, tableToCsv as sr, verifyRedactions as st, initWasm as t, generatePdfAXmp as ta, wrapText$2 as ti, formatNumber$1 as tn, PdfFileAttachmentAnnotation as to, buildNamespacesArray as tr, normalizeAxisCoordinate as tt, preflightPdfA as u, getProfile as ua, readCode39 as ui, gtsPdfVtVersion as un, PdfPolygonAnnotation as uo, metadataPlugin as ur, buildCertPath as ut, tagList as v, SRGB_ICC_PROFILE as va, encodeDataMatrix as vi, buildPdfA4Xmp as vn, generateFreeTextAppearance as vo, processBatch as vr, validateCertificateChain as vt, tagTableRow as w, delinearizePdf as wa, ean8ToOperators as wi, renderCodeFrame as wn, generateStrikeOutAppearance as wo, flattenFields as wr, enforcePdfX as wt, tagTable as x, flattenTransparency as xa, upcAToOperators as xi, sampleShadingColor as xn, generateLineAppearance as xo, removeAllBookmarks as xr, layoutParagraph as xt, tagListItem as y, generateSrgbIccProfile as ya, calculateUpcCheckDigit as yi, pdfA4Rules as yn, generateHighlightAppearance as yo, addBookmark as yr, findHyphenationPoints as yt, renderPageTile as z, getFieldLocks as za, encodePngFromPixels as zi, buildCollection as zn, PluginError as zr, extractCrlUrls as zt };
 
-//# sourceMappingURL=src-CiUkSS81.mjs.map
+//# sourceMappingURL=src-4wfgzZvz.mjs.map