modern-pdf-lib 0.34.0 → 0.36.0

package/dist/{src-PxZwqIKQ.cjs → src-MIBq9xGq.cjs}

@@ -1,4 +1,4 @@
-const require_pdfDocument = require("./pdfDocument-Dyj4AmT1.cjs");
+const require_pdfDocument = require("./pdfDocument-D5qz7duP.cjs");
 const require_pdfObjects = require("./pdfObjects-BcPlSI0a.cjs");
 const require_streamDecode = require("./streamDecode-kQ-REV7v.cjs");
 const require_pdfForm = require("./pdfForm-BVS_do95.cjs");
@@ -277,7 +277,7 @@ function compressStream(stream, level) {
 * @returns              The incremental save result.
 */
 async function saveDocumentIncremental(originalBytes, doc, options) {
-	const { buildDocumentStructure } = await Promise.resolve().then(() => require("./pdfDocument-Dyj4AmT1.cjs")).then((n) => n.pdfCatalog_exports);
+	const { buildDocumentStructure } = await Promise.resolve().then(() => require("./pdfDocument-D5qz7duP.cjs")).then((n) => n.pdfCatalog_exports);
 	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 require_pdfDocument.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 require_pdfObjects.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 require_pdfObjects.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 require_pdfObjects.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 require_pdfObjects.PdfDict) {
+		const type = object.get("/Type");
+		if (type instanceof require_pdfObjects.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 require_pdfObjects.PdfDict) {
+		const type = object.get("/Type");
+		if (type instanceof require_pdfObjects.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 require_pdfObjects.PdfArray && names.length >= 2) return true;
+	const kids = resolve$2(dict.get("/Kids"), registry);
+	if (kids instanceof require_pdfObjects.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 require_pdfObjects.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 require_pdfObjects.PdfDict) || catalogDicts.has(object)) continue;
+		const type = object.get("/Type");
+		if (type instanceof require_pdfObjects.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 require_pdfDocument.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 require_pdfObjects.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 require_pdfObjects.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 = require_pdfDocument.buildInfoDict({}, registry);
+	else infoRef = require_pdfDocument.buildInfoDict(preservedMeta, registry);
+	const structure = {
+		catalogRef: root.ref,
+		infoRef,
+		pagesRef: pagesRef instanceof require_pdfObjects.PdfRef ? pagesRef : root.ref
+	};
+	registry.filterReachable([structure.catalogRef, structure.infoRef]);
+	return {
+		pdf: await require_pdfDocument.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 require_pdfDocument.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 = require_compressionAnalysis.extractTextWithPositions(require_compressionAnalysis.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 require_pdfDocument.PdfObjectParser(new require_pdfDocument.PdfLexer(pdf), new require_pdfObjects.PdfObjectRegistry());
+		const { entries, trailer } = await new require_pdfDocument.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 require_pdfDocument.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 Promise.resolve().then(() => require("./pdfDocument-Dyj4AmT1.cjs")).then((n) => n.libdeflateWasm_exports);
+		const { initDeflateWasm } = await Promise.resolve().then(() => require("./pdfDocument-D5qz7duP.cjs")).then((n) => n.libdeflateWasm_exports);
 		await initDeflateWasm(options.deflateWasm);
 	})());
 	if (options.png || options.pngWasm) inits.push((async () => {
-		const { initPngWasm } = await Promise.resolve().then(() => require("./pdfDocument-Dyj4AmT1.cjs")).then((n) => n.pngEmbed_exports);
+		const { initPngWasm } = await Promise.resolve().then(() => require("./pdfDocument-D5qz7duP.cjs")).then((n) => n.pngEmbed_exports);
 		await initPngWasm(options.pngWasm);
 	})());
 	if (options.fonts || options.fontWasm) inits.push((async () => {
-		const { initSubsetWasm } = await Promise.resolve().then(() => require("./pdfDocument-Dyj4AmT1.cjs")).then((n) => n.fontSubset_exports);
+		const { initSubsetWasm } = await Promise.resolve().then(() => require("./pdfDocument-D5qz7duP.cjs")).then((n) => n.fontSubset_exports);
 		await initSubsetWasm(options.fontWasm);
 	})());
 	if (options.jpeg || options.jpegWasm) inits.push((async () => {
@@ -33228,6 +35674,12 @@ Object.defineProperty(exports, "getCertificationLevel", {
 		return getCertificationLevel;
 	}
 });
+Object.defineProperty(exports, "getColorGlyphLayers", {
+	enumerable: true,
+	get: function() {
+		return getColorGlyphLayers;
+	}
+});
 Object.defineProperty(exports, "getComponentDepths", {
 	enumerable: true,
 	get: function() {
@@ -33312,6 +35764,12 @@ Object.defineProperty(exports, "injectJpegMetadata", {
 		return injectJpegMetadata;
 	}
 });
+Object.defineProperty(exports, "inspectEncryption", {
+	enumerable: true,
+	get: function() {
+		return inspectEncryption;
+	}
+});
 Object.defineProperty(exports, "interpretContentStream", {
 	enumerable: true,
 	get: function() {
@@ -33426,6 +35884,12 @@ Object.defineProperty(exports, "nameHalftone", {
 		return nameHalftone;
 	}
 });
+Object.defineProperty(exports, "normalizeAxisCoordinate", {
+	enumerable: true,
+	get: function() {
+		return normalizeAxisCoordinate;
+	}
+});
 Object.defineProperty(exports, "normalizeComponentDepth", {
 	enumerable: true,
 	get: function() {
@@ -33462,6 +35926,12 @@ Object.defineProperty(exports, "parseCiiXml", {
 		return parseCiiXml;
 	}
 });
+Object.defineProperty(exports, "parseColorFont", {
+	enumerable: true,
+	get: function() {
+		return parseColorFont;
+	}
+});
 Object.defineProperty(exports, "parseExistingTrailer", {
 	enumerable: true,
 	get: function() {
@@ -33480,6 +35950,12 @@ Object.defineProperty(exports, "parseTimestampResponse", {
 		return parseTimestampResponse;
 	}
 });
+Object.defineProperty(exports, "parseVariableFont", {
+	enumerable: true,
+	get: function() {
+		return parseVariableFont;
+	}
+});
 Object.defineProperty(exports, "parseXmpMetadata", {
 	enumerable: true,
 	get: function() {
@@ -33654,6 +36130,12 @@ Object.defineProperty(exports, "renderToPdf", {
 		return renderToPdf;
 	}
 });
+Object.defineProperty(exports, "reorderVisual", {
+	enumerable: true,
+	get: function() {
+		return reorderVisual;
+	}
+});
 Object.defineProperty(exports, "replaceTemplateVariables", {
 	enumerable: true,
 	get: function() {
@@ -33666,6 +36148,12 @@ Object.defineProperty(exports, "requestTimestamp", {
 		return requestTimestamp;
 	}
 });
+Object.defineProperty(exports, "resolveBidi", {
+	enumerable: true,
+	get: function() {
+		return resolveBidi;
+	}
+});
 Object.defineProperty(exports, "resolveFallback", {
 	enumerable: true,
 	get: function() {
@@ -33678,12 +36166,24 @@ Object.defineProperty(exports, "resolveFieldReference", {
 		return resolveFieldReference;
 	}
 });
+Object.defineProperty(exports, "resolveInstanceCoordinates", {
+	enumerable: true,
+	get: function() {
+		return resolveInstanceCoordinates;
+	}
+});
 Object.defineProperty(exports, "sampleShadingColor", {
 	enumerable: true,
 	get: function() {
 		return sampleShadingColor;
 	}
 });
+Object.defineProperty(exports, "sanitizePdf", {
+	enumerable: true,
+	get: function() {
+		return sanitizePdf;
+	}
+});
 Object.defineProperty(exports, "saveDocumentIncremental", {
 	enumerable: true,
 	get: function() {
@@ -33702,6 +36202,12 @@ Object.defineProperty(exports, "saveIncrementalWithSignaturePreservation", {
 		return saveIncrementalWithSignaturePreservation;
 	}
 });
+Object.defineProperty(exports, "scanPdfThreats", {
+	enumerable: true,
+	get: function() {
+		return scanPdfThreats;
+	}
+});
 Object.defineProperty(exports, "searchTextItems", {
 	enumerable: true,
 	get: function() {
@@ -33978,6 +36484,12 @@ Object.defineProperty(exports, "verifyOfflineRevocation", {
 		return verifyOfflineRevocation;
 	}
 });
+Object.defineProperty(exports, "verifyRedactions", {
+	enumerable: true,
+	get: function() {
+		return verifyRedactions;
+	}
+});
 Object.defineProperty(exports, "verifySignatureDetailed", {
 	enumerable: true,
 	get: function() {
@@ -34003,4 +36515,4 @@ Object.defineProperty(exports, "wrapText", {
 	}
 });
 
-//# sourceMappingURL=src-PxZwqIKQ.cjs.map
+//# sourceMappingURL=src-MIBq9xGq.cjs.map