modern-pdf-lib 0.29.0 → 0.31.0

package/dist/{src-Ci9ZjqhP.mjs → src-B7SQNDvy.mjs}

@@ -1,4 +1,4 @@
-import { A as encodeUTCTime, Br as rectangle, Bt as PageSizes, C as encodeInteger, E as encodeOctetString, F as parseDerTlv, Gr as setLineWidth, H as mergePdfs, I as toBuffer, Jr as beginText, Kn as applyFillColor, L as computeSignatureHash, M as extractIssuerAndSerial, N as extractSubjectPublicKeyInfo, O as encodeSequence, P as getSubtle, Pr as fill, Rn as restoreState, Rr as lineTo, S as encodeContextTag, Sn as formatPdfDate, T as encodeOID, Vn as saveState, Vr as setDashPattern, Xr as moveText, Yn as cmykToRgb, Yr as endText, at as sha256, b as detectKeyAlgorithm, ei as setFont, gn as buildAnnotationDict, gt as PdfParseError, k as encodeSet, mn as PdfAnnotation, n as StandardFonts, oi as setWordSpacing, qn as applyStrokeColor, qr as stroke, r as createPdf, s as setPageLabels, si as showText$1, t as PdfDocument, x as detectNamedCurve, y as decodeOidBytes, z as findSignatures, zr as moveTo } from "./pdfDocument-B6czyaVI.mjs";
+import { A as encodeUTCTime, Br as rectangle, Bt as PageSizes, C as encodeInteger, E as encodeOctetString, F as parseDerTlv, Gr as setLineWidth, H as mergePdfs, I as toBuffer, Jr as beginText, Kn as applyFillColor, L as computeSignatureHash, M as extractIssuerAndSerial, N as extractSubjectPublicKeyInfo, O as encodeSequence, P as getSubtle, Pr as fill, Rn as restoreState, Rr as lineTo, S as encodeContextTag, Sn as formatPdfDate, T as encodeOID, Vn as saveState, Vr as setDashPattern, Xr as moveText, Yn as cmykToRgb, Yr as endText, at as sha256, b as detectKeyAlgorithm, ei as setFont, gn as buildAnnotationDict, gt as PdfParseError, k as encodeSet, mn as PdfAnnotation, n as StandardFonts, oi as setWordSpacing, qn as applyStrokeColor, qr as stroke, r as createPdf, s as setPageLabels, si as showText$1, t as PdfDocument, x as detectNamedCurve, y as decodeOidBytes, z as findSignatures, zr as moveTo } from "./pdfDocument-Cgkkk8F8.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 { n as decodeStreamData, r as getStreamFilters } from "./streamDecode-DCpgTocN.mjs";
 import { g as FieldFlags, v as numVal } from "./pdfForm-CfLnlsj-.mjs";
@@ -277,7 +277,7 @@ function compressStream(stream, level) {
 * @returns              The incremental save result.
 */
 async function saveDocumentIncremental(originalBytes, doc, options) {
-	const { buildDocumentStructure } = await import("./pdfDocument-B6czyaVI.mjs").then((n) => n.Cn);
+	const { buildDocumentStructure } = await import("./pdfDocument-Cgkkk8F8.mjs").then((n) => n.Cn);
 	const registry = doc.getRegistry();
 	const structure = buildDocumentStructure(doc.getInternalPages().map((p) => p.finalize()), {
 		producer: doc.getProducer(),
@@ -17060,7 +17060,7 @@ const SECTION_TYPES = /* @__PURE__ */ new Set([
 	"BlockQuote"
 ]);
 /** Illustration types that require alt text per PDF/UA. */
-const ILLUSTRATION_TYPES = /* @__PURE__ */ new Set([
+const ILLUSTRATION_TYPES$1 = /* @__PURE__ */ new Set([
 	"Figure",
 	"Formula",
 	"Form"
@@ -17403,7 +17403,7 @@ function findPreviousHeadingInSection(current, sectionHeadings) {
 */
 function checkAltText(elements, errors) {
 	for (const elem of elements) {
-		if (!ILLUSTRATION_TYPES.has(elem.type)) continue;
+		if (!ILLUSTRATION_TYPES$1.has(elem.type)) continue;
 		if (elem.options.artifact) continue;
 		if (elem.options.altText === void 0 && elem.options.actualText === void 0) errors.push({
 			code: "UA-STRUCT-005",
@@ -29946,6 +29946,1001 @@ var RenderCache = class {
 	}
 };
 //#endregion
+//#region src/compliance/afAttach.ts
+/**
+* @module compliance/afAttach
+*
+* Attach embedded / associated files to any PDF object.
+*
+* The Associated Files mechanism (`/AF`) lets a PDF declare that one or more
+* embedded files are *associated* with a given object.  ISO 32000-2 allows the
+* `/AF` key on the document catalog (§7.11.4) as well as on individual objects
+* — page dictionaries, annotation dictionaries, Form/Image XObject stream
+* dictionaries, and structure elements (§14.13).  Because every one of those
+* targets is a plain {@link PdfDict}, the same helper attaches `/AF` uniformly.
+*
+* In addition, a *document-level* associated file must also be reachable
+* through the catalog's embedded-files name tree
+* (`/Names` → `/EmbeddedFiles` → `/Names`).  {@link createAssociatedFile} (in
+* `associatedFiles.ts`) intentionally leaves that wiring to the caller;
+* {@link registerEmbeddedFile} completes it.
+*
+* These are pure builders: they mutate the supplied dictionaries in place and
+* return nothing.  Object numbers / serialization remain the writer's concern.
+*
+* Reference: ISO 32000-2:2020, §7.11.4 (embedded file streams) and §14.13
+* (associated files).
+*/
+/**
+* Attach one or more associated files to any PDF object via its `/AF` key.
+*
+* Works uniformly for the document catalog, a page dictionary, an annotation
+* dictionary, a Form/Image XObject stream's dictionary, or a structure-element
+* dictionary — all of which are plain {@link PdfDict} instances.
+*
+* If `target` has no `/AF` yet, a fresh array (built with
+* {@link buildAfArray}) is set.  If `/AF` is already a {@link PdfArray}, the
+* new refs are appended to it, preserving the existing entries and order.  Any
+* other (malformed) `/AF` value is replaced with a fresh array.
+*
+* @param target        The object dictionary to attach the files to.
+* @param fileSpecRefs  Indirect references to file-specification dictionaries.
+*/
+function attachAssociatedFiles(target, fileSpecRefs) {
+	const existing = target.get("/AF");
+	if (existing instanceof PdfArray) {
+		for (const ref of fileSpecRefs) existing.push(ref);
+		return;
+	}
+	target.set("/AF", buildAfArray([...fileSpecRefs]));
+}
+/**
+* Locate the `/EmbeddedFiles` name-tree `/Names` array on the catalog,
+* creating the intermediate `/Names` and `/EmbeddedFiles` dictionaries (and
+* the leaf `/Names` array) if they do not yet exist.  Existing dictionaries
+* are reused in place rather than replaced.
+*/
+function ensureEmbeddedFilesNames(catalog) {
+	const namesEntry = catalog.get("/Names");
+	const namesDict = namesEntry instanceof PdfDict ? namesEntry : new PdfDict();
+	if (namesDict !== namesEntry) catalog.set("/Names", namesDict);
+	const efEntry = namesDict.get("/EmbeddedFiles");
+	const efDict = efEntry instanceof PdfDict ? efEntry : new PdfDict();
+	if (efDict !== efEntry) namesDict.set("/EmbeddedFiles", efDict);
+	const leafEntry = efDict.get("/Names");
+	const leaf = leafEntry instanceof PdfArray ? leafEntry : new PdfArray();
+	if (leaf !== leafEntry) efDict.set("/Names", leaf);
+	return leaf;
+}
+/**
+* Insert a `[name, fileSpecRef]` pair into an embedded-files name-tree `/Names`
+* array, keeping the array sorted by name.  The array is a flat sequence of
+* alternating key/value entries: `[ name0, ref0, name1, ref1, … ]`.
+*/
+function insertNamePairSorted(leaf, name, fileSpecRef) {
+	const items = leaf.items;
+	let insertAt = items.length;
+	for (let i = 0; i < items.length; i += 2) {
+		const entry = items[i];
+		if ((entry instanceof PdfString ? entry.value : "") > name) {
+			insertAt = i;
+			break;
+		}
+	}
+	items.splice(insertAt, 0, PdfString.literal(name), fileSpecRef);
+}
+/**
+* Complete {@link createAssociatedFile}'s "caller responsibility" by wiring a
+* file-specification reference into the document catalog at the *document
+* level*.
+*
+* Two things happen:
+*  1. The pair `[PdfString.literal(name), fileSpecRef]` is added to the
+*     catalog's `/Names` → `/EmbeddedFiles` → `/Names` array, keeping the
+*     array's name/value pairs sorted by name (as required for a name tree).
+*     The intermediate dictionaries and the leaf array are created on demand
+*     and reused if already present.
+*  2. `fileSpecRef` is added to the catalog's `/AF` array (via
+*     {@link attachAssociatedFiles}).
+*
+* @param catalog      The document catalog dictionary.
+* @param name         The name under which the file is registered in the tree.
+* @param fileSpecRef  Indirect reference to the file-specification dictionary.
+*/
+function registerEmbeddedFile(catalog, name, fileSpecRef) {
+	insertNamePairSorted(ensureEmbeddedFilesNames(catalog), name, fileSpecRef);
+	attachAssociatedFiles(catalog, [fileSpecRef]);
+}
+//#endregion
+//#region src/compliance/pageOutputIntent.ts
+/**
+* @module compliance/pageOutputIntent
+*
+* Per-page and per-stream output intents (ISO 32000-2 §14.11.5).
+*
+* In addition to the document-level `/OutputIntents` array carried on the
+* catalog, PDF 2.0 permits an `/OutputIntents` array on individual *page*
+* dictionaries and on *Form XObject* stream dictionaries.  These narrower
+* intents override the document intent for the colour-managed content of that
+* page or form, which is essential for documents that mix output conditions
+* (for example, a PDF/X job whose individual pages target different print
+* presses).
+*
+* This module provides two pure builders:
+*
+*  - {@link buildPageOutputIntent} constructs a single `/OutputIntent`
+*    dictionary (reusing {@link buildOutputIntent} for the embedded ICC
+*    `/DestOutputProfile`) and registers it as an indirect object.
+*  - {@link attachOutputIntents} sets — or, when one already exists, appends
+*    to — the `/OutputIntents` array on a target dictionary (a page dict for
+*    per-page intents, or a Form XObject stream's dict for per-stream).
+*
+* Reference: ISO 32000-2:2020, §14.11.5 (Output intents).
+*/
+/**
+* Attach output-intent references to a target dictionary's `/OutputIntents`
+* array.
+*
+* If the target has no `/OutputIntents` entry, a fresh {@link PdfArray} is
+* created and populated with `intentRefs`.  If one already exists (and is an
+* array), the references are appended to it in order, preserving the existing
+* array instance.
+*
+* The target may be a page dictionary (for per-page intents) or a Form
+* XObject stream's dictionary (for per-stream intents).
+*
+* @param target      The page or Form XObject dictionary to mutate.
+* @param intentRefs  Indirect references to `/OutputIntent` dictionaries.
+*/
+function attachOutputIntents(target, intentRefs) {
+	const existing = target.get("/OutputIntents");
+	const array = existing instanceof PdfArray ? existing : new PdfArray();
+	for (const ref of intentRefs) array.push(ref);
+	if (!(existing instanceof PdfArray)) target.set("/OutputIntents", array);
+}
+/**
+* Build a per-page / per-stream `/OutputIntent` dictionary and register it.
+*
+* The embedded ICC `/DestOutputProfile` is produced by reusing
+* {@link buildOutputIntent}; this builder then layers the per-page subtype
+* (`/S`), output-condition identifier and optional `/Info` string on top.
+* The resulting dictionary carries `/Type /OutputIntent` and may be attached
+* to a page or Form XObject dictionary via {@link attachOutputIntents}.
+*
+* @param registry  The PDF object registry to register objects into.
+* @param options   Output-intent configuration.
+* @returns         An indirect reference to the `/OutputIntent` dictionary.
+*/
+function buildPageOutputIntent(registry, options = {}) {
+	const intentRef = buildOutputIntent(registry, {
+		subtype: options.subtype ?? "/GTS_PDFA1",
+		...options.iccProfile !== void 0 ? { iccProfile: options.iccProfile } : {},
+		...options.components !== void 0 ? { components: options.components } : {},
+		...options.outputConditionIdentifier !== void 0 ? { outputConditionIdentifier: options.outputConditionIdentifier } : {}
+	});
+	const intentDict = registry.resolve(intentRef);
+	if (intentDict !== void 0 && intentDict.kind === "dict") {
+		intentDict.set("/Type", PdfName.of("OutputIntent"));
+		if (options.outputConditionIdentifier !== void 0) intentDict.set("/OutputConditionIdentifier", PdfString.literal(options.outputConditionIdentifier));
+		if (options.info !== void 0) intentDict.set("/Info", PdfString.literal(options.info));
+	}
+	return intentRef;
+}
+//#endregion
+//#region src/compliance/encryptedPayload.ts
+/**
+* @module compliance/encryptedPayload
+*
+* Unencrypted wrapper documents and encrypted payloads
+* (ISO 32000-2:2020 §7.6.7).
+*
+* A PDF 2.0 *unencrypted wrapper document* is an ordinary, viewable PDF that
+* carries an *encrypted payload* as an embedded file.  The wrapper itself is
+* not encrypted (so any conforming reader can open it and show a cover page),
+* while the sensitive content lives in the embedded payload, which is
+* protected by an external/handler-specific crypto filter.
+*
+* The payload is declared through an *Encrypted Payload* dictionary
+* (`/Type /EncryptedPayload`).  Its `/Subtype` names the crypto filter used to
+* protect the payload (for example `/AESV3`), and an optional `/Version`
+* records the version of that filter.  The Encrypted Payload dictionary is
+* attached to the embedded file's *file specification* dictionary via the
+* `/EP` key, and that file specification is also marked with
+* `/AFRelationship /EncryptedPayload`.
+*
+* This module provides two pure builders:
+*
+*  - {@link buildEncryptedPayload} — build the `/EncryptedPayload` dictionary.
+*  - {@link buildUnencryptedWrapper} — embed the payload bytes as an
+*    associated file and attach the `/EP` dictionary to its file
+*    specification, returning the file-spec reference.
+*
+* The caller attaches the returned file-spec reference to the catalog `/AF`
+* array and to the `/Names /EmbeddedFiles` name tree (for example via
+* `afAttach`).
+*
+* Reference: ISO 32000-2:2020, §7.6.7 (Unencrypted wrapper document).
+*/
+/**
+* Build an `/EncryptedPayload` dictionary (ISO 32000-2 §7.6.7).
+*
+* The returned dictionary has:
+*  - `/Type /EncryptedPayload`
+*  - `/Subtype /<subtype>` — the crypto filter name
+*  - `/Version /<version>` — only when {@link EncryptedPayloadOptions.version}
+*    is supplied
+*
+* @param options - The crypto-filter subtype and optional version.
+* @returns A spec-shaped `/EncryptedPayload` {@link PdfDict}.
+*/
+function buildEncryptedPayload(options) {
+	const dict = new PdfDict();
+	dict.set("/Type", PdfName.of("EncryptedPayload"));
+	dict.set("/Subtype", PdfName.of(options.subtype));
+	if (options.version !== void 0) dict.set("/Version", PdfName.of(options.version));
+	return dict;
+}
+/**
+* Build the embedded encrypted-payload file for an unencrypted wrapper
+* document and return its file-specification reference.
+*
+* The payload bytes are embedded via {@link createAssociatedFile} with an
+* `/AFRelationship` of `/EncryptedPayload` and an `application/octet-stream`
+* MIME type.  The resolved file-specification dictionary then receives an
+* `/EP` entry holding the {@link buildEncryptedPayload} dictionary.
+*
+* The caller is responsible for attaching the returned file-spec reference to
+* the catalog `/AF` array and the `/Names /EmbeddedFiles` name tree.
+*
+* @param registry - The PDF object registry to register objects into.
+* @param options  - The payload bytes, filename, crypto subtype/version, and
+*                   optional description.
+* @returns An indirect reference to the file-specification dictionary.
+*/
+function buildUnencryptedWrapper(registry, options) {
+	const { fileSpecRef } = createAssociatedFile(registry, {
+		data: options.data,
+		filename: options.filename,
+		mimeType: "application/octet-stream",
+		relationship: "EncryptedPayload",
+		description: options.description
+	});
+	const fileSpec = registry.resolve(fileSpecRef);
+	if (fileSpec instanceof PdfDict) {
+		const ep = buildEncryptedPayload({
+			subtype: options.subtype,
+			version: options.version
+		});
+		fileSpec.set("/EP", ep);
+	}
+	return fileSpecRef;
+}
+//#endregion
+//#region src/core/softMask.ts
+/**
+* @module core/softMask
+*
+* Soft-mask groups in graphics state (ISO 32000-1 §11.6.5.2).
+*
+* A *soft mask* defines a per-pixel shape/opacity for subsequent painting
+* operations.  It is carried in an `ExtGState` dictionary under the `/SMask`
+* key.  The mask is derived from a *transparency-group XObject* (a form
+* XObject whose `/Group` dictionary has `/S /Transparency`):
+*
+*  - A **luminosity** mask (`/S /Luminosity`) computes the mask value from the
+*    luminosity of the group's composited result.  An optional `/BC` backdrop
+*    color sets the colour against which the group is composited before the
+*    luminosity is measured.
+*  - An **alpha** mask (`/S /Alpha`) computes the mask value from the group's
+*    accumulated alpha (shape/opacity).  `/BC` is not meaningful and is omitted.
+*
+* An optional `/TR` *transfer function* remaps the computed mask values; it may
+* be an indirect reference to a function object or the name `/Identity`.
+*
+* These are pure builders: they return spec-shaped `ExtGState` dictionaries.
+* Registering the result and naming it in a page's `/Resources /ExtGState`
+* (e.g. via `page.registerExtGState(name, registry.register(extGState))`) is
+* the caller's concern.
+*
+* Reference: ISO 32000-1:2008, §11.6.5.2 (Mask shape and opacity);
+*            ISO 32000-1:2008, §8.4.5 (Graphics state, `/SMask`).
+*/
+/**
+* Build an `ExtGState` dictionary that installs a soft-mask group.
+*
+* The returned dictionary has `/Type /ExtGState` and an `/SMask` mask
+* dictionary:
+*
+*  - `/Type /Mask`
+*  - `/S /Luminosity` or `/S /Alpha` (per {@link SoftMaskGroupOptions.type},
+*    defaulting to `Luminosity`)
+*  - `/G` → the supplied group XObject reference
+*  - `/BC [ … ]` — backdrop colour, **only** for luminosity masks and only
+*    when {@link SoftMaskGroupOptions.backdropColor} is provided
+*  - `/TR` → the transfer function (indirect reference) or the name
+*    `/Identity`, only when {@link SoftMaskGroupOptions.transferFunction} is
+*    provided
+*
+* @param options - The soft-mask group description.
+* @returns A spec-shaped `ExtGState` {@link PdfDict}.
+*/
+function buildSoftMaskGroupExtGState(options) {
+	const subtype = options.type ?? "Luminosity";
+	const smask = new PdfDict();
+	smask.set("/Type", PdfName.of("Mask"));
+	smask.set("/S", PdfName.of(subtype));
+	smask.set("/G", options.groupXObject);
+	if (subtype === "Luminosity" && options.backdropColor !== void 0 && options.backdropColor.length > 0) smask.set("/BC", PdfArray.fromNumbers([...options.backdropColor]));
+	if (options.transferFunction !== void 0) smask.set("/TR", options.transferFunction === "Identity" ? PdfName.of("Identity") : options.transferFunction);
+	const extGState = new PdfDict();
+	extGState.set("/Type", PdfName.of("ExtGState"));
+	extGState.set("/SMask", smask);
+	return extGState;
+}
+/**
+* Build an `ExtGState` dictionary that clears any active soft mask by setting
+* `/SMask /None`.  Apply this after a masked region to restore unmasked
+* painting.
+*
+* @returns An `ExtGState` {@link PdfDict} with `/SMask /None`.
+*/
+function buildSoftMaskNone() {
+	const extGState = new PdfDict();
+	extGState.set("/Type", PdfName.of("ExtGState"));
+	extGState.set("/SMask", PdfName.of("None"));
+	return extGState;
+}
+//#endregion
+//#region src/core/imageMask.ts
+/**
+* @module core/imageMask
+*
+* Image masks and black-point compensation per ISO 32000-2 §8.9.6
+* (Masked images) and §8.6.5.9 (Black-point compensation).
+*
+* PDF supports three ways of masking an image XObject:
+*
+* - **Stencil mask** — a 1-bit-per-component `/ImageMask` image whose sample
+*   values select which areas of the page are painted with the current fill
+*   colour and which are left untouched (§8.9.6.2). The mask data is packed
+*   one bit per sample, each row byte-aligned (`ceil(width / 8)` bytes per
+*   row); the caller supplies the already-packed bytes.
+* - **Colour-key mask** — a `/Mask` array of `[min0 max0 min1 max1 …]`
+*   integer ranges (two per colour component) that makes matching sample
+*   colours transparent (§8.9.6.4).
+* - **Soft mask** — a separate DeviceGray image referenced from a base
+*   image's `/SMask` entry, giving per-pixel opacity (§11.6.5.2).
+*
+* Black-point compensation (§8.6.5.9) is controlled through an ExtGState's
+* `/UseBlackPtComp` entry, which selects whether the conversion between
+* colour spaces maps source black to destination black.
+*
+* These are pure builders: they construct (and, for the stream variants,
+* register) PDF objects but do not wire them into a page or resource
+* dictionary — that is the caller's concern.
+*
+* Reference: ISO 32000-2:2020, §8.9.6 (Masked images), §8.6.5.9
+*            (Black-point compensation).
+*/
+/**
+* Build a stencil mask: a 1-bit `/ImageMask` image XObject (§8.9.6.2).
+*
+* The returned stream has `/Type /XObject`, `/Subtype /Image`,
+* `/ImageMask true`, `/BitsPerComponent 1`, and the supplied `/Width` and
+* `/Height`. When a `decode` pair is given it is emitted as a `/Decode`
+* array, allowing the mask polarity to be inverted (`[1 0]`).
+*
+* The `bits` buffer must already be packed one bit per sample with each row
+* byte-aligned (`ceil(width / 8)` bytes per row); this builder stores it
+* verbatim and does not repack it.
+*
+* @param registry - Registry to register the stream into.
+* @param bits     - Packed, byte-aligned 1-bpc mask data.
+* @param width    - Image width in samples.
+* @param height   - Image height in samples.
+* @param decode   - Optional `[d0, d1]` decode pair.
+* @returns An indirect reference to the registered image XObject stream.
+*/
+function buildStencilMask(registry, bits, width, height, decode) {
+	const dict = new PdfDict();
+	dict.set("/Type", PdfName.of("XObject"));
+	dict.set("/Subtype", PdfName.of("Image"));
+	dict.set("/ImageMask", PdfBool.TRUE);
+	dict.set("/BitsPerComponent", PdfNumber.of(1));
+	dict.set("/Width", PdfNumber.of(width));
+	dict.set("/Height", PdfNumber.of(height));
+	if (decode !== void 0) dict.set("/Decode", PdfArray.fromNumbers([decode[0], decode[1]]));
+	dict.set("/Length", PdfNumber.of(bits.length));
+	return registry.register(new PdfStream(dict, bits));
+}
+/**
+* Build a colour-key masking array (§8.9.6.4).
+*
+* The `ranges` list holds two integers — a minimum and a maximum — per
+* colour component, laid out as `[min0 max0 min1 max1 …]`. Sample colours
+* whose every component falls within its range become transparent. The
+* returned {@link PdfArray} is assigned to a base image's `/Mask` entry.
+*
+* @param ranges - An even-length list of `[min, max]` integer pairs.
+* @returns A `/Mask` {@link PdfArray} of {@link PdfNumber}s.
+* @throws RangeError if `ranges` is empty or has an odd length.
+*/
+function buildColorKeyMask(ranges) {
+	if (ranges.length === 0 || ranges.length % 2 !== 0) throw new RangeError(`colour-key mask requires a non-empty even number of values (min/max pairs); got ${ranges.length}`);
+	return new PdfArray(ranges.map((v) => PdfNumber.of(v)));
+}
+/**
+* Build an image soft mask: a DeviceGray image XObject usable as a base
+* image's `/SMask` (§11.6.5.2).
+*
+* The returned stream has `/Type /XObject`, `/Subtype /Image`,
+* `/ColorSpace /DeviceGray`, the supplied `/Width` and `/Height`, and
+* `/BitsPerComponent` (defaulting to 8). Each grayscale sample provides the
+* opacity of the corresponding base-image pixel.
+*
+* @param registry          - Registry to register the stream into.
+* @param gray              - Grayscale opacity samples.
+* @param width             - Image width in samples.
+* @param height            - Image height in samples.
+* @param bitsPerComponent  - Bits per sample; defaults to 8.
+* @returns An indirect reference to the registered soft-mask image XObject.
+*/
+function buildImageSoftMask(registry, gray, width, height, bitsPerComponent) {
+	const dict = new PdfDict();
+	dict.set("/Type", PdfName.of("XObject"));
+	dict.set("/Subtype", PdfName.of("Image"));
+	dict.set("/Width", PdfNumber.of(width));
+	dict.set("/Height", PdfNumber.of(height));
+	dict.set("/ColorSpace", PdfName.of("DeviceGray"));
+	dict.set("/BitsPerComponent", PdfNumber.of(bitsPerComponent ?? 8));
+	dict.set("/Length", PdfNumber.of(gray.length));
+	return registry.register(new PdfStream(dict, gray));
+}
+/**
+* Build an ExtGState that controls black-point compensation (§8.6.5.9).
+*
+* The returned dictionary has `/Type /ExtGState` and `/UseBlackPtComp` set
+* to the requested mode:
+*
+* - `Default` — leave the choice to the conforming reader.
+* - `ON`      — always apply black-point compensation.
+* - `OFF`     — never apply black-point compensation.
+*
+* @param mode - The `/UseBlackPtComp` mode.
+* @returns An ExtGState {@link PdfDict}.
+*/
+function buildBlackPointCompensationExtGState(mode) {
+	const gs = new PdfDict();
+	gs.set("/Type", PdfName.of("ExtGState"));
+	gs.set("/UseBlackPtComp", PdfName.of(mode));
+	return gs;
+}
+//#endregion
+//#region src/accessibility/taggingHelpers.ts
+/**
+* The property key under which {@link tagList} records the chosen
+* {@link ListNumbering} on a list element's `options` object.
+*
+* `StructureElementOptions` has no dedicated `listNumbering` field, so
+* the value is stored as an extra (string-keyed) property on the same
+* options object.  When the structure tree is serialized this is the
+* value an attribute writer should emit as the list's `/ListNumbering`
+* entry inside an `/A` attribute dictionary whose owner is `/List`
+* (ISO 32000, Table 384):
+*
+* ```
+* /A << /O /List /ListNumbering /Decimal >>
+* ```
+*
+* Using a well-known string key (rather than a `Symbol`) keeps the
+* value plain-serializable and inspectable from tests.
+*/
+const LIST_NUMBERING_KEY = "__listNumbering";
+/**
+* Heading level → structure-type mapping for {@link tagHeading}.
+*
+* Indexed by the numeric heading level (`1`..`6`); the result is the
+* corresponding standard heading structure type (`'H1'`..`'H6'`).
+*/
+const HEADING_TYPE = {
+	1: "H1",
+	2: "H2",
+	3: "H3",
+	4: "H4",
+	5: "H5",
+	6: "H6"
+};
+/**
+* Tag a heading element of the given level.
+*
+* @param tree    The structure tree to add the element to.
+* @param parent  The parent element, or `null` to add under the root
+*                `Document` element.
+* @param level   The heading level (`1`..`6`); maps to `H1`..`H6`.
+* @param options Optional attributes (title, language, id, …).
+* @returns       The newly created heading element (type `H1`..`H6`).
+*
+* @example
+* ```ts
+* const tree = doc.createStructureTree();
+* const h2 = tagHeading(tree, null, 2, { title: 'Background' });
+* // h2.type === 'H2'
+* ```
+*/
+function tagHeading(tree, parent, level, options) {
+	return tree.addElement(parent, HEADING_TYPE[level], options);
+}
+/**
+* Tag a paragraph (`P`) element.
+*
+* @param tree    The structure tree to add the element to.
+* @param parent  The parent element, or `null` for the root.
+* @param options Optional attributes.
+* @returns       The newly created `P` element.
+*/
+function tagParagraph(tree, parent, options) {
+	return tree.addElement(parent, "P", options);
+}
+/**
+* Tag a figure (`Figure`) element with alternative text.
+*
+* The `altText` argument is required because PDF/UA mandates
+* alternative text for illustration elements.  If the caller also
+* supplies `altText` in `options`, that explicit value takes
+* precedence over the positional argument.
+*
+* @param tree    The structure tree to add the element to.
+* @param parent  The parent element, or `null` for the root.
+* @param altText Alternative text describing the figure.
+* @param options Optional additional attributes.
+* @returns       The newly created `Figure` element with `/Alt` set.
+*/
+function tagFigure(tree, parent, altText, options) {
+	const merged = {
+		altText,
+		...options
+	};
+	return tree.addElement(parent, "Figure", merged);
+}
+/**
+* Tag a link (`Link`) element.
+*
+* @param tree    The structure tree to add the element to.
+* @param parent  The parent element, or `null` for the root.
+* @param options Optional attributes.
+* @returns       The newly created `Link` element.
+*/
+function tagLink(tree, parent, options) {
+	return tree.addElement(parent, "Link", options);
+}
+/**
+* Tag a list (`L`) element and record its numbering style.
+*
+* The chosen {@link ListNumbering} is stored on the returned element's
+* `options` object under {@link LIST_NUMBERING_KEY} (since
+* `StructureElementOptions` has no dedicated field).  A serializer can
+* emit it as the list's `/ListNumbering` attribute (ISO 32000,
+* Table 384) inside an `/A` dictionary owned by `/List`.
+*
+* @param tree      The structure tree to add the element to.
+* @param parent    The parent element, or `null` for the root.
+* @param numbering The list numbering style (default `'None'`).
+* @param options   Optional additional attributes.
+* @returns         The newly created `L` element.
+*/
+function tagList(tree, parent, numbering = "None", options) {
+	const list = tree.addElement(parent, "L", options);
+	list.options[LIST_NUMBERING_KEY] = numbering;
+	return list;
+}
+/**
+* Tag a list item under a list, building the conventional
+* `LI` → (`Lbl`, `LBody`) substructure.
+*
+* @param tree    The structure tree to add the elements to.
+* @param list    The parent `L` (list) element.
+* @param options Optional attributes for the `LI` element.
+* @returns       The created `item` (`LI`), `label` (`Lbl`) and
+*                `body` (`LBody`) elements.
+*
+* @example
+* ```ts
+* const list = tagList(tree, null, 'Decimal');
+* const { item, label, body } = tagListItem(tree, list);
+* // item.type === 'LI', label.type === 'Lbl', body.type === 'LBody'
+* ```
+*/
+function tagListItem(tree, list, options) {
+	const item = tree.addElement(list, "LI", options);
+	return {
+		item,
+		label: tree.addElement(item, "Lbl"),
+		body: tree.addElement(item, "LBody")
+	};
+}
+/**
+* Tag a table (`Table`) element.
+*
+* @param tree    The structure tree to add the element to.
+* @param parent  The parent element, or `null` for the root.
+* @param options Optional attributes.
+* @returns       The newly created `Table` element.
+*/
+function tagTable(tree, parent, options) {
+	return tree.addElement(parent, "Table", options);
+}
+/**
+* Tag a table row (`TR`) under a table.
+*
+* @param tree   The structure tree to add the element to.
+* @param table  The parent `Table` element.
+* @returns      The newly created `TR` element.
+*/
+function tagTableRow(tree, table) {
+	return tree.addElement(table, "TR");
+}
+/**
+* Tag a table header cell (`TH`) under a row, recording its scope.
+*
+* The `scope` is stored in the element's options (`/Scope` attribute,
+* one of `Row`, `Column`, or `Both`) and is used by table-header
+* validation to associate header cells with the cells they describe.
+*
+* @param tree    The structure tree to add the element to.
+* @param row     The parent `TR` element.
+* @param scope   The header scope (default `'Column'`).
+* @param options Optional additional attributes (e.g. colSpan/rowSpan).
+* @returns       The newly created `TH` element with `scope` set.
+*/
+function tagTableHeaderCell(tree, row, scope = "Column", options) {
+	const merged = {
+		...options,
+		scope
+	};
+	return tree.addElement(row, "TH", merged);
+}
+/**
+* Tag a table data cell (`TD`) under a row.
+*
+* @param tree    The structure tree to add the element to.
+* @param row     The parent `TR` element.
+* @param options Optional attributes (e.g. colSpan/rowSpan).
+* @returns       The newly created `TD` element.
+*/
+function tagTableDataCell(tree, row, options) {
+	return tree.addElement(row, "TD", options);
+}
+//#endregion
+//#region src/accessibility/pdfUa2.ts
+/** The AIIM PDF/UA identification namespace URI (used in the XMP packet). */
+const PDFUA_ID_NS = "http://www.aiim.org/pdfua/ns/id/";
+/** The PDF/UA part identified by this module's XMP. */
+const PDFUA2_PART = 2;
+/**
+* The PDF/UA-2 revision year.  ISO 14289-2 was published in 2024, which the
+* AIIM `pdfuaid:rev` field records as a four-digit year.
+*/
+const PDFUA2_REV = 2024;
+/** Illustration types that require alternative text under PDF/UA-2. */
+const ILLUSTRATION_TYPES = /* @__PURE__ */ new Set([
+	"Figure",
+	"Formula",
+	"Form"
+]);
+/**
+* Validate a PDF document against PDF/UA-2 (ISO 14289-2) requirements.
+*
+* The check reuses {@link validatePdfUa} for the shared tagging, language,
+* MarkInfo, and metadata requirements, then layers the PDF 2.0 / UA-2
+* specific requirements on top:
+*
+* - **UA2-STRUCT-001** — a structure tree must exist (tagged PDF).
+* - **UA2-NS-001** — the structure tree must declare structure
+*   `/Namespaces` (PDF/UA-2 builds on PDF 2.0 namespaces).
+* - **UA2-LANG-001** — the document must declare a natural language
+*   (`/Lang`).
+* - **UA2-FIG-001** — every figure must carry alternative text.
+*
+* Each failure is mapped to an ISO 14289-2 clause string.  The returned
+* result is `conformant` only when there are no issues.
+*
+* @param doc  The PDF document to validate.
+* @returns    A {@link PdfUa2Result} describing conformance and issues.
+*
+* @example
+* ```ts
+* import { createPdf } from 'modern-pdf-lib';
+* import { validatePdfUa2 } from 'modern-pdf-lib/accessibility';
+*
+* const doc = createPdf();
+* const result = validatePdfUa2(doc);
+* if (!result.conformant) {
+*   for (const issue of result.issues) {
+*     console.error(`[${issue.code}] ${issue.message} (§${issue.clause})`);
+*   }
+* }
+* ```
+*/
+function validatePdfUa2(doc) {
+	const issues = [];
+	const tree = doc.getStructureTree();
+	if (!tree) issues.push({
+		code: "UA2-STRUCT-001",
+		message: "Document has no structure tree (/StructTreeRoot). PDF/UA-2 requires a fully tagged PDF 2.0 document with logical structure.",
+		clause: "8.2"
+	});
+	if (!hasDeclaredNamespaces(tree)) issues.push({
+		code: "UA2-NS-001",
+		message: "Structure tree does not declare structure /Namespaces. PDF/UA-2 builds on PDF 2.0 structure namespaces (ISO 32000-2 §14.7.4); the StructTreeRoot must declare its namespaces.",
+		clause: "8.2.2"
+	});
+	const lang = doc.getLanguage();
+	if (lang === void 0 || lang.trim().length === 0) issues.push({
+		code: "UA2-LANG-001",
+		message: "Document has no natural language (/Lang). PDF/UA-2 requires the document catalog to specify a default natural language.",
+		clause: "7.2"
+	});
+	if (tree) for (const elem of tree.getAllElements()) {
+		if (!ILLUSTRATION_TYPES.has(elem.type)) continue;
+		if (elem.options.artifact) continue;
+		const alt = elem.options.altText;
+		const actual = elem.options.actualText;
+		const hasAlt = alt !== void 0 && alt.trim().length > 0;
+		const hasActual = actual !== void 0 && actual.trim().length > 0;
+		if (!hasAlt && !hasActual) issues.push({
+			code: "UA2-FIG-001",
+			message: `${elem.type} element has no /Alt or /ActualText. PDF/UA-2 requires alternative text for all non-decorative illustration elements.`,
+			clause: "7.3"
+		});
+	}
+	const ua1 = validatePdfUa(doc);
+	for (const err of ua1.errors) {
+		if (isCoveredByUa2(err.code)) continue;
+		issues.push({
+			code: `UA2-${err.code}`,
+			message: err.message,
+			clause: mapUa1Clause(err.clause)
+		});
+	}
+	return {
+		conformant: issues.length === 0,
+		issues
+	};
+}
+/**
+* Build an XMP packet (RDF/XML) that identifies a document as PDF/UA-2.
+*
+* The packet declares the AIIM PDF/UA identification schema
+* (`pdfuaid`, namespace `http://www.aiim.org/pdfua/ns/id/`) with:
+*
+* - `pdfuaid:part` = `2` — the PDF/UA part (ISO 14289-2);
+* - `pdfuaid:rev`  = the revision year of the standard.
+*
+* The result is a serialized, packet-wrapped XMP string suitable for
+* embedding as the document's `/Metadata` stream.
+*
+* @returns  The serialized PDF/UA-2 identification XMP packet.
+*
+* @example
+* ```ts
+* import { buildPdfUa2Xmp } from 'modern-pdf-lib/accessibility';
+*
+* doc.setXmpMetadata(buildPdfUa2Xmp());
+* ```
+*/
+function buildPdfUa2Xmp() {
+	return [
+		"<?xpacket begin=\"\" id=\"W5M0MpCehiHzreSzNTczkc9d\"?>",
+		"<x:xmpmeta xmlns:x=\"adobe:ns:meta/\">",
+		"  <rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">",
+		`    <rdf:Description rdf:about=""`,
+		`        xmlns:pdfuaid="${PDFUA_ID_NS}">`,
+		`      <pdfuaid:part>${PDFUA2_PART}</pdfuaid:part>`,
+		`      <pdfuaid:rev>${PDFUA2_REV}</pdfuaid:rev>`,
+		"    </rdf:Description>",
+		"  </rdf:RDF>",
+		"</x:xmpmeta>",
+		"<?xpacket end=\"w\"?>"
+	].join("\n");
+}
+/**
+* Determine whether a structure tree declares one or more structure
+* namespaces.
+*
+* The in-memory {@link PdfStructureTree} model does not yet carry a
+* first-class namespaces field, so callers declare namespaces by attaching
+* a `namespaces` array (of namespace URI strings, or namespace descriptor
+* objects) to the tree.  This helper reads that field defensively and also
+* recognizes a per-element `namespace` option as evidence of namespace use.
+*
+* @internal
+*/
+function hasDeclaredNamespaces(tree) {
+	if (!tree) return false;
+	const declared = tree.namespaces;
+	if (Array.isArray(declared) && declared.length > 0) return true;
+	for (const elem of tree.getAllElements()) {
+		const ns = elem.options.namespace;
+		if (typeof ns === "string" && ns.length > 0) return true;
+	}
+	return false;
+}
+/**
+* Whether a PDF/UA-1 error code is already represented by a dedicated
+* UA-2 issue produced above (to avoid duplicate structure-tree / language
+* findings).
+*
+* @internal
+*/
+function isCoveredByUa2(ua1Code) {
+	return ua1Code === "UA-STRUCT-001" || ua1Code === "UA-STRUCT-002" || ua1Code === "UA-META-001" || ua1Code === "UA-META-002" || ua1Code === "UA-META-003";
+}
+/**
+* Map a PDF/UA-1 (ISO 14289-1) clause reference onto the corresponding
+* PDF/UA-2 (ISO 14289-2) clause.  The two standards share most clause
+* numbering; when a UA-1 clause is absent we fall back to the general
+* UA-2 conformance clause.
+*
+* @internal
+*/
+function mapUa1Clause(ua1Clause) {
+	if (ua1Clause === void 0 || ua1Clause.length === 0) return "5";
+	return ua1Clause;
+}
+//#endregion
+//#region src/accessibility/autoTag.ts
+/** Default heading-detection scale relative to body text size. */
+const DEFAULT_HEADING_SCALE = 1.2;
+/**
+* Maximum vertical gap (in page-space units, as a fraction of the run's
+* font size) within which two text runs are considered to belong to the
+* same visual line.  Runs whose baselines are within this fraction of an
+* em are merged onto one line.
+*/
+const SAME_LINE_FRACTION = .5;
+/** Highest heading level tag supported. */
+const MAX_HEADING_LEVEL = 6;
+/**
+* Infer a coarse logical structure for a single untagged page and add the
+* inferred `H1`..`H6` and `P` elements to the document's structure tree.
+*
+* The procedure:
+* 1. Interpret the page into positioned text runs.
+* 2. Group runs into visual lines by their baseline y-position.
+* 3. Determine the body font size as the median run font size.
+* 4. Order lines top-to-bottom (reading order on a y-up page).
+* 5. Classify each line as a heading (font size `>= headingScale × body`)
+*    or body text; map distinct heading sizes to `H1`..`H6`
+*    (largest → `H1`).
+* 6. Emit one heading element per heading line and one `P` element per
+*    contiguous block of body lines.
+*
+* Never throws on an empty (or text-free) page — it returns all-zero
+* counts and leaves the structure tree untouched.
+*
+* @param doc        The document containing the page.
+* @param pageIndex  Zero-based index of the page to tag.
+* @param options    Optional heuristic tuning ({@link AutoTagOptions}).
+* @returns          Counts of the elements that were added.
+*/
+function autoTagPage(doc, pageIndex, options) {
+	const headingScale = options?.headingScale ?? DEFAULT_HEADING_SCALE;
+	const textItems = collectTextItems(doc, pageIndex);
+	if (textItems.length === 0) return {
+		headings: 0,
+		paragraphs: 0,
+		elements: 0
+	};
+	const lines = groupIntoLines(textItems);
+	if (lines.length === 0) return {
+		headings: 0,
+		paragraphs: 0,
+		elements: 0
+	};
+	const bodySize = medianFontSize(textItems);
+	const ordered = [...lines].sort((a, b) => b.y - a.y);
+	const headingThreshold = bodySize * headingScale;
+	const headingLevelForSize = buildHeadingLevelMap(ordered, headingThreshold);
+	const tree = doc.createStructureTree();
+	let headings = 0;
+	let paragraphs = 0;
+	let paragraphOpen = false;
+	for (const line of ordered) if (line.fontSize >= headingThreshold) {
+		paragraphOpen = false;
+		const type = `H${headingLevelForSize.get(line.fontSize) ?? 1}`;
+		tree.addElement(null, type, { title: line.text });
+		headings++;
+	} else if (!paragraphOpen) {
+		tree.addElement(null, "P");
+		paragraphs++;
+		paragraphOpen = true;
+	}
+	return {
+		headings,
+		paragraphs,
+		elements: headings + paragraphs
+	};
+}
+/**
+* Interpret the page and return only its text runs.  Returns an empty
+* array (never throws) if the page cannot be interpreted.
+*
+* @internal
+*/
+function collectTextItems(doc, pageIndex) {
+	const pageCount = doc.getPageCount();
+	if (pageIndex < 0 || pageIndex >= pageCount) return [];
+	let items = [];
+	try {
+		items = interpretPage(doc.getPage(pageIndex)).items.filter((it) => it.type === "text" && it.text.trim().length > 0);
+	} catch {
+		return [];
+	}
+	return [...items];
+}
+/**
+* Group text runs into visual lines by their baseline y-position.
+*
+* The baseline is taken from the run's text-space → page-space transform
+* (`transform[5]`, the `f` translation component).  Runs whose baselines
+* fall within {@link SAME_LINE_FRACTION} of an em of an existing line are
+* merged onto that line; the line's font size is the maximum run size.
+*
+* @internal
+*/
+function groupIntoLines(items) {
+	const sorted = [...items].sort((a, b) => b.transform[5] - a.transform[5]);
+	const lines = [];
+	for (const item of sorted) {
+		const y = item.transform[5];
+		const size = item.fontSize > 0 ? item.fontSize : Math.abs(item.transform[3]) || 1;
+		const last = lines[lines.length - 1];
+		const tolerance = size * SAME_LINE_FRACTION;
+		if (last && Math.abs(last.y - y) <= tolerance) {
+			last.text = `${last.text} ${item.text}`.trim();
+			if (size > last.fontSize) last.fontSize = size;
+		} else lines.push({
+			y,
+			fontSize: size,
+			text: item.text.trim()
+		});
+	}
+	return lines.map((l) => ({
+		y: l.y,
+		fontSize: l.fontSize,
+		text: l.text
+	}));
+}
+/**
+* Compute the median font size across all text runs.  The median is more
+* robust than the mean against a handful of oversized heading runs, so it
+* gives a reliable estimate of the body text size.
+*
+* @internal
+*/
+function medianFontSize(items) {
+	const sizes = items.map((it) => it.fontSize > 0 ? it.fontSize : Math.abs(it.transform[3])).filter((s) => s > 0).sort((a, b) => a - b);
+	if (sizes.length === 0) return 1;
+	const mid = sizes.length >> 1;
+	if (sizes.length % 2 === 1) return sizes[mid];
+	return (sizes[mid - 1] + sizes[mid]) / 2;
+}
+/**
+* Build a map from each distinct heading font size to a heading level.
+* The largest heading size becomes `H1`, the next-largest `H2`, and so on,
+* capped at {@link MAX_HEADING_LEVEL} (`H6`).
+*
+* @internal
+*/
+function buildHeadingLevelMap(lines, headingThreshold) {
+	const distinct = [...new Set(lines.filter((l) => l.fontSize >= headingThreshold).map((l) => l.fontSize))].sort((a, b) => b - a);
+	const map = /* @__PURE__ */ new Map();
+	distinct.forEach((size, index) => {
+		map.set(size, Math.min(index + 1, MAX_HEADING_LEVEL));
+	});
+	return map;
+}
+//#endregion
 //#region src/index.ts
 /** Whether initWasm has already completed successfully. */
 let wasmInitialized = false;
@@ -29972,15 +30967,15 @@ async function initWasm(options) {
 	if (wasmInitialized) return;
 	const inits = [];
 	if (options.deflate || options.deflateWasm) inits.push((async () => {
-		const { initDeflateWasm } = await import("./pdfDocument-B6czyaVI.mjs").then((n) => n.zt);
+		const { initDeflateWasm } = await import("./pdfDocument-Cgkkk8F8.mjs").then((n) => n.zt);
 		await initDeflateWasm(options.deflateWasm);
 	})());
 	if (options.png || options.pngWasm) inits.push((async () => {
-		const { initPngWasm } = await import("./pdfDocument-B6czyaVI.mjs").then((n) => n.At);
+		const { initPngWasm } = await import("./pdfDocument-Cgkkk8F8.mjs").then((n) => n.At);
 		await initPngWasm(options.pngWasm);
 	})());
 	if (options.fonts || options.fontWasm) inits.push((async () => {
-		const { initSubsetWasm } = await import("./pdfDocument-B6czyaVI.mjs").then((n) => n.Pt);
+		const { initSubsetWasm } = await import("./pdfDocument-Cgkkk8F8.mjs").then((n) => n.Pt);
 		await initSubsetWasm(options.fontWasm);
 	})());
 	if (options.jpeg || options.jpegWasm) inits.push((async () => {
@@ -29991,6 +30986,6 @@ async function initWasm(options) {
 	wasmInitialized = true;
 }
 //#endregion
-export { setFieldValue as $, appendIncrementalUpdate as $i, formatDate$1 as $n, extractJpegMetadata as $r, buildLab as $t, buildPdfXOutputIntent as A, generateSquigglyAppearance as Aa, validatePdfA as Ai, flattenField as An, ean13ToOperators as Ar, levenshtein as At, decodeTile as B, buildSeparationColorSpace as Ba, hasLtvData as Bi, ForeignPageError as Bn, encodeCode128 as Br, buildType1Halftone as Bt, validateKeyUsage as C, PdfFreeTextAnnotation as Ca, getToUnicodeCmap as Ci, batchFlatten as Cn, pdf417ToOperators as Cr, generateOrderX as Ct, layoutColumns as D, generateInkAppearance as Da, detectTransparency as Di, getBookmarks as Dn, encodeUpcA as Dr, buildFunctionShading as Dt, findHyphenationPoints as E, generateHighlightAppearance as Ea, generateSrgbIccProfile as Ei, addBookmark as En, calculateUpcCheckDigit as Er, pdfA4Rules as Et, normalizeComponentDepth as F, buildXmpMetadata as Fa, computeObjectHash as Fi, EncryptedPdfError as Fn, itfToOperators as Fr, buildPdfX6OutputIntent as Ft, downloadCrl as G, buildFieldLockDict as Gi, NoSuchFieldError as Gn, embedTiffDirect as Gr, markdownToPdf as Gt, parseTileInfo as H, saveDocumentIncremental as Ha, getCounterSignatures as Hi, InvalidFieldNamePartError as Hn, valuesToModules as Hr, identityTransferFunction as Ht, offsetSignedToUnsigned as I, createXmpStream as Ia, findChangedObjects as Ii, ExceededMaxLengthError as In, code39ToOperators as Ir, validateBoxGeometry as It, checkCertificateStatus as J, MdpPermission as Ji, RichTextFieldReadError as Jn, webpToJpeg as Jr, reconstructParagraphs as Jt, extractCrlUrls as K, getFieldLocks as Ki, PluginError as Kn, encodePngFromPixels as Kr, buildCollection as Kt, summarizeBitDepth as L, parseXmpMetadata$1 as La, optimizeIncrementalSave as Li, FieldAlreadyExistsError as Ln, computeCode39CheckDigit as Lr, STANDARD_SPOT_FUNCTIONS as Lt, validatePdfX as M, generateUnderlineAppearance as Ma, getLinearizationInfo as Mi, flattenForm as Mn, encodeEan13 as Mr, generateCiiXml as Mt, downscale16To8 as N, PdfLinkAnnotation as Na, isLinearized as Ni, BatchProcessingError as Nn, encodeEan8 as Nr, buildBoxDict as Nt, layoutParagraph as O, generateLineAppearance as Oa, flattenTransparency as Oi, removeAllBookmarks as On, upcAToOperators as Or, sampleShadingColor as Ot, getComponentDepths as P, PdfTextAnnotation as Pa, linearizePdf as Pi, CombedTextLayoutError as Pn, encodeItf as Pr, buildGtsPdfxVersion as Pt, resolveFieldReference as Q, validateSignatureChain as Qi, applyHeaderFooterToPage as Qn, isCmykTiff as Qr, buildCalRGB as Qt, upscale8To16 as R, PDFOperator as Ra, buildDssDictionary as Ri, FieldExistsAsNonTerminalError as Rn, encodeCode39 as Rr, buildSampledTransferFunction as Rt, validateExtendedKeyUsage as S, PdfUnderlineAnnotation as Sa, generateZapfDingbatsToUnicodeCmap as Si, validatePdfUa as Sn, encodePdf417 as Sr, splitByScript as St, validateCertificateChain as T, generateFreeTextAppearance as Ta, SRGB_ICC_PROFILE as Ti, processBatch as Tn, encodeDataMatrix as Tr, buildPdfA4Xmp as Tt, verifySignatureDetailed as U, saveIncremental as Ua, diffSignedContent as Ui, InvalidPageSizeError as Un, PdfWorker as Ur, nameHalftone as Ut, decodeTileRegion as V, ChangeTracker as Va, addCounterSignature as Vi, InvalidColorError as Vn, encodeCode128Values as Vr, buildType5Halftone as Vt, TrustStore as W, addFieldLock as Wi, MissingOnValueCheckError as Wn, canDirectEmbed as Wr, evaluateFunction as Wt, createSandbox as X, getCertificationLevel as Xi, UnexpectedFieldTypeError as Xn, convertTiffCmykToRgb as Xr, buildDocTimeStampDict as Xt, extractOcspUrl as Y, buildDocMdpReference as Yi, StreamingParseError as Yn, webpToPng as Yr, DEFAULT_DOC_TIMESTAMP_CONTENTS_SIZE as Yt, getFieldValue as Z, setCertificationLevel as Zi, applyHeaderFooter as Zn, embedTiffCmyk as Zr, buildCalGray as Zt, interpretPage as _, PdfPolygonAnnotation as _a, getProfile as _i, metadataPlugin as _n, readCode39 as _r, gtsPdfVtVersion as _t, redactRegions as a, parseTimestampResponse as aa, recompressImage as ai, MATHML_NAMESPACE as an, estimateTextWidth as ar, formatDate as at, EKU_OIDS as b, PdfSquigglyAnnotation as ba, generateSymbolToUnicodeCmap as bi, PdfDocumentBuilder as bn, calculateBarcodeDimensions as br, createRangeFetcher as bt, comparePages as c, PdfFileAttachmentAnnotation as ca, generatePdfAXmp as ci, buildNamespacesArray as cn, wrapText$2 as cr, formatNumber$1 as ct, generateThumbnail as d, PdfRedactAnnotation as da, stripProhibitedFeatures as di, buildRequirements as dn, borderedPreset as dr, isWoff2 as dt, findExistingSignatures as ea, injectJpegMetadata as ei, labToRgb as en, replaceTemplateVariables as er, addVisibilityAction as et, renderDisplayListToCanvas as f, PdfInkAnnotation as fa, buildAfArray as fi, buildDPartRoot as fn, minimalPreset as fr, readWoffHeader as ft, interpretContentStream as g, PdfPolyLineAnnotation as ga, validateXmpMetadata as gi, accessibilityPlugin as gn, readCode128 as gr, buildVtDpm as gt, renderPageToImage as h, PdfLineAnnotation as ha, parseXmpMetadata as hi, tableToJson as hn, readBarcode as hr, buildPdfVtDParts as ht, renderPageTile as i, buildTimestampRequest as ia, optimizeImage as ii, toSarif as in, ellipsisText as ir, AFDate_FormatEx as it, enforcePdfX as j, generateStrikeOutAppearance as ja, delinearizePdf as ji, flattenFields as jn, ean8ToOperators as jr, renderCodeFrame as jt, layoutTextFlow as k, generateSquareAppearance as ka, enforcePdfA as ki, removeBookmark as kn, calculateEanCheckDigit as kr, didYouMean as kt, extractFonts as l, PdfCaretAnnotation as la, generatePdfAXmpBytes as li, buildPieceInfo as ln, applyPreset as lr, decodeWoff as lt, rasterize as m, PdfCircleAnnotation as ma, extractXmpMetadata as mi, tableToCsv as mn, stripedPreset as mr, createWorkerPool as mt, RenderCache as n, saveIncrementalWithSignaturePreservation as na, downscaleImage as ni, SARIF_SCHEMA_URI as nn, toRoman as nr, validateFieldValue as nt, applyOcr as o, requestTimestamp as oa, applyRedaction as oi, PDF2_NAMESPACE as on, shrinkFontSize as or, parseAcrobatDate as ot, renderPageToCanvas as p, PdfStampAnnotation as pa, createAssociatedFile as pi, extractTables as pn, professionalPreset as pr, signDeferred as pt, isCertificateRevoked as q, detectModifications as qi, RemovePageFromEmptyDocumentError as qn, recompressWebP as qr, reconstructLines as qt, computeTileGrid as r, validateByteRangeIntegrity as ra, estimateJpegQuality as ri, toJsonReport as rn, applyOverflow as rr, AFSpecial_Format as rt, compareImages as s, searchTextItems as sa, enforcePdfAFull as si, buildNamespace as sn, truncateText as sr, AFNumber_Format as st, initWasm as t, parseExistingTrailer as ta, analyzeJpegMarkers as ti, DEFAULT_SARIF_TOOL_NAME as tn, toAlpha as tr, setFieldVisibility as tt, extractImages as u, PdfPopupAnnotation as ua, countOccurrences as ui, buildRequirement as un, applyTablePreset as ur, isWoff as ut, extractEmbeddedRevocationData as v, PdfSquareAnnotation as va, getSupportedLevels as vi, timestampPlugin as vn, readEan13 as vr, h as vt, buildCertificateChain as w, generateCircleAppearance as wa, buildOutputIntent as wi, batchMerge as wn, dataMatrixToOperators as wr, generateXRechnungCii as wt, validateCertificatePolicy as x, PdfStrikeOutAnnotation as xa, generateWinAnsiToUnicodeCmap as xi, enforcePdfUa as xn, renderStyledBarcode as xr, resolveFallback as xt, verifyOfflineRevocation as y, PdfHighlightAnnotation as ya, isValidLevel as yi, StreamingPdfParser as yn, readEan8 as yr, renderToPdf as yt, assembleTiles as z, buildDeviceNColorSpace as za, embedLtvData as zi, FontNotEmbeddedError as zn, code128ToOperators as zr, buildThresholdHalftone as zt };
+export { layoutColumns as $, generateInkAppearance as $a, detectTransparency as $i, getBookmarks as $n, encodeUpcA as $r, buildFunctionShading as $t, renderPageTile as A, buildTimestampRequest as Aa, optimizeImage as Ai, toSarif as An, ellipsisText as Ar, AFDate_FormatEx as At, rasterize as B, PdfCircleAnnotation as Ba, extractXmpMetadata as Bi, tableToCsv as Bn, stripedPreset as Br, createWorkerPool as Bt, buildUnencryptedWrapper as C, setCertificationLevel as Ca, embedTiffCmyk as Ci, buildCalGray as Cn, applyHeaderFooter as Cr, getFieldValue as Ct, registerEmbeddedFile as D, parseExistingTrailer as Da, analyzeJpegMarkers as Di, DEFAULT_SARIF_TOOL_NAME as Dn, toAlpha as Dr, setFieldVisibility as Dt, attachAssociatedFiles as E, findExistingSignatures as Ea, injectJpegMetadata as Ei, labToRgb as En, replaceTemplateVariables as Er, addVisibilityAction as Et, extractFonts as F, PdfCaretAnnotation as Fa, generatePdfAXmpBytes as Fi, buildPieceInfo as Fn, applyPreset as Fr, decodeWoff as Ft, verifyOfflineRevocation as G, PdfHighlightAnnotation as Ga, isValidLevel as Gi, StreamingPdfParser as Gn, readEan8 as Gr, renderToPdf as Gt, interpretContentStream as H, PdfPolyLineAnnotation as Ha, validateXmpMetadata as Hi, accessibilityPlugin as Hn, readCode128 as Hr, buildVtDpm as Ht, extractImages as I, PdfPopupAnnotation as Ia, countOccurrences as Ii, buildRequirement as In, applyTablePreset as Ir, isWoff as It, validateExtendedKeyUsage as J, PdfUnderlineAnnotation as Ja, generateZapfDingbatsToUnicodeCmap as Ji, validatePdfUa as Jn, encodePdf417 as Jr, splitByScript as Jt, EKU_OIDS as K, PdfSquigglyAnnotation as Ka, generateSymbolToUnicodeCmap as Ki, PdfDocumentBuilder as Kn, calculateBarcodeDimensions as Kr, createRangeFetcher as Kt, generateThumbnail as L, PdfRedactAnnotation as La, stripProhibitedFeatures as Li, buildRequirements as Ln, borderedPreset as Lr, isWoff2 as Lt, applyOcr as M, requestTimestamp as Ma, applyRedaction as Mi, PDF2_NAMESPACE as Mn, shrinkFontSize as Mr, parseAcrobatDate as Mt, compareImages as N, searchTextItems as Na, enforcePdfAFull as Ni, buildNamespace as Nn, truncateText as Nr, AFNumber_Format as Nt, RenderCache as O, saveIncrementalWithSignaturePreservation as Oa, downscaleImage as Oi, SARIF_SCHEMA_URI as On, toRoman as Or, validateFieldValue as Ot, comparePages as P, PdfFileAttachmentAnnotation as Pa, generatePdfAXmp as Pi, buildNamespacesArray as Pn, wrapText$2 as Pr, formatNumber$1 as Pt, findHyphenationPoints as Q, generateHighlightAppearance as Qa, generateSrgbIccProfile as Qi, addBookmark as Qn, calculateUpcCheckDigit as Qr, pdfA4Rules as Qt, renderDisplayListToCanvas as R, PdfInkAnnotation as Ra, buildAfArray as Ri, buildDPartRoot as Rn, minimalPreset as Rr, readWoffHeader as Rt, buildEncryptedPayload as S, getCertificationLevel as Sa, convertTiffCmykToRgb as Si, buildDocTimeStampDict as Sn, UnexpectedFieldTypeError as Sr, createSandbox as St, buildPageOutputIntent as T, appendIncrementalUpdate as Ta, extractJpegMetadata as Ti, buildLab as Tn, formatDate$1 as Tr, setFieldValue as Tt, interpretPage as U, PdfPolygonAnnotation as Ua, getProfile as Ui, metadataPlugin as Un, readCode39 as Ur, gtsPdfVtVersion as Ut, renderPageToImage as V, PdfLineAnnotation as Va, parseXmpMetadata as Vi, tableToJson as Vn, readBarcode as Vr, buildPdfVtDParts as Vt, extractEmbeddedRevocationData as W, PdfSquareAnnotation as Wa, getSupportedLevels as Wi, timestampPlugin as Wn, readEan13 as Wr, h as Wt, buildCertificateChain as X, generateCircleAppearance as Xa, buildOutputIntent as Xi, batchMerge as Xn, dataMatrixToOperators as Xr, generateXRechnungCii as Xt, validateKeyUsage as Y, PdfFreeTextAnnotation as Ya, getToUnicodeCmap as Yi, batchFlatten as Yn, pdf417ToOperators as Yr, generateOrderX as Yt, validateCertificateChain as Z, generateFreeTextAppearance as Za, SRGB_ICC_PROFILE as Zi, processBatch as Zn, encodeDataMatrix as Zr, buildPdfA4Xmp as Zt, buildColorKeyMask as _, buildFieldLockDict as _a, embedTiffDirect as _i, markdownToPdf as _n, NoSuchFieldError as _r, downloadCrl as _t, LIST_NUMBERING_KEY as a, isLinearized as aa, encodeEan8 as ai, buildBoxDict as an, PdfLinkAnnotation as ao, BatchProcessingError as ar, downscale16To8 as at, buildSoftMaskGroupExtGState as b, MdpPermission as ba, webpToJpeg as bi, reconstructParagraphs as bn, RichTextFieldReadError as br, checkCertificateStatus as bt, tagLink as c, findChangedObjects as ca, code39ToOperators as ci, validateBoxGeometry as cn, createXmpStream as co, ExceededMaxLengthError as cr, offsetSignedToUnsigned as ct, tagParagraph as d, embedLtvData as da, code128ToOperators as di, buildThresholdHalftone as dn, buildDeviceNColorSpace as do, FontNotEmbeddedError as dr, assembleTiles as dt, flattenTransparency as ea, upcAToOperators as ei, sampleShadingColor as en, generateLineAppearance as eo, removeAllBookmarks as er, layoutParagraph as et, tagTable as f, hasLtvData as fa, encodeCode128 as fi, buildType1Halftone as fn, buildSeparationColorSpace as fo, ForeignPageError as fr, decodeTile as ft, buildBlackPointCompensationExtGState as g, addFieldLock as ga, canDirectEmbed as gi, evaluateFunction as gn, MissingOnValueCheckError as gr, TrustStore as gt, tagTableRow as h, diffSignedContent as ha, PdfWorker as hi, nameHalftone as hn, saveIncremental as ho, InvalidPageSizeError as hr, verifySignatureDetailed as ht, validatePdfUa2 as i, getLinearizationInfo as ia, encodeEan13 as ii, generateCiiXml as in, generateUnderlineAppearance as io, flattenForm as ir, validatePdfX as it, redactRegions as j, parseTimestampResponse as ja, recompressImage as ji, MATHML_NAMESPACE as jn, estimateTextWidth as jr, formatDate as jt, computeTileGrid as k, validateByteRangeIntegrity as ka, estimateJpegQuality as ki, toJsonReport as kn, applyOverflow as kr, AFSpecial_Format as kt, tagList as l, optimizeIncrementalSave as la, computeCode39CheckDigit as li, STANDARD_SPOT_FUNCTIONS as ln, parseXmpMetadata$1 as lo, FieldAlreadyExistsError as lr, summarizeBitDepth as lt, tagTableHeaderCell as m, getCounterSignatures as ma, valuesToModules as mi, identityTransferFunction as mn, saveDocumentIncremental as mo, InvalidFieldNamePartError as mr, parseTileInfo as mt, autoTagPage as n, validatePdfA as na, ean13ToOperators as ni, levenshtein as nn, generateSquigglyAppearance as no, flattenField as nr, buildPdfXOutputIntent as nt, tagFigure as o, linearizePdf as oa, encodeItf as oi, buildGtsPdfxVersion as on, PdfTextAnnotation as oo, CombedTextLayoutError as or, getComponentDepths as ot, tagTableDataCell as p, addCounterSignature as pa, encodeCode128Values as pi, buildType5Halftone as pn, ChangeTracker as po, InvalidColorError as pr, decodeTileRegion as pt, validateCertificatePolicy as q, PdfStrikeOutAnnotation as qa, generateWinAnsiToUnicodeCmap as qi, enforcePdfUa as qn, renderStyledBarcode as qr, resolveFallback as qt, buildPdfUa2Xmp as r, delinearizePdf as ra, ean8ToOperators as ri, renderCodeFrame as rn, generateStrikeOutAppearance as ro, flattenFields as rr, enforcePdfX as rt, tagHeading as s, computeObjectHash as sa, itfToOperators as si, buildPdfX6OutputIntent as sn, buildXmpMetadata as so, EncryptedPdfError as sr, normalizeComponentDepth as st, initWasm as t, enforcePdfA as ta, calculateEanCheckDigit as ti, didYouMean as tn, generateSquareAppearance as to, removeBookmark as tr, layoutTextFlow as tt, tagListItem as u, buildDssDictionary as ua, encodeCode39 as ui, buildSampledTransferFunction as un, PDFOperator as uo, FieldExistsAsNonTerminalError as ur, upscale8To16 as ut, buildImageSoftMask as v, getFieldLocks as va, encodePngFromPixels as vi, buildCollection as vn, PluginError as vr, extractCrlUrls as vt, attachOutputIntents as w, validateSignatureChain as wa, isCmykTiff as wi, buildCalRGB as wn, applyHeaderFooterToPage as wr, resolveFieldReference as wt, buildSoftMaskNone as x, buildDocMdpReference as xa, webpToPng as xi, DEFAULT_DOC_TIMESTAMP_CONTENTS_SIZE as xn, StreamingParseError as xr, extractOcspUrl as xt, buildStencilMask as y, detectModifications as ya, recompressWebP as yi, reconstructLines as yn, RemovePageFromEmptyDocumentError as yr, isCertificateRevoked as yt, renderPageToCanvas as z, PdfStampAnnotation as za, createAssociatedFile as zi, extractTables as zn, professionalPreset as zr, signDeferred as zt };
 
-//# sourceMappingURL=src-Ci9ZjqhP.mjs.map
+//# sourceMappingURL=src-B7SQNDvy.mjs.map