modern-pdf-lib 0.29.0 → 0.31.0

package/dist/{src-DQ63jYIR.cjs → src-VeeIdf7B.cjs}

@@ -1,4 +1,4 @@
-const require_pdfDocument = require("./pdfDocument-BaQlOkYr.cjs");
+const require_pdfDocument = require("./pdfDocument-Bh4ebDqE.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-BaQlOkYr.cjs")).then((n) => n.pdfCatalog_exports);
+	const { buildDocumentStructure } = await Promise.resolve().then(() => require("./pdfDocument-Bh4ebDqE.cjs")).then((n) => n.pdfCatalog_exports);
 	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 require_pdfObjects.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 require_pdfObjects.PdfDict ? namesEntry : new require_pdfObjects.PdfDict();
+	if (namesDict !== namesEntry) catalog.set("/Names", namesDict);
+	const efEntry = namesDict.get("/EmbeddedFiles");
+	const efDict = efEntry instanceof require_pdfObjects.PdfDict ? efEntry : new require_pdfObjects.PdfDict();
+	if (efDict !== efEntry) namesDict.set("/EmbeddedFiles", efDict);
+	const leafEntry = efDict.get("/Names");
+	const leaf = leafEntry instanceof require_pdfObjects.PdfArray ? leafEntry : new require_pdfObjects.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 require_pdfObjects.PdfString ? entry.value : "") > name) {
+			insertAt = i;
+			break;
+		}
+	}
+	items.splice(insertAt, 0, require_pdfObjects.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 require_pdfObjects.PdfArray ? existing : new require_pdfObjects.PdfArray();
+	for (const ref of intentRefs) array.push(ref);
+	if (!(existing instanceof require_pdfObjects.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", require_pdfObjects.PdfName.of("OutputIntent"));
+		if (options.outputConditionIdentifier !== void 0) intentDict.set("/OutputConditionIdentifier", require_pdfObjects.PdfString.literal(options.outputConditionIdentifier));
+		if (options.info !== void 0) intentDict.set("/Info", require_pdfObjects.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 require_pdfObjects.PdfDict();
+	dict.set("/Type", require_pdfObjects.PdfName.of("EncryptedPayload"));
+	dict.set("/Subtype", require_pdfObjects.PdfName.of(options.subtype));
+	if (options.version !== void 0) dict.set("/Version", require_pdfObjects.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 require_pdfObjects.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 require_pdfObjects.PdfDict();
+	smask.set("/Type", require_pdfObjects.PdfName.of("Mask"));
+	smask.set("/S", require_pdfObjects.PdfName.of(subtype));
+	smask.set("/G", options.groupXObject);
+	if (subtype === "Luminosity" && options.backdropColor !== void 0 && options.backdropColor.length > 0) smask.set("/BC", require_pdfObjects.PdfArray.fromNumbers([...options.backdropColor]));
+	if (options.transferFunction !== void 0) smask.set("/TR", options.transferFunction === "Identity" ? require_pdfObjects.PdfName.of("Identity") : options.transferFunction);
+	const extGState = new require_pdfObjects.PdfDict();
+	extGState.set("/Type", require_pdfObjects.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 require_pdfObjects.PdfDict();
+	extGState.set("/Type", require_pdfObjects.PdfName.of("ExtGState"));
+	extGState.set("/SMask", require_pdfObjects.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 require_pdfObjects.PdfDict();
+	dict.set("/Type", require_pdfObjects.PdfName.of("XObject"));
+	dict.set("/Subtype", require_pdfObjects.PdfName.of("Image"));
+	dict.set("/ImageMask", require_pdfObjects.PdfBool.TRUE);
+	dict.set("/BitsPerComponent", require_pdfObjects.PdfNumber.of(1));
+	dict.set("/Width", require_pdfObjects.PdfNumber.of(width));
+	dict.set("/Height", require_pdfObjects.PdfNumber.of(height));
+	if (decode !== void 0) dict.set("/Decode", require_pdfObjects.PdfArray.fromNumbers([decode[0], decode[1]]));
+	dict.set("/Length", require_pdfObjects.PdfNumber.of(bits.length));
+	return registry.register(new require_pdfObjects.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 require_pdfObjects.PdfArray(ranges.map((v) => require_pdfObjects.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 require_pdfObjects.PdfDict();
+	dict.set("/Type", require_pdfObjects.PdfName.of("XObject"));
+	dict.set("/Subtype", require_pdfObjects.PdfName.of("Image"));
+	dict.set("/Width", require_pdfObjects.PdfNumber.of(width));
+	dict.set("/Height", require_pdfObjects.PdfNumber.of(height));
+	dict.set("/ColorSpace", require_pdfObjects.PdfName.of("DeviceGray"));
+	dict.set("/BitsPerComponent", require_pdfObjects.PdfNumber.of(bitsPerComponent ?? 8));
+	dict.set("/Length", require_pdfObjects.PdfNumber.of(gray.length));
+	return registry.register(new require_pdfObjects.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 require_pdfObjects.PdfDict();
+	gs.set("/Type", require_pdfObjects.PdfName.of("ExtGState"));
+	gs.set("/UseBlackPtComp", require_pdfObjects.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 Promise.resolve().then(() => require("./pdfDocument-BaQlOkYr.cjs")).then((n) => n.libdeflateWasm_exports);
+		const { initDeflateWasm } = await Promise.resolve().then(() => require("./pdfDocument-Bh4ebDqE.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-BaQlOkYr.cjs")).then((n) => n.pngEmbed_exports);
+		const { initPngWasm } = await Promise.resolve().then(() => require("./pdfDocument-Bh4ebDqE.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-BaQlOkYr.cjs")).then((n) => n.fontSubset_exports);
+		const { initSubsetWasm } = await Promise.resolve().then(() => require("./pdfDocument-Bh4ebDqE.cjs")).then((n) => n.fontSubset_exports);
 		await initSubsetWasm(options.fontWasm);
 	})());
 	if (options.jpeg || options.jpegWasm) inits.push((async () => {
@@ -30099,6 +31094,12 @@ Object.defineProperty(exports, "InvalidPageSizeError", {
 		return InvalidPageSizeError;
 	}
 });
+Object.defineProperty(exports, "LIST_NUMBERING_KEY", {
+	enumerable: true,
+	get: function() {
+		return LIST_NUMBERING_KEY;
+	}
+});
 Object.defineProperty(exports, "MATHML_NAMESPACE", {
 	enumerable: true,
 	get: function() {
@@ -30411,6 +31412,24 @@ Object.defineProperty(exports, "assembleTiles", {
 		return assembleTiles;
 	}
 });
+Object.defineProperty(exports, "attachAssociatedFiles", {
+	enumerable: true,
+	get: function() {
+		return attachAssociatedFiles;
+	}
+});
+Object.defineProperty(exports, "attachOutputIntents", {
+	enumerable: true,
+	get: function() {
+		return attachOutputIntents;
+	}
+});
+Object.defineProperty(exports, "autoTagPage", {
+	enumerable: true,
+	get: function() {
+		return autoTagPage;
+	}
+});
 Object.defineProperty(exports, "batchFlatten", {
 	enumerable: true,
 	get: function() {
@@ -30435,6 +31454,12 @@ Object.defineProperty(exports, "buildAfArray", {
 		return buildAfArray;
 	}
 });
+Object.defineProperty(exports, "buildBlackPointCompensationExtGState", {
+	enumerable: true,
+	get: function() {
+		return buildBlackPointCompensationExtGState;
+	}
+});
 Object.defineProperty(exports, "buildBoxDict", {
 	enumerable: true,
 	get: function() {
@@ -30465,6 +31490,12 @@ Object.defineProperty(exports, "buildCollection", {
 		return buildCollection;
 	}
 });
+Object.defineProperty(exports, "buildColorKeyMask", {
+	enumerable: true,
+	get: function() {
+		return buildColorKeyMask;
+	}
+});
 Object.defineProperty(exports, "buildDPartRoot", {
 	enumerable: true,
 	get: function() {
@@ -30495,6 +31526,12 @@ Object.defineProperty(exports, "buildDssDictionary", {
 		return buildDssDictionary;
 	}
 });
+Object.defineProperty(exports, "buildEncryptedPayload", {
+	enumerable: true,
+	get: function() {
+		return buildEncryptedPayload;
+	}
+});
 Object.defineProperty(exports, "buildFieldLockDict", {
 	enumerable: true,
 	get: function() {
@@ -30513,6 +31550,12 @@ Object.defineProperty(exports, "buildGtsPdfxVersion", {
 		return buildGtsPdfxVersion;
 	}
 });
+Object.defineProperty(exports, "buildImageSoftMask", {
+	enumerable: true,
+	get: function() {
+		return buildImageSoftMask;
+	}
+});
 Object.defineProperty(exports, "buildLab", {
 	enumerable: true,
 	get: function() {
@@ -30537,12 +31580,24 @@ Object.defineProperty(exports, "buildOutputIntent", {
 		return buildOutputIntent;
 	}
 });
+Object.defineProperty(exports, "buildPageOutputIntent", {
+	enumerable: true,
+	get: function() {
+		return buildPageOutputIntent;
+	}
+});
 Object.defineProperty(exports, "buildPdfA4Xmp", {
 	enumerable: true,
 	get: function() {
 		return buildPdfA4Xmp;
 	}
 });
+Object.defineProperty(exports, "buildPdfUa2Xmp", {
+	enumerable: true,
+	get: function() {
+		return buildPdfUa2Xmp;
+	}
+});
 Object.defineProperty(exports, "buildPdfVtDParts", {
 	enumerable: true,
 	get: function() {
@@ -30591,6 +31646,24 @@ Object.defineProperty(exports, "buildSeparationColorSpace", {
 		return buildSeparationColorSpace;
 	}
 });
+Object.defineProperty(exports, "buildSoftMaskGroupExtGState", {
+	enumerable: true,
+	get: function() {
+		return buildSoftMaskGroupExtGState;
+	}
+});
+Object.defineProperty(exports, "buildSoftMaskNone", {
+	enumerable: true,
+	get: function() {
+		return buildSoftMaskNone;
+	}
+});
+Object.defineProperty(exports, "buildStencilMask", {
+	enumerable: true,
+	get: function() {
+		return buildStencilMask;
+	}
+});
 Object.defineProperty(exports, "buildThresholdHalftone", {
 	enumerable: true,
 	get: function() {
@@ -30615,6 +31688,12 @@ Object.defineProperty(exports, "buildType5Halftone", {
 		return buildType5Halftone;
 	}
 });
+Object.defineProperty(exports, "buildUnencryptedWrapper", {
+	enumerable: true,
+	get: function() {
+		return buildUnencryptedWrapper;
+	}
+});
 Object.defineProperty(exports, "buildVtDpm", {
 	enumerable: true,
 	get: function() {
@@ -31539,6 +32618,12 @@ Object.defineProperty(exports, "redactRegions", {
 		return redactRegions;
 	}
 });
+Object.defineProperty(exports, "registerEmbeddedFile", {
+	enumerable: true,
+	get: function() {
+		return registerEmbeddedFile;
+	}
+});
 Object.defineProperty(exports, "removeAllBookmarks", {
 	enumerable: true,
 	get: function() {
@@ -31713,6 +32798,66 @@ Object.defineProperty(exports, "tableToJson", {
 		return tableToJson;
 	}
 });
+Object.defineProperty(exports, "tagFigure", {
+	enumerable: true,
+	get: function() {
+		return tagFigure;
+	}
+});
+Object.defineProperty(exports, "tagHeading", {
+	enumerable: true,
+	get: function() {
+		return tagHeading;
+	}
+});
+Object.defineProperty(exports, "tagLink", {
+	enumerable: true,
+	get: function() {
+		return tagLink;
+	}
+});
+Object.defineProperty(exports, "tagList", {
+	enumerable: true,
+	get: function() {
+		return tagList;
+	}
+});
+Object.defineProperty(exports, "tagListItem", {
+	enumerable: true,
+	get: function() {
+		return tagListItem;
+	}
+});
+Object.defineProperty(exports, "tagParagraph", {
+	enumerable: true,
+	get: function() {
+		return tagParagraph;
+	}
+});
+Object.defineProperty(exports, "tagTable", {
+	enumerable: true,
+	get: function() {
+		return tagTable;
+	}
+});
+Object.defineProperty(exports, "tagTableDataCell", {
+	enumerable: true,
+	get: function() {
+		return tagTableDataCell;
+	}
+});
+Object.defineProperty(exports, "tagTableHeaderCell", {
+	enumerable: true,
+	get: function() {
+		return tagTableHeaderCell;
+	}
+});
+Object.defineProperty(exports, "tagTableRow", {
+	enumerable: true,
+	get: function() {
+		return tagTableRow;
+	}
+});
 Object.defineProperty(exports, "timestampPlugin", {
 	enumerable: true,
 	get: function() {
@@ -31815,6 +32960,12 @@ Object.defineProperty(exports, "validatePdfUa", {
 		return validatePdfUa;
 	}
 });
+Object.defineProperty(exports, "validatePdfUa2", {
+	enumerable: true,
+	get: function() {
+		return validatePdfUa2;
+	}
+});
 Object.defineProperty(exports, "validatePdfX", {
 	enumerable: true,
 	get: function() {
@@ -31870,4 +33021,4 @@ Object.defineProperty(exports, "wrapText", {
 	}
 });
 
-//# sourceMappingURL=src-DQ63jYIR.cjs.map
+//# sourceMappingURL=src-VeeIdf7B.cjs.map