modern-pdf-lib 0.38.0 → 0.40.0

package/dist/{src-DlRTrvWg.mjs → src-wZnfMPwi.mjs}

@@ -1,4 +1,4 @@
-import { $r as beginText, A as encodeUTCTime, C as encodeInteger, Dn as formatPdfDate, E as encodeOctetString, F as parseDerTlv, Gr as rectangle, Gt as PageSizes, I as toBuffer, Kn as saveState, Kr as setDashPattern, M as extractIssuerAndSerial, N as extractSubjectPublicKeyInfo, O as encodeSequence, P as getSubtle, Qn as applyStrokeColor, Qr as stroke, S as encodeContextTag, T as encodeOID, Tn as buildInfoDict, Un as restoreState, Ur as lineTo, Ut as serializePdf, V as findSignatures, W as mergePdfs, Wr as moveTo, Xr as setLineWidth, Zn as applyFillColor, ai as setFont, b as detectKeyAlgorithm, bt as PdfLexer, di as setWordSpacing, ei as endText, er as cmykToRgb, fi as showText$1, k as encodeSet, n as StandardFonts, nt as loadPdf, r as createPdf, rt as PdfEncryptionHandler, s as setPageLabels, st as sha256, t as PdfDocument, ti as moveText, vt as XrefParser, x as detectNamedCurve, xn as buildAnnotationDict, xt as PdfParseError, y as decodeOidBytes, yn as PdfAnnotation, yt as PdfObjectParser, z as computeSignatureHash, zr as fill } from "./pdfDocument-Q0wrwKEZ.mjs";
+import { $r as beginText, A as encodeUTCTime, C as encodeInteger, Dn as formatPdfDate, E as encodeOctetString, F as parseDerTlv, Gr as rectangle, Gt as PageSizes, I as toBuffer, Kn as saveState, Kr as setDashPattern, M as extractIssuerAndSerial, N as extractSubjectPublicKeyInfo, O as encodeSequence, P as getSubtle, Qn as applyStrokeColor, Qr as stroke, S as encodeContextTag, T as encodeOID, Tn as buildInfoDict, Un as restoreState, Ur as lineTo, Ut as serializePdf, V as findSignatures, W as mergePdfs, Wr as moveTo, Xr as setLineWidth, Zn as applyFillColor, ai as setFont, b as detectKeyAlgorithm, bt as PdfLexer, cr as rgb, di as setWordSpacing, ei as endText, er as cmykToRgb, fi as showText$1, k as encodeSet, n as StandardFonts, nt as loadPdf, r as createPdf, rt as PdfEncryptionHandler, s as setPageLabels, st as sha256, t as PdfDocument, ti as moveText, vt as XrefParser, x as detectNamedCurve, xn as buildAnnotationDict, xt as PdfParseError, y as decodeOidBytes, yn as PdfAnnotation, yt as PdfObjectParser, z as computeSignatureHash, zr as fill } from "./pdfDocument-Q0wrwKEZ.mjs";
 import { c as PdfRef, i as PdfName, l as PdfStream, n as PdfBool, o as PdfNumber, r as PdfDict, s as PdfObjectRegistry, t as PdfArray, u as PdfString } from "./pdfObjects-CB7TEdbW.mjs";
 import { n as decodeStreamData, r as getStreamFilters } from "./streamDecode-DCpgTocN.mjs";
 import { g as FieldFlags, v as numVal } from "./pdfForm-CfLnlsj-.mjs";
@@ -13223,7 +13223,7 @@ const DEFAULT_HEIGHT = 50;
 const DEFAULT_MODULE_WIDTH = 1;
 const DEFAULT_QUIET_ZONE = 10;
 const DEFAULT_FONT_NAME = "Helvetica";
-const DEFAULT_FONT_SIZE$2 = 10;
+const DEFAULT_FONT_SIZE$3 = 10;
 const DEFAULT_BORDER_WIDTH = .5;
 const DEFAULT_PADDING = 4;
 const DEFAULT_BAR_COLOR = {
@@ -13254,7 +13254,7 @@ function calculateBarcodeDimensions(matrix, options) {
 	const height = options?.height ?? DEFAULT_HEIGHT;
 	const padding = options?.padding ?? (options?.border ? DEFAULT_PADDING : 0);
 	const borderW = options?.border ? options.borderWidth ?? DEFAULT_BORDER_WIDTH : 0;
-	const textHeight = options?.showText ? (options.fontSize ?? DEFAULT_FONT_SIZE$2) + 4 : 0;
+	const textHeight = options?.showText ? (options.fontSize ?? DEFAULT_FONT_SIZE$3) + 4 : 0;
 	return {
 		width: (matrix.width + quietZone * 2) * moduleWidth + padding * 2 + borderW * 2,
 		height: height + textHeight + padding * 2 + borderW * 2
@@ -13284,7 +13284,7 @@ function renderStyledBarcode(matrix, x, y, text, options) {
 	const bgColor = options?.backgroundColor ?? DEFAULT_BG_COLOR;
 	const showTextBelow = options?.showText ?? false;
 	const fontName = options?.fontName ?? DEFAULT_FONT_NAME;
-	const fontSize = options?.fontSize ?? DEFAULT_FONT_SIZE$2;
+	const fontSize = options?.fontSize ?? DEFAULT_FONT_SIZE$3;
 	const textColor = options?.textColor ?? barColor;
 	const hasBorder = options?.border ?? false;
 	const borderWidth = options?.borderWidth ?? DEFAULT_BORDER_WIDTH;
@@ -15530,7 +15530,7 @@ const DEFAULT_MARGINS = {
 	left: 50,
 	right: 50
 };
-const DEFAULT_FONT_SIZE$1 = 10;
+const DEFAULT_FONT_SIZE$2 = 10;
 const DEFAULT_DATE_FORMAT = "YYYY-MM-DD";
 /** Convert an integer to a lowercase Roman numeral string. */
 function toRoman(num) {
@@ -15618,7 +15618,7 @@ function applyHeaderFooterToPage(page, options, pageNumber, totalPages, title) {
 	if (options.header && options.header.length > 0) {
 		const headerY = pageHeight - margins.top;
 		for (const item of options.header) {
-			const fontSize = item.fontSize ?? DEFAULT_FONT_SIZE$1;
+			const fontSize = item.fontSize ?? DEFAULT_FONT_SIZE$2;
 			const resolvedText = replaceTemplateVariables(item.text, pageNumber, totalPages, now, dateFormat, effectiveTitle);
 			const textWidth = estimateWidth(resolvedText, item.font, fontSize);
 			let x;
@@ -15634,7 +15634,7 @@ function applyHeaderFooterToPage(page, options, pageNumber, totalPages, title) {
 			});
 		}
 		if (options.separatorLine) {
-			const lineY = headerY - (options.header[0]?.fontSize ?? DEFAULT_FONT_SIZE$1) - 4;
+			const lineY = headerY - (options.header[0]?.fontSize ?? DEFAULT_FONT_SIZE$2) - 4;
 			page.drawLine({
 				start: {
 					x: margins.left,
@@ -15653,7 +15653,7 @@ function applyHeaderFooterToPage(page, options, pageNumber, totalPages, title) {
 	if (options.footer && options.footer.length > 0) {
 		const footerY = margins.bottom;
 		for (const item of options.footer) {
-			const fontSize = item.fontSize ?? DEFAULT_FONT_SIZE$1;
+			const fontSize = item.fontSize ?? DEFAULT_FONT_SIZE$2;
 			const resolvedText = replaceTemplateVariables(item.text, pageNumber, totalPages, now, dateFormat, effectiveTitle);
 			const textWidth = estimateWidth(resolvedText, item.font, fontSize);
 			let x;
@@ -15669,7 +15669,7 @@ function applyHeaderFooterToPage(page, options, pageNumber, totalPages, title) {
 			});
 		}
 		if (options.separatorLine) {
-			const lineY = footerY + (options.footer[0]?.fontSize ?? DEFAULT_FONT_SIZE$1) + 4;
+			const lineY = footerY + (options.footer[0]?.fontSize ?? DEFAULT_FONT_SIZE$2) + 4;
 			page.drawLine({
 				start: {
 					x: margins.left,
@@ -21869,7 +21869,7 @@ function createRangeFetcher(url, options) {
 * @param children  Child nodes for `document` / `page` containers.
 * @returns         A frozen-shaped {@link VNode}.
 */
-function h(type, props, ...children) {
+function h$1(type, props, ...children) {
 	switch (type) {
 		case "document": return {
 			type: "document",
@@ -21905,7 +21905,7 @@ function asText(value) {
 	return typeof value === "string" ? value : "";
 }
 /** Internal layout constants. */
-const DEFAULT_FONT_SIZE = 12;
+const DEFAULT_FONT_SIZE$1 = 12;
 const DEFAULT_MARGIN = 50;
 const LINE_SPACING = 1.35;
 const HEADING_SCALE = [
@@ -21927,13 +21927,13 @@ const HEADING_SCALE = [
 * @param options  Optional layout overrides.
 * @returns        A promise resolving to the saved PDF bytes (starting `%PDF-`).
 */
-async function renderToPdf(root, options) {
-	const fontSize = options?.fontSize ?? DEFAULT_FONT_SIZE;
+async function renderToPdf$1(root, options) {
+	const fontSize = options?.fontSize ?? DEFAULT_FONT_SIZE$1;
 	const margin = options?.margin ?? DEFAULT_MARGIN;
 	const doc = createPdf();
 	const body = await doc.embedFont(StandardFonts.Helvetica);
 	const bold = await doc.embedFont(StandardFonts.HelveticaBold);
-	for (const pageNode of collectPages(root)) renderPage(doc, body, bold, pageNode, fontSize, margin);
+	for (const pageNode of collectPages$1(root)) renderPage(doc, body, bold, pageNode, fontSize, margin);
 	return doc.save();
 }
 /**
@@ -21943,7 +21943,7 @@ async function renderToPdf(root, options) {
 * are gathered into a synthesized `page`.  A non-`document` root is
 * itself treated as a page (wrapping a leaf if necessary).
 */
-function collectPages(root) {
+function collectPages$1(root) {
 	if (root.type === "document") {
 		const pages = [];
 		const loose = [];
@@ -32167,6 +32167,1856 @@ function feBlend(a, b, mode) {
 	return out;
 }
 //#endregion
+//#region src/runtime/sharedConcurrency.ts
+/**
+* @module runtime/sharedConcurrency
+*
+* `SharedArrayBuffer` + `Atomics` concurrency primitives for coordinating
+* work across Web Workers / `worker_threads`. These are thin, correctness
+* focused wrappers around the standard atomic operations — they add no
+* acceleration of their own and make no use of SIMD or any other hardware
+* feature. They simply expose race-free counters, flags, and a byte ring
+* so multiple agents can share state through a single `SharedArrayBuffer`.
+*
+* Availability caveats (feature-detected, never assumed):
+*
+* - `SharedArrayBuffer` and `Atomics` must both exist. In browsers, shared
+*   memory additionally requires the page to be *cross-origin isolated*
+*   (COOP+COEP headers); we treat `crossOriginIsolated === false` as
+*   "unavailable". See {@link isSharedMemoryAvailable}.
+* - `Atomics.wait` is only permitted on a non-main agent (it throws on the
+*   main browser thread and would deadlock the event loop everywhere). The
+*   {@link SharedFlag} `wait` method feature-detects this and degrades to a
+*   non-blocking poll rather than throwing — see its docs.
+*
+* All references below are to the ECMA-262 `Atomics` semantics and MDN:
+*
+* - `Atomics.add(ta, i, v)` atomically adds `v` and returns the **previous**
+*   value at index `i` (the value before the addition).
+* - `Atomics.compareExchange(ta, i, expected, replacement)` writes
+*   `replacement` iff the current value equals `expected`, and returns the
+*   value that was at index `i` **before** the call (so success is detected
+*   by `result === expected`).
+* - `Atomics.notify(ta, i, count)` wakes up to `count` agents blocked in
+*   `Atomics.wait` on index `i` and returns the number actually woken (0 if
+*   none are waiting). It is safe to call from any thread, including the
+*   main thread.
+* - `Atomics.wait(ta, i, value, timeout)` blocks while the slot equals
+*   `value`, returning `'ok'`, `'timed-out'`, or `'not-equal'`.
+*/
+/**
+* Bytes per `Int32Array` element. Atomics operate on 32-bit integer views.
+*/
+const INT32_BYTES = 4;
+/**
+* Reference to the global `SharedArrayBuffer` constructor, or `undefined`
+* when the runtime does not provide one. Captured via `globalThis` so the
+* module loads without a `ReferenceError` on platforms that omit it.
+*/
+const SharedArrayBufferCtor = globalThis.SharedArrayBuffer;
+/**
+* Allocate a fresh zero-initialised `SharedArrayBuffer` of `byteLength`
+* bytes, throwing a clear error if shared memory is not available.
+*/
+function allocShared(byteLength) {
+	if (SharedArrayBufferCtor === void 0) throw new Error("sharedConcurrency: SharedArrayBuffer is not available in this runtime. Call isSharedMemoryAvailable() before constructing these primitives.");
+	return new SharedArrayBufferCtor(byteLength);
+}
+/**
+* Report whether shared-memory concurrency is usable in this runtime.
+*
+* Returns `true` only when **both** `SharedArrayBuffer` and `Atomics`
+* exist, and — in a browser context that exposes `crossOriginIsolated` —
+* that flag is not `false`. The check is fully defensive: it performs only
+* `typeof` probes and never throws, so it is safe to call as a guard before
+* touching any other export here.
+*
+* Note: `crossOriginIsolated` is only consulted when it is a boolean. On
+* Node / Deno / Bun / Workers (where it is typically `undefined`) we do not
+* treat its absence as a failure, since those runtimes allow shared memory
+* without the browser's COOP/COEP isolation requirement.
+*
+* @returns `true` iff shared-memory primitives can be constructed and used.
+*/
+function isSharedMemoryAvailable() {
+	try {
+		if (typeof SharedArrayBuffer === "undefined") return false;
+		if (typeof Atomics === "undefined") return false;
+		if (globalThis.crossOriginIsolated === false) return false;
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* An atomic 32-bit integer counter backed by a single slot of an
+* `Int32Array` view over a `SharedArrayBuffer`. Multiple `SharedCounter`
+* instances constructed over the **same** buffer and index observe each
+* other's writes, so the counter can be shared across workers by passing
+* its {@link SharedCounter.buffer} through `postMessage`.
+*
+* All mutations use `Atomics`, so increments from concurrent agents never
+* lose updates.
+*/
+var SharedCounter = class {
+	/** Int32 view over the backing buffer. */
+	#view;
+	/** Element index of this counter's slot within {@link #view}. */
+	#index;
+	/** The `SharedArrayBuffer` backing this counter. */
+	buffer;
+	/**
+	* @param buffer - Existing shared buffer to attach to. When omitted, a
+	*                 fresh single-slot (`4`-byte) `SharedArrayBuffer` is
+	*                 allocated and zero-initialised.
+	* @param index  - Element index (in `Int32` units) of the counter slot.
+	*                 Defaults to `0`. Must be a non-negative integer that
+	*                 fits within `buffer`.
+	* @throws If shared memory is unavailable (when allocating), or if
+	*         `index` is out of range for the supplied `buffer`.
+	*/
+	constructor(buffer, index) {
+		const slot = index ?? 0;
+		if (!Number.isInteger(slot) || slot < 0) throw new Error(`SharedCounter: index must be a non-negative integer, received ${slot}`);
+		const buf = buffer ?? allocShared(INT32_BYTES);
+		if ((slot + 1) * INT32_BYTES > buf.byteLength) throw new Error(`SharedCounter: index ${slot} is out of range for a ${buf.byteLength}-byte buffer`);
+		this.buffer = buf;
+		this.#view = new Int32Array(buf);
+		this.#index = slot;
+	}
+	/**
+	* The current counter value, read atomically via `Atomics.load`.
+	*/
+	get value() {
+		return Atomics.load(this.#view, this.#index);
+	}
+	/**
+	* Atomically add `n` to the counter.
+	*
+	* Per `Atomics.add` semantics this returns the **previous** value — the
+	* value the slot held *before* `n` was added — not the new total. Read
+	* {@link SharedCounter.value} afterwards for the updated total.
+	*
+	* @param n - Integer addend (may be negative to subtract).
+	* @returns The value that was stored before the addition.
+	*/
+	add(n) {
+		return Atomics.add(this.#view, this.#index, n | 0);
+	}
+	/**
+	* Atomically increment the counter by one.
+	*
+	* As with {@link SharedCounter.add}, the returned number is the
+	* **pre-increment** value.
+	*
+	* @returns The value that was stored before incrementing.
+	*/
+	increment() {
+		return Atomics.add(this.#view, this.#index, 1);
+	}
+	/**
+	* Atomically set the counter to `next` iff it currently equals
+	* `expected`, via `Atomics.compareExchange`.
+	*
+	* @param expected - The value the swap is conditional on.
+	* @param next     - The value to store when `expected` matches.
+	* @returns The value that was at the slot **before** the call. The swap
+	*          succeeded iff this equals `expected`.
+	*/
+	compareExchange(expected, next) {
+		return Atomics.compareExchange(this.#view, this.#index, expected | 0, next | 0);
+	}
+};
+/** Slot value meaning "flag is clear / unset". */
+const FLAG_UNSET = 0;
+/** Slot value meaning "flag is set". */
+const FLAG_SET = 1;
+/**
+* A one-bit synchronisation gate over a single `Int32Array` slot
+* (`0` = unset, `1` = set), supporting `Atomics.wait` / `Atomics.notify`.
+*
+* Producers call {@link SharedFlag.set} then {@link SharedFlag.notify} to
+* release agents blocked in {@link SharedFlag.wait}.
+*
+* IMPORTANT — `Atomics.wait` may only block on a *non-main* agent. On the
+* main browser thread it throws `TypeError`, and on any main thread it
+* would freeze the event loop. {@link SharedFlag.wait} feature-detects
+* blocking support and, when blocking is not permitted, degrades to a
+* single non-blocking check (returning `'ok'` if already set, otherwise
+* `'not-equal'`) instead of throwing. {@link SharedFlag.notify} is always
+* safe to call from any thread.
+*/
+var SharedFlag = class {
+	/** Int32 view over the backing buffer; the flag lives at index 0. */
+	#view;
+	/** The `SharedArrayBuffer` backing this flag. */
+	buffer;
+	/**
+	* @param buffer - Existing shared buffer to attach to (its first `Int32`
+	*                 slot is used). When omitted, a fresh `4`-byte
+	*                 `SharedArrayBuffer` is allocated, starting cleared.
+	* @throws If shared memory is unavailable when allocating, or `buffer`
+	*         is too small to hold one `Int32`.
+	*/
+	constructor(buffer) {
+		const buf = buffer ?? allocShared(INT32_BYTES);
+		if (buf.byteLength < INT32_BYTES) throw new Error(`SharedFlag: buffer must be at least ${INT32_BYTES} bytes, got ${buf.byteLength}`);
+		this.buffer = buf;
+		this.#view = new Int32Array(buf);
+	}
+	/**
+	* Atomically set the flag. Does not itself wake waiters — call
+	* {@link SharedFlag.notify} afterwards to release any blocked agents.
+	*/
+	set() {
+		Atomics.store(this.#view, 0, FLAG_SET);
+	}
+	/**
+	* Atomically clear the flag back to its unset state.
+	*/
+	clear() {
+		Atomics.store(this.#view, 0, FLAG_UNSET);
+	}
+	/**
+	* @returns `true` iff the flag is currently set, read via `Atomics.load`.
+	*/
+	isSet() {
+		return Atomics.load(this.#view, 0) === FLAG_SET;
+	}
+	/**
+	* Block until the flag becomes set, or until `timeoutMs` elapses.
+	*
+	* Implemented with `Atomics.wait` on the unset value: while the slot
+	* still reads `0` (unset) the agent sleeps; a {@link SharedFlag.set} +
+	* {@link SharedFlag.notify} from another agent wakes it.
+	*
+	* Blocking is only legal off the main thread. When `Atomics.wait` is not
+	* allowed here (e.g. the main browser thread), this method does **not**
+	* throw: it performs a single non-blocking check and returns `'ok'` if
+	* the flag is already set, or `'not-equal'` otherwise. Callers that need
+	* to truly block must run on a dedicated worker.
+	*
+	* @param timeoutMs - Optional timeout in milliseconds. Omit (or pass
+	*                    `Infinity`) to wait indefinitely.
+	* @returns `'ok'` when woken with the flag still unset at entry,
+	*          `'timed-out'` if the timeout expired, or `'not-equal'` if the
+	*          flag was already set on entry (nothing to wait for).
+	*/
+	wait(timeoutMs) {
+		if (Atomics.load(this.#view, 0) === FLAG_SET) return "not-equal";
+		if (typeof Atomics.wait !== "function") return Atomics.load(this.#view, 0) === FLAG_SET ? "ok" : "not-equal";
+		try {
+			const timeout = timeoutMs ?? Infinity;
+			return Atomics.wait(this.#view, 0, FLAG_UNSET, timeout);
+		} catch {
+			return Atomics.load(this.#view, 0) === FLAG_SET ? "ok" : "not-equal";
+		}
+	}
+	/**
+	* Wake up to `count` agents blocked in {@link SharedFlag.wait} on this
+	* flag, via `Atomics.notify`. Safe to call from any thread.
+	*
+	* @param count - Maximum number of waiters to wake. Defaults to
+	*                `Infinity` (wake all).
+	* @returns The number of agents actually woken — `0` when none were
+	*          waiting.
+	*/
+	notify(count) {
+		return Atomics.notify(this.#view, 0, count ?? Infinity);
+	}
+};
+/**
+* Control-region layout, in `Int32` slots, preceding the data region:
+*
+* - slot 0 (`HEAD_SLOT`): read cursor — byte offset into the data region of
+*   the next frame to be popped by the (single) consumer.
+* - slot 1 (`TAIL_SLOT`): write cursor — byte offset into the data region
+*   at which the next frame will be pushed by the (single) producer.
+*
+* Both cursors range over `[0, dataBytes)` and wrap modulo the data size.
+* The buffer is empty when `head === tail` and considered full when the
+* next write would catch up to `head` (one frame slot is kept free to
+* disambiguate the full/empty states).
+*/
+const HEAD_SLOT = 0;
+const TAIL_SLOT = 1;
+/** Number of Int32 control slots ([head, tail]) ahead of the data region. */
+const CONTROL_SLOTS = 2;
+/** Byte size of the control region. */
+const CONTROL_BYTES = CONTROL_SLOTS * INT32_BYTES;
+/** Bytes used by each frame's little-endian `uint32` length header. */
+const LENGTH_HEADER_BYTES = 4;
+/**
+* A lock-free **single-producer / single-consumer** (SPSC) byte ring buffer
+* over a `SharedArrayBuffer`, suitable for streaming chunks between exactly
+* one producing worker and one consuming worker.
+*
+* ## Contract
+*
+* - **SPSC only.** Correctness relies on there being at most one concurrent
+*   {@link SharedRingBuffer.push} caller (the producer) and at most one
+*   concurrent {@link SharedRingBuffer.pop} caller (the consumer). Multiple
+*   producers or multiple consumers are **not** supported and will corrupt
+*   the cursors. (The producer and consumer may be different agents.)
+* - {@link SharedRingBuffer.push} returns `false` (writing nothing) when the
+*   frame would not fit in the currently free space.
+* - {@link SharedRingBuffer.pop} returns `null` when the ring is empty, or
+*   when the next frame is larger than the caller's `maxBytes` budget (the
+*   frame is left intact for a later, larger pop).
+*
+* ## SAB layout
+*
+* `[ head:int32 | tail:int32 | ...dataBytes ]`
+*
+* The `head`/`tail` cursors are published with `Atomics.store` and read with
+* `Atomics.load`, which establishes the happens-before edge that makes the
+* non-atomic byte writes into the data region visible to the consumer. Each
+* frame is encoded as a 4-byte little-endian length header followed by that
+* many payload bytes; both header and payload wrap around the data region.
+*/
+var SharedRingBuffer = class SharedRingBuffer {
+	/** Int32 view over the control slots (head/tail). */
+	#control;
+	/** Byte view over the data region (excludes the control slots). */
+	#data;
+	/** Size, in bytes, of the data region. */
+	#size;
+	/** The `SharedArrayBuffer` backing this ring. */
+	buffer;
+	/**
+	* Allocate a new ring whose data region holds `capacityBytes` bytes
+	* (the backing `SharedArrayBuffer` is `capacityBytes` + control overhead).
+	*
+	* @param capacityBytes - Size of the data region in bytes. Must be a
+	*                        positive integer.
+	* @param existingBuffer - Internal: when supplied, the ring attaches to
+	*                        this already-allocated buffer instead of creating
+	*                        a fresh one (used by {@link SharedRingBuffer.fromBuffer}).
+	*                        Its data region must equal `capacityBytes`.
+	* @throws If `capacityBytes` is not a positive integer, or shared memory
+	*         is unavailable.
+	*/
+	constructor(capacityBytes, existingBuffer) {
+		if (!Number.isInteger(capacityBytes) || capacityBytes <= 0) throw new Error(`SharedRingBuffer: capacityBytes must be a positive integer, received ${capacityBytes}`);
+		const buf = existingBuffer ?? allocShared(CONTROL_BYTES + capacityBytes);
+		this.buffer = buf;
+		this.#control = new Int32Array(buf, 0, CONTROL_SLOTS);
+		this.#data = new Uint8Array(buf, CONTROL_BYTES, capacityBytes);
+		this.#size = capacityBytes;
+	}
+	/**
+	* Attach a second `SharedRingBuffer` view to an existing buffer — e.g.
+	* the consumer side wrapping a buffer received from the producer via
+	* `postMessage`. No cursors are reset; the view observes whatever the
+	* other side has already published.
+	*
+	* @param buffer - A `SharedArrayBuffer` previously created by a
+	*                 `SharedRingBuffer` constructor.
+	* @returns A `SharedRingBuffer` sharing `buffer`'s cursors and data.
+	* @throws If `buffer` is too small to contain the control region.
+	*/
+	static fromBuffer(buffer) {
+		if (buffer.byteLength <= CONTROL_BYTES) throw new Error(`SharedRingBuffer.fromBuffer: buffer too small (${buffer.byteLength} bytes)`);
+		return new SharedRingBuffer(buffer.byteLength - CONTROL_BYTES, buffer);
+	}
+	/** @internal Free bytes available for a new frame's payload + header. */
+	#freeBytes(head, tail) {
+		if (tail >= head) return this.#size - (tail - head) - 1;
+		return head - tail - 1;
+	}
+	/**
+	* Push a single byte frame onto the ring (producer side).
+	*
+	* The frame is stored as a length-prefixed record. Returns `false`
+	* without modifying the ring if there is not enough free space for the
+	* header plus payload.
+	*
+	* @param bytes - Payload to enqueue (may be empty).
+	* @returns `true` if enqueued, `false` if the ring was too full.
+	*/
+	push(bytes) {
+		const head = Atomics.load(this.#control, HEAD_SLOT);
+		const tail = Atomics.load(this.#control, TAIL_SLOT);
+		if (LENGTH_HEADER_BYTES + bytes.length > this.#freeBytes(head, tail)) return false;
+		let cursor = tail;
+		const len = bytes.length;
+		cursor = this.#writeByte(cursor, len & 255);
+		cursor = this.#writeByte(cursor, len >>> 8 & 255);
+		cursor = this.#writeByte(cursor, len >>> 16 & 255);
+		cursor = this.#writeByte(cursor, len >>> 24 & 255);
+		for (let i = 0; i < len; i += 1) cursor = this.#writeByte(cursor, bytes[i] ?? 0);
+		Atomics.store(this.#control, TAIL_SLOT, cursor);
+		return true;
+	}
+	/**
+	* Pop the next byte frame from the ring (consumer side).
+	*
+	* @param maxBytes - Maximum payload size the caller is willing to receive.
+	*                   If the next frame's payload exceeds this, the frame is
+	*                   left in place and `null` is returned.
+	* @returns The dequeued payload as a fresh `Uint8Array`, or `null` when
+	*          the ring is empty or the next frame exceeds `maxBytes`.
+	*/
+	pop(maxBytes) {
+		const head = Atomics.load(this.#control, HEAD_SLOT);
+		if (head === Atomics.load(this.#control, TAIL_SLOT)) return null;
+		let cursor = head;
+		const b0 = this.#readByte(cursor);
+		cursor = (cursor + 1) % this.#size;
+		const b1 = this.#readByte(cursor);
+		cursor = (cursor + 1) % this.#size;
+		const b2 = this.#readByte(cursor);
+		cursor = (cursor + 1) % this.#size;
+		const b3 = this.#readByte(cursor);
+		cursor = (cursor + 1) % this.#size;
+		const len = (b0 | b1 << 8 | b2 << 16 | b3 << 24) >>> 0;
+		if (len > maxBytes) return null;
+		const out = new Uint8Array(len);
+		for (let i = 0; i < len; i += 1) {
+			out[i] = this.#readByte(cursor);
+			cursor = (cursor + 1) % this.#size;
+		}
+		Atomics.store(this.#control, HEAD_SLOT, cursor);
+		return out;
+	}
+	/**
+	* Write one byte at `cursor` (already within `[0, size)`) and return the
+	* next cursor position, wrapping around the data region.
+	*/
+	#writeByte(cursor, value) {
+		this.#data[cursor] = value;
+		return (cursor + 1) % this.#size;
+	}
+	/**
+	* Read one byte at `cursor` (already within `[0, size)`). The `?? 0` only
+	* satisfies `noUncheckedIndexedAccess`; `cursor` is always in range.
+	*/
+	#readByte(cursor) {
+		return this.#data[cursor] ?? 0;
+	}
+};
+//#endregion
+//#region src/runtime/memoryBudget.ts
+/**
+* @module runtime/memoryBudget
+*
+* A memory budget / cap used to bound the processing of *untrusted* PDFs as a
+* defence against decompression bombs and out-of-memory (OOM) attacks.
+*
+* ## What this is — and what it is NOT
+*
+* {@link MemoryBudget} is a **pure accounting guard**. It is a plain integer
+* counter with a ceiling. It does **NOT** measure real process memory (RSS),
+* heap usage, `performance.memory`, or anything reported by the host. It makes
+* **no** claim of measuring actual memory and performs **no** acceleration of
+* any kind — there are no workers, SIMD, threads, `Atomics`, or
+* `SharedArrayBuffer` involved.
+*
+* The intended usage pattern is *predictive*: before a caller allocates a
+* large buffer (for example, the expected output length of an inflated /
+* decoded stream, which a malicious PDF can declare as enormous), it reports
+* that size to the budget via {@link MemoryBudget.allocate} (or
+* {@link MemoryBudget.tryAllocate}). If the reported size would push total
+* tracked usage past the configured limit, the allocation is rejected
+* **before** the real memory is ever requested — so a bomb is stopped early
+* instead of being materialised and crashing the runtime.
+*
+* Because it is pure accounting, its accuracy is exactly as good as the sizes
+* callers report. It is a budget, not a profiler.
+*
+* ## Runtime
+*
+* This module uses only ECMAScript primitives (numbers, classes, closures).
+* It assumes no Node-only globals and runs unchanged on Node, Deno, Bun,
+* Cloudflare Workers, and browsers.
+*/
+/**
+* Thrown by {@link MemoryBudget.allocate} (and {@link MemoryBudget.withAllocation})
+* when a requested allocation would exceed the configured limit.
+*
+* Carries the numbers involved so callers can surface a precise diagnostic:
+*
+* - {@link requested} — the size that was being allocated.
+* - {@link used} — the tracked usage *before* the rejected allocation.
+* - {@link limit} — the configured ceiling.
+*/
+var MemoryBudgetExceededError = class extends Error {
+	/** The allocation size, in bytes, that was rejected. */
+	requested;
+	/** The configured budget ceiling, in bytes. */
+	limit;
+	/** The tracked usage, in bytes, at the moment of rejection. */
+	used;
+	/**
+	* @param requested - The size, in bytes, that was being allocated.
+	* @param used      - The tracked usage, in bytes, before the allocation.
+	* @param limit     - The configured ceiling, in bytes.
+	*/
+	constructor(requested, used, limit) {
+		super(`Memory budget exceeded: requested ${requested} byte(s) with ${used} of ${limit} byte(s) already in use (would total ${used + requested}).`);
+		this.name = "MemoryBudgetExceededError";
+		this.requested = requested;
+		this.used = used;
+		this.limit = limit;
+	}
+};
+/**
+* Validate a configured limit. The limit must be a finite number strictly
+* greater than zero; `NaN`, negative values, and `Infinity` are rejected.
+*
+* @throws {TypeError} If the limit is not a finite number `> 0`.
+*/
+function assertValidLimit(limitBytes) {
+	if (typeof limitBytes !== "number" || !Number.isFinite(limitBytes) || limitBytes <= 0) throw new TypeError(`MemoryBudget: limitBytes must be a finite number greater than 0, received ${String(limitBytes)}.`);
+}
+/**
+* Validate a size passed to {@link MemoryBudget.allocate},
+* {@link MemoryBudget.tryAllocate}, {@link MemoryBudget.release}, or
+* {@link MemoryBudget.withAllocation}. The size must be a finite,
+* non-negative number; `NaN`, negative values, and `Infinity` are rejected.
+*
+* @throws {TypeError} If the size is not a finite number `>= 0`.
+*/
+function assertValidSize(bytes, method) {
+	if (typeof bytes !== "number" || !Number.isFinite(bytes) || bytes < 0) throw new TypeError(`MemoryBudget.${method}: bytes must be a finite, non-negative number, received ${String(bytes)}.`);
+}
+/**
+* A bounded memory accounting guard. See the {@link module:runtime/memoryBudget module documentation}
+* for the precise semantics — in particular, that this tracks *reported*
+* sizes and does not measure real RSS.
+*/
+var MemoryBudget = class {
+	/** The configured ceiling, in bytes. */
+	#limit;
+	/** The optional pre-throw notification callback. */
+	#onExceed;
+	/** Currently tracked usage, in bytes. Always `0 <= used <= limit`. */
+	#used = 0;
+	/**
+	* @param options - The {@link MemoryBudgetOptions}. `limitBytes` must be a
+	*                  finite number greater than `0`.
+	* @throws {TypeError} If `limitBytes` is not a finite number `> 0`.
+	*/
+	constructor(options) {
+		assertValidLimit(options.limitBytes);
+		this.#limit = options.limitBytes;
+		this.#onExceed = options.onExceed;
+	}
+	/** Currently tracked usage, in bytes. */
+	get used() {
+		return this.#used;
+	}
+	/** The configured ceiling, in bytes. */
+	get limit() {
+		return this.#limit;
+	}
+	/** Bytes still available before the limit is reached (never negative). */
+	get remaining() {
+		return this.#limit - this.#used;
+	}
+	/**
+	* Reserve `bytes` against the budget.
+	*
+	* If `used + bytes` would exceed the limit, {@link onExceed} (if supplied)
+	* is invoked first and then a {@link MemoryBudgetExceededError} is thrown;
+	* tracked usage is left unchanged in that case.
+	*
+	* @param bytes - The size to reserve. Must be a finite number `>= 0`.
+	* @throws {TypeError} If `bytes` is negative, `NaN`, or `Infinity`.
+	* @throws {MemoryBudgetExceededError} If the allocation would exceed the limit.
+	*/
+	allocate(bytes) {
+		assertValidSize(bytes, "allocate");
+		if (this.#used + bytes > this.#limit) {
+			this.#onExceed?.({
+				requested: bytes,
+				used: this.#used,
+				limit: this.#limit
+			});
+			throw new MemoryBudgetExceededError(bytes, this.#used, this.#limit);
+		}
+		this.#used += bytes;
+	}
+	/**
+	* Non-throwing variant of {@link allocate}. Reserves `bytes` and returns
+	* `true` on success, or returns `false` (leaving usage unchanged) if the
+	* allocation would exceed the limit. {@link onExceed} is **not** invoked.
+	*
+	* @param bytes - The size to reserve. Must be a finite number `>= 0`.
+	* @returns `true` if reserved, `false` if it would exceed the limit.
+	* @throws {TypeError} If `bytes` is negative, `NaN`, or `Infinity`.
+	*/
+	tryAllocate(bytes) {
+		assertValidSize(bytes, "tryAllocate");
+		if (this.#used + bytes > this.#limit) return false;
+		this.#used += bytes;
+		return true;
+	}
+	/**
+	* Return `bytes` to the budget. Usage is clamped at `0`, so over-releasing
+	* (or releasing more than was reserved) never produces a negative value.
+	*
+	* @param bytes - The size to release. Must be a finite number `>= 0`.
+	* @throws {TypeError} If `bytes` is negative, `NaN`, or `Infinity`.
+	*/
+	release(bytes) {
+		assertValidSize(bytes, "release");
+		this.#used = Math.max(0, this.#used - bytes);
+	}
+	/** Reset tracked usage to zero. The limit is unchanged. */
+	reset() {
+		this.#used = 0;
+	}
+	/**
+	* Reserve `bytes`, run `fn`, and release `bytes` in a `finally` block so the
+	* reservation is returned even if `fn` throws.
+	*
+	* If the reservation itself would exceed the limit, `fn` is never invoked
+	* and a {@link MemoryBudgetExceededError} is thrown (nothing to release).
+	*
+	* @typeParam T - The return type of `fn`.
+	* @param bytes - The size to reserve for the duration of `fn`.
+	* @param fn    - The work to run while the reservation is held.
+	* @returns Whatever `fn` returns.
+	* @throws {TypeError} If `bytes` is negative, `NaN`, or `Infinity`.
+	* @throws {MemoryBudgetExceededError} If the reservation would exceed the limit.
+	*/
+	withAllocation(bytes, fn) {
+		this.allocate(bytes);
+		try {
+			return fn();
+		} finally {
+			this.release(bytes);
+		}
+	}
+};
+/**
+* Create a {@link MemoryBudget} with the given ceiling.
+*
+* The limit must be a finite number strictly greater than `0`; `NaN`,
+* negative values, and `Infinity` are all rejected with a {@link TypeError}.
+* (An infinite budget is intentionally disallowed: the whole point is to cap
+* untrusted input, and `Infinity` would silently disable the guard.)
+*
+* @param limitBytes - The ceiling, in bytes. Must be finite and `> 0`.
+* @returns A new {@link MemoryBudget}.
+* @throws {TypeError} If `limitBytes` is not a finite number `> 0`.
+*/
+function createMemoryBudget(limitBytes) {
+	return new MemoryBudget({ limitBytes });
+}
+//#endregion
+//#region src/runtime/runtimeCapabilities.ts
+/**
+* SIMD probe: a function `() -> v128` whose body is `i32.const 0; i32x4.splat;
+* i8x16.popcnt`. The `v128` result type and the `0xfd …` SIMD opcodes only
+* validate on a host implementing the SIMD MVP. Verified to validate on a
+* SIMD-capable host and to be rejected by a host lacking SIMD.
+*/
+const WASM_SIMD_MODULE = new Uint8Array([
+	0,
+	97,
+	115,
+	109,
+	1,
+	0,
+	0,
+	0,
+	1,
+	5,
+	1,
+	96,
+	0,
+	1,
+	123,
+	3,
+	2,
+	1,
+	0,
+	10,
+	10,
+	1,
+	8,
+	0,
+	65,
+	0,
+	253,
+	15,
+	253,
+	98,
+	11
+]);
+/**
+* Threads/atomics probe: a function whose body executes
+* `memory.atomic.notify` (`0xfe 0x00`) against a **shared** memory
+* (`flags = 0x03` ⇒ shared with a maximum). The shared-memory limits and the
+* `0xfe` atomic opcode only validate on a threads-capable host. Verified to
+* validate on such a host.
+*/
+const WASM_THREADS_MODULE = new Uint8Array([
+	0,
+	97,
+	115,
+	109,
+	1,
+	0,
+	0,
+	0,
+	1,
+	4,
+	1,
+	96,
+	0,
+	0,
+	3,
+	2,
+	1,
+	0,
+	5,
+	4,
+	1,
+	3,
+	1,
+	1,
+	10,
+	13,
+	1,
+	11,
+	0,
+	65,
+	0,
+	65,
+	0,
+	254,
+	0,
+	2,
+	0,
+	26,
+	11
+]);
+/**
+* Bulk-memory probe: a function whose body executes `memory.fill`
+* (`0xfc 0x0b`) against a defined memory. The `0xfc 0x0b` opcode only validates
+* on a bulk-memory-capable host. Verified to validate with the memory section
+* present and to be rejected when the memory section is removed (proving
+* `memory.fill` is the discriminating instruction).
+*/
+const WASM_BULK_MEMORY_MODULE = new Uint8Array([
+	0,
+	97,
+	115,
+	109,
+	1,
+	0,
+	0,
+	0,
+	1,
+	4,
+	1,
+	96,
+	0,
+	0,
+	3,
+	2,
+	1,
+	0,
+	5,
+	3,
+	1,
+	0,
+	1,
+	10,
+	13,
+	1,
+	11,
+	0,
+	65,
+	0,
+	65,
+	0,
+	65,
+	0,
+	252,
+	11,
+	0,
+	11
+]);
+/**
+* `true` iff `WebAssembly` is an object exposing a callable `validate`.
+* `WebAssembly.validate` itself never throws for a well-formed buffer, so this
+* gate is what makes every WASM probe safe.
+*/
+function hasWasm() {
+	try {
+		return typeof WebAssembly === "object" && WebAssembly !== null && typeof WebAssembly.validate === "function";
+	} catch {
+		return false;
+	}
+}
+/**
+* Validate a feature-detect module, returning `false` on any failure. Never
+* throws — a non-WASM host or a malformed buffer simply yields `false`.
+*/
+function validatesModule(bytes) {
+	try {
+		if (!hasWasm()) return false;
+		return WebAssembly.validate(bytes);
+	} catch {
+		return false;
+	}
+}
+/** `true` iff the named global is defined and not `undefined`. */
+function hasGlobal(name) {
+	try {
+		return globalThis[name] !== void 0;
+	} catch {
+		return false;
+	}
+}
+/**
+* Best-effort logical-core count. Prefers `navigator.hardwareConcurrency`
+* (browsers, Workers, Deno, Bun, modern Node), then Node's `os.cpus().length`
+* if a synchronously-resolvable `os` module is reachable, then `1`. Always
+* returns a positive integer and never throws.
+*
+* Note: `os` is *not* statically imported — that would assume a Node global on
+* non-Node runtimes. We only consult `navigator`, which is feature-detected,
+* and otherwise fall back to `1`. (A dynamic `import('node:os')` is async and
+* cannot feed a synchronous detector, so it is intentionally not attempted
+* here; `navigator.hardwareConcurrency` is present on Node ≥ 21.)
+*/
+function resolveHardwareConcurrency() {
+	try {
+		const reported = globalThis.navigator?.hardwareConcurrency;
+		if (typeof reported === "number" && Number.isInteger(reported) && reported > 0) return reported;
+	} catch {}
+	return 1;
+}
+/**
+* Honestly detect the perf-relevant capabilities of the current runtime.
+*
+* Every probe is feature-detected and throw-free; on a host missing a feature
+* the corresponding flag is `false` (or `1` for {@link
+* RuntimeCapabilities.hardwareConcurrency}). The result is **not** cached so a
+* test harness (or a host that gains a feature, e.g. cross-origin isolation
+* toggling) sees the live state.
+*
+* @returns A fresh {@link RuntimeCapabilities} snapshot.
+*/
+function detectRuntimeCapabilities() {
+	const wasm = hasWasm();
+	const sharedArrayBuffer = hasGlobal("SharedArrayBuffer");
+	return {
+		wasm,
+		wasmSimd: wasm && validatesModule(WASM_SIMD_MODULE),
+		wasmThreads: wasm && sharedArrayBuffer && validatesModule(WASM_THREADS_MODULE),
+		wasmBulkMemory: wasm && validatesModule(WASM_BULK_MEMORY_MODULE),
+		sharedArrayBuffer,
+		atomics: hasGlobal("Atomics"),
+		bigInt64Array: hasGlobal("BigInt64Array"),
+		crossOriginIsolated: globalThis.crossOriginIsolated === true,
+		hardwareConcurrency: resolveHardwareConcurrency()
+	};
+}
+/**
+* Convenience predicate: does the host implement the WebAssembly SIMD proposal?
+*
+* Equivalent to `detectRuntimeCapabilities().wasmSimd`. A `true` result means a
+* SIMD-enabled module would validate here — **not** that modern-pdf-lib's
+* shipped WASM uses SIMD (see {@link SIMD_NOTE}).
+*
+* @returns `true` iff the SIMD feature-detect module validates.
+*/
+function isWasmSimdSupported() {
+	return validatesModule(WASM_SIMD_MODULE);
+}
+/**
+* Honesty disclaimer about SIMD acceleration.
+*
+* modern-pdf-lib's bundled WebAssembly binaries are built **without** SIMD
+* today. {@link isWasmSimdSupported} / {@link RuntimeCapabilities.wasmSimd}
+* report only whether the *host* could run SIMD code — actually benefiting from
+* SIMD requires a SIMD-enabled rebuild of the WASM modules. This constant
+* exists so callers and docs do not mistake capability detection for active
+* acceleration.
+*/
+const SIMD_NOTE = "modern-pdf-lib's bundled WASM is currently built WITHOUT SIMD; isWasmSimdSupported()/wasmSimd report only that the host could run SIMD code. Realising SIMD acceleration requires a SIMD-enabled rebuild of the WASM modules — it is not used today.";
+//#endregion
+//#region src/jsx/jsxRuntime.ts
+/**
+* @module jsx/jsxRuntime
+*
+* A framework-agnostic **JSX / hyperscript renderer** that builds a real PDF
+* from a declarative element tree. It supports both the classic `h()` pragma
+* and the React-17+ *automatic runtime* (`jsx` / `jsxs` / `Fragment`), so you
+* can drive it from any JSX toolchain:
+*
+* ```jsonc
+* // tsconfig.json (automatic runtime)
+* { "compilerOptions": { "jsx": "react-jsx", "jsxImportSource": "modern-pdf-lib/jsx" } }
+* ```
+* ```jsonc
+* // tsconfig.json (classic runtime)
+* { "compilerOptions": { "jsx": "react", "jsxFactory": "h", "jsxFragmentFactory": "Fragment" } }
+* ```
+*
+* @example Classic pragma
+* ```ts
+* import { h, renderToPdf } from 'modern-pdf-lib/jsx';
+* import { PageSizes } from 'modern-pdf-lib';
+*
+* const bytes = await renderToPdf(
+*   h('document', { size: PageSizes.A4 },
+*     h('page', null,
+*       h('text', { size: 24, bold: true }, 'Invoice'),
+*       h('text', null, 'Thank you for your business.'),
+*     ),
+*   ),
+* );
+* ```
+*
+* ## Intrinsic elements
+*
+* | Tag         | Props                                                              | Meaning |
+* |-------------|--------------------------------------------------------------------|---------|
+* | `document`  | `{ size? }`                                                        | Root container. `size` is the default page size. |
+* | `page`      | `{ size? }`                                                        | Starts a new PDF page (overrides the document size). |
+* | `text`      | `{ x?, y?, size?, color?, bold? }`                                 | Draws one text line. |
+* | `view`      | `{ x?, y?, width?, height?, padding?, background? }`               | A block container; indents/pads its children. |
+* | `rect`      | `{ x, y, width, height, color?, border? }`                        | Draws a rectangle. |
+*
+* Function components are plain `(props) => PdfNode` functions — they are
+* called with their props (children supplied as `props.children`) and their
+* return value is rendered in place. {@link Fragment} groups children without
+* adding any layout box.
+*
+* ## Layout model (simple, by design)
+*
+* This is **not** a flexbox engine. Layout is a deterministic *top-down block
+* flow* per page:
+*
+* - Each `page` maintains a running **y cursor** that starts at
+*   `pageHeight - MARGIN_TOP` and a running **x cursor** at `MARGIN_LEFT`.
+*   Because PDF coordinates are y-up but documents read top-down, the cursor
+*   *decreases* as successive blocks are placed.
+* - A flowed `text` is drawn at the current `(x, y - ascent)` and then advances
+*   the y cursor down by its line height (`size * LINE_HEIGHT_FACTOR`).
+* - A flowed `view` optionally paints its `background`, indents the x cursor by
+*   its `padding`, lays its children out in the same top-down flow, then
+*   restores x and advances y past the consumed block (plus padding).
+* - **Absolute positioning:** if an element supplies an explicit `x` *and* `y`,
+*   it is placed at exactly that PDF coordinate (y-up, measured from the page
+*   bottom) and does **not** consume or advance the flow cursor. A `rect`
+*   (which requires explicit `x`/`y`) is therefore always absolute.
+* - Each `page` element resets both cursors and starts a fresh PDF page.
+*
+* Anything the simple model cannot express (wrapping across pages, automatic
+* text reflow, percentage sizing, z-index) is intentionally out of scope.
+*
+* @packageDocumentation
+*/
+/** Top margin (points) where the flow cursor starts on every page. */
+const MARGIN_TOP = 50;
+/** Left margin (points) where the flow cursor starts on every page. */
+const MARGIN_LEFT = 50;
+/** Default font size (points) for `text` when `size` is not supplied. */
+const DEFAULT_FONT_SIZE = 12;
+/** Line-height multiplier applied to a text line's font size. */
+const LINE_HEIGHT_FACTOR = 1.2;
+/**
+* Recursively flatten a children argument list into a flat `PdfNode[]`,
+* splatting nested arrays (which JSX produces for `{items.map(...)}`).
+*/
+function flattenChildren(children) {
+	const out = [];
+	const visit = (node) => {
+		if (Array.isArray(node)) for (const item of node) visit(item);
+		else out.push(node);
+	};
+	visit(children);
+	return out;
+}
+/**
+* Classic hyperscript pragma (`jsxFactory: "h"`).
+*
+* @param type      Intrinsic tag name or a function component.
+* @param props     Props object, or `null` for no props.
+* @param children  Zero or more child nodes (nested arrays are flattened).
+* @returns         A {@link PdfElement}.
+*/
+function h(type, props, ...children) {
+	return {
+		type,
+		props: props ?? {},
+		children: flattenChildren(children)
+	};
+}
+/**
+* Extract the flattened children from an automatic-runtime props object.
+* The JSX automatic runtime passes children inside `props.children`.
+*/
+function childrenFromProps(props) {
+	if (!("children" in props)) return {
+		rest: props,
+		children: []
+	};
+	const { children, ...rest } = props;
+	return {
+		rest,
+		children: flattenChildren(children)
+	};
+}
+/**
+* Automatic-runtime factory for elements with a single (or no) child.
+*
+* @param type   Intrinsic tag name or a function component.
+* @param props  Props object; children (if any) live under `props.children`.
+* @returns      A {@link PdfElement}.
+*/
+function jsx(type, props) {
+	const { rest, children } = childrenFromProps(props);
+	return {
+		type,
+		props: rest,
+		children
+	};
+}
+/**
+* Automatic-runtime factory for elements with multiple static children.
+*
+* Behaviour is identical to {@link jsx}; the JSX transform calls `jsxs` when
+* the children are a static array.
+*
+* @param type   Intrinsic tag name or a function component.
+* @param props  Props object; children live under `props.children`.
+* @returns      A {@link PdfElement}.
+*/
+function jsxs(type, props) {
+	return jsx(type, props);
+}
+/**
+* Fragment component — groups children without adding a layout box. Used by
+* the JSX transform for `<>...</>` and directly via `h(Fragment, null, ...)`.
+*
+* @param props  Props whose `children` are returned for rendering.
+* @returns      The children as a {@link PdfNode} (an array, which the
+*               renderer flattens transparently).
+*/
+const Fragment = (props) => {
+	return props["children"] ?? null;
+};
+/** Number prop reader that tolerates absent / non-number values. */
+function numProp(props, key) {
+	const v = props[key];
+	return typeof v === "number" ? v : void 0;
+}
+/** Resolve a `PageSize`-ish value into a concrete `[width, height]`. */
+function resolvePageSize(value, fallback) {
+	if (Array.isArray(value) && value.length === 2 && typeof value[0] === "number" && typeof value[1] === "number") return [value[0], value[1]];
+	if (value && typeof value === "object" && typeof value.width === "number" && typeof value.height === "number") return value;
+	return fallback;
+}
+/**
+* Normalize an element/component (or a raw array produced by a component such
+* as {@link Fragment}) into a concrete, flattened array of child nodes.
+*/
+function resolveNode(input) {
+	if (Array.isArray(input)) return flattenChildren(input);
+	const node = input;
+	if (node === null || node === void 0 || typeof node === "boolean") return [];
+	if (typeof node === "string" || typeof node === "number") return [node];
+	if (typeof node.type === "function") {
+		const componentProps = {
+			...node.props,
+			children: node.children
+		};
+		return flattenChildren(node.type(componentProps));
+	}
+	return [node];
+}
+/**
+* Render context shared across a single document render: holds the document,
+* a lazily-embedded default + bold font, and the active page/cursor.
+*/
+var RenderContext = class {
+	doc;
+	regular;
+	bold;
+	constructor(doc) {
+		this.doc = doc;
+	}
+	async init() {
+		this.regular = await this.doc.embedFont("Helvetica");
+		this.bold = await this.doc.embedFont("Helvetica-Bold");
+	}
+	font(bold) {
+		const f = bold ? this.bold : this.regular;
+		if (f === void 0) throw new Error("RenderContext.init() must be awaited before rendering.");
+		return f;
+	}
+};
+/**
+* Draw a single text line. Returns the height consumed in the flow (0 when the
+* element was absolutely positioned and therefore does not advance the flow).
+*/
+function renderText(ctx, page, cursor, el) {
+	const props = el.props;
+	const size = numProp(props, "size") ?? DEFAULT_FONT_SIZE;
+	const bold = props["bold"] === true;
+	const color = props["color"];
+	const font = ctx.font(bold);
+	const text = el.children.filter((c) => typeof c === "string" || typeof c === "number").map((c) => String(c)).join("");
+	const absX = numProp(props, "x");
+	const absY = numProp(props, "y");
+	const absolute = absX !== void 0 && absY !== void 0;
+	const lineHeight = size * LINE_HEIGHT_FACTOR;
+	if (absolute) {
+		page.drawText(text, {
+			x: absX,
+			y: absY,
+			size,
+			font,
+			...color !== void 0 ? { color } : {}
+		});
+		return 0;
+	}
+	const baseline = cursor.y - size;
+	page.drawText(text, {
+		x: cursor.x,
+		y: baseline,
+		size,
+		font,
+		...color !== void 0 ? { color } : {}
+	});
+	cursor.y -= lineHeight;
+	return lineHeight;
+}
+/**
+* Draw a rectangle. `rect` is always absolutely positioned (x/y required) and
+* therefore never advances the flow cursor.
+*/
+function renderRect(page, el) {
+	const props = el.props;
+	const x = numProp(props, "x") ?? 0;
+	const y = numProp(props, "y") ?? 0;
+	const width = numProp(props, "width") ?? 0;
+	const height = numProp(props, "height") ?? 0;
+	const color = props["color"];
+	const border = props["border"];
+	page.drawRectangle({
+		x,
+		y,
+		width,
+		height,
+		...color !== void 0 ? { color } : {},
+		...border !== void 0 ? {
+			borderColor: border,
+			borderWidth: 1
+		} : {}
+	});
+}
+/**
+* Render a `view` block container. Returns the height consumed in the flow
+* (0 when absolutely positioned).
+*/
+function renderView(ctx, page, cursor, el) {
+	const props = el.props;
+	const padding = numProp(props, "padding") ?? 0;
+	const background = props["background"];
+	const absX = numProp(props, "x");
+	const absY = numProp(props, "y");
+	const absolute = absX !== void 0 && absY !== void 0;
+	const explicitWidth = numProp(props, "width");
+	const explicitHeight = numProp(props, "height");
+	if (absolute) {
+		const localTop = absY + (explicitHeight ?? 0);
+		const local = {
+			x: absX + padding,
+			y: localTop - padding
+		};
+		if (background !== void 0 && explicitWidth !== void 0 && explicitHeight !== void 0) page.drawRectangle({
+			x: absX,
+			y: absY,
+			width: explicitWidth,
+			height: explicitHeight,
+			color: background
+		});
+		renderChildren(ctx, page, local, el.children);
+		return 0;
+	}
+	const blockTop = cursor.y;
+	const innerCursor = {
+		x: cursor.x + padding,
+		y: cursor.y - padding
+	};
+	renderChildren(ctx, page, innerCursor, el.children);
+	const contentConsumed = cursor.y - padding - innerCursor.y;
+	const blockHeight = explicitHeight ?? contentConsumed + padding * 2;
+	if (background !== void 0) {
+		const blockWidth = explicitWidth ?? page.width - cursor.x - MARGIN_LEFT;
+		page.drawRectangle({
+			x: cursor.x,
+			y: blockTop - blockHeight,
+			width: blockWidth,
+			height: blockHeight,
+			color: background
+		});
+	}
+	cursor.y = blockTop - blockHeight;
+	return blockHeight;
+}
+/** Render a flat list of children in top-down flow on the current page. */
+function renderChildren(ctx, page, cursor, children) {
+	for (const child of children) for (const resolved of resolveNode(child)) renderFlowNode(ctx, page, cursor, resolved);
+}
+/** Render one already-resolved node into the current page's flow. */
+function renderFlowNode(ctx, page, cursor, node) {
+	if (node === null || node === void 0 || typeof node === "boolean") return;
+	if (typeof node === "string" || typeof node === "number") {
+		const size = DEFAULT_FONT_SIZE;
+		const baseline = cursor.y - size;
+		page.drawText(String(node), {
+			x: cursor.x,
+			y: baseline,
+			size,
+			font: ctx.font(false)
+		});
+		cursor.y -= size * LINE_HEIGHT_FACTOR;
+		return;
+	}
+	if (typeof node.type === "function") {
+		for (const resolved of resolveNode(node)) renderFlowNode(ctx, page, cursor, resolved);
+		return;
+	}
+	switch (node.type) {
+		case "text":
+			renderText(ctx, page, cursor, node);
+			return;
+		case "view":
+			renderView(ctx, page, cursor, node);
+			return;
+		case "rect":
+			renderRect(page, node);
+			return;
+		case "page":
+		case "document":
+			renderChildren(ctx, page, cursor, node.children);
+			return;
+		default:
+			renderChildren(ctx, page, cursor, node.children);
+			return;
+	}
+}
+/**
+* Collect the `page` elements from a `document`'s children, resolving any
+* function components / fragments that wrap them.
+*/
+function collectPages(children) {
+	const pages = [];
+	const visit = (node) => {
+		for (const resolved of resolveNode(node)) {
+			if (resolved === null || resolved === void 0 || typeof resolved === "boolean" || typeof resolved === "string" || typeof resolved === "number") continue;
+			if (typeof resolved.type === "function") {
+				visit(resolved);
+				continue;
+			}
+			if (resolved.type === "page") pages.push(resolved);
+			else for (const c of resolved.children) visit(c);
+		}
+	};
+	for (const child of children) visit(child);
+	return pages;
+}
+/**
+* Render a declarative element tree to a PDF document.
+*
+* The `root` should be a `document` element (or a component / fragment that
+* resolves to one). Each `page` child becomes a PDF page; content flows
+* top-down within each page per the layout model documented in the module
+* header.
+*
+* @param root  The root {@link PdfNode} (typically a `document` element).
+* @returns     The serialized PDF as a `Uint8Array` (begins with `"%PDF-"`).
+*
+* @example
+* ```ts
+* const bytes = await renderToPdf(
+*   h('document', { size: PageSizes.A4 },
+*     h('page', null, h('text', { size: 24 }, 'Hello'), h('text', null, 'World')),
+*   ),
+* );
+* ```
+*/
+async function renderToPdf(root) {
+	let documentEl;
+	const stack = resolveNode(root);
+	while (stack.length > 0) {
+		const node = stack.shift();
+		if (node === null || node === void 0 || typeof node === "boolean" || typeof node === "string" || typeof node === "number") continue;
+		if (typeof node.type === "function") {
+			stack.unshift(...resolveNode(node));
+			continue;
+		}
+		if (node.type === "document") {
+			documentEl = node;
+			break;
+		}
+		documentEl = {
+			type: "document",
+			props: {},
+			children: [node]
+		};
+		break;
+	}
+	const doc = createPdf();
+	const ctx = new RenderContext(doc);
+	await ctx.init();
+	const docSize = resolvePageSize(documentEl?.props["size"], PageSizes.A4);
+	const pageEls = documentEl ? collectPages(documentEl.children) : [];
+	if (pageEls.length === 0) doc.addPage(docSize);
+	for (const pageEl of pageEls) {
+		const pageSize = resolvePageSize(pageEl.props["size"], docSize);
+		const page = doc.addPage(pageSize);
+		renderChildren(ctx, page, {
+			x: MARGIN_LEFT,
+			y: page.height - MARGIN_TOP
+		}, pageEl.children);
+	}
+	return doc.save();
+}
+//#endregion
+//#region src/form/schemaForm.ts
+/**
+* @module form/schemaForm
+*
+* Generate a fillable AcroForm PDF directly from a JSON-Schema-like
+* description.  Only the subset of JSON Schema that maps cleanly onto
+* PDF interactive form (AcroForm) field types is supported:
+*
+* | JSON Schema                       | AcroForm field            |
+* | --------------------------------- | ------------------------- |
+* | `type: 'string'`                  | text field                |
+* | `type: 'string'` + `enum: [...]`  | dropdown (combo box)      |
+* | `type: 'boolean'`                 | checkbox                  |
+* | `type: 'number'` / `'integer'`    | text field                |
+* | `type: 'object'` / `'array'`      | text field (placeholder)  |
+* | anything else / no `type`         | text field (placeholder)  |
+*
+* ### Documented limitations (intentional, honest scope)
+*
+* - **Nested objects and arrays are NOT recursed.** A property whose
+*   `type` is `'object'` or `'array'` becomes a single flat text-field
+*   placeholder labelled with the property name. Sub-properties of a
+*   nested object are ignored. (Recursive / repeatable structures have
+*   no first-class AcroForm representation.)
+* - **Unsupported / unknown `type` keywords** (and properties with no
+*   `type` at all) also degrade gracefully to a plain text field, so the
+*   generated document is always a valid, fillable PDF.
+* - Schema validation keywords (`minLength`, `pattern`, `minimum`,
+*   `multipleOf`, `oneOf`, `anyOf`, `$ref`, …) are **not** enforced; they
+*   are simply ignored. Only `type`, `properties`, `required`, `enum`,
+*   and `title` influence the output.
+* - `enum` is honoured only for `type: 'string'`. Enum values of other
+*   types fall through to their normal mapping.
+*
+* The returned {@link PdfDocument} is **not** saved — call `doc.save()`
+* (or any of the `saveAs*` variants) on it yourself.
+*
+* @example
+* ```ts
+* import { buildFormFromJsonSchema } from 'modern-pdf-lib/form/schemaForm';
+*
+* const { doc, fields } = buildFormFromJsonSchema({
+*   type: 'object',
+*   title: 'Signup',
+*   properties: {
+*     fullName: { type: 'string', title: 'Full Name' },
+*     subscribe: { type: 'boolean' },
+*     country: { type: 'string', enum: ['US', 'CA', 'MX'] },
+*   },
+*   required: ['fullName'],
+* });
+*
+* const bytes = await doc.save();
+* ```
+*/
+/** Vertical space (points) allotted to each row (field + gap). */
+const ROW_HEIGHT = 34;
+/** Height (points) of a text / dropdown widget. */
+const FIELD_HEIGHT = 20;
+/** Side margin (points). */
+const MARGIN = 48;
+/** Top margin (points) below which fields start on each page. */
+const TOP_MARGIN = 56;
+/** Bottom margin (points); fields below this trigger a page break. */
+const BOTTOM_MARGIN = 48;
+/** Default label-column width (points). */
+const DEFAULT_LABEL_WIDTH = 160;
+/** Body font size for labels. */
+const LABEL_SIZE = 11;
+/** Title font size. */
+const TITLE_SIZE = 18;
+/**
+* Determine which AcroForm field kind a property schema maps to.
+*
+* @returns The field kind plus, for dropdowns, the list of options.
+*/
+function mapPropertyToKind(prop) {
+	const type = prop.type;
+	if (type === "boolean") return {
+		kind: "checkbox",
+		options: []
+	};
+	if (type === "string" && Array.isArray(prop.enum) && prop.enum.length > 0) return {
+		kind: "dropdown",
+		options: prop.enum.map((v) => String(v))
+	};
+	return {
+		kind: "text",
+		options: []
+	};
+}
+/**
+* Internal plugin that wires a freshly-built form into the document at
+* save time.  It runs after pages are finalized so it can:
+*
+*  - append each field's (pre-registered) indirect reference to its
+*    page's `/Annots` array (`onBuildPageDict`), and
+*  - register the `/AcroForm` dictionary on the catalog with a `/DR`
+*    default-resources entry and `/NeedAppearances true` so viewers
+*    generate the field appearances (`onBuildCatalog`).
+*
+* This avoids editing any shared document code: everything needed to
+* make `getForm()` fields round-trip is performed through the public
+* plugin hooks.
+*/
+function createAcroFormWiringPlugin(acroFormDict, acroFormRef, fieldRefsByPage) {
+	return {
+		name: "modern-pdf-lib:schemaForm-acroform-wiring",
+		version: "1.0.0",
+		onBuildPageDict(pageDict, pageIndex) {
+			const refs = fieldRefsByPage.get(pageIndex);
+			if (refs === void 0 || refs.length === 0) return;
+			const existing = pageDict.get("/Annots");
+			if (existing !== void 0 && existing.kind === "array") for (const ref of refs) existing.push(ref);
+			else pageDict.set("/Annots", PdfArray.of([...refs]));
+		},
+		onBuildCatalog(catalog) {
+			if (!acroFormDict.has("/DR")) {
+				const helvetica = new PdfDict();
+				helvetica.set("/Type", PdfName.of("Font"));
+				helvetica.set("/Subtype", PdfName.of("Type1"));
+				helvetica.set("/BaseFont", PdfName.of("Helvetica"));
+				const fontDict = new PdfDict();
+				fontDict.set("/Helv", helvetica);
+				const resources = new PdfDict();
+				resources.set("/Font", fontDict);
+				acroFormDict.set("/DR", resources);
+			}
+			if (!acroFormDict.has("/DA")) acroFormDict.set("/DA", PdfString.literal("/Helv 0 Tf 0 g"));
+			acroFormDict.set("/NeedAppearances", PdfBool.TRUE);
+			catalog.set("/AcroForm", acroFormRef);
+		}
+	};
+}
+/**
+* Build a fillable AcroForm PDF from a JSON-Schema-like description.
+*
+* For an object schema, the `properties` are iterated in insertion
+* order and one labelled form field is emitted per property.  Fields
+* are stacked top-down; when the vertical cursor runs off the page a
+* new page is added and the cursor reset.  Required fields (listed in
+* the schema's `required` array) are marked with a trailing asterisk in
+* their label.
+*
+* @param schema   The JSON-Schema-like description.
+* @param options  Optional layout options.
+* @returns        The generated (unsaved) {@link PdfDocument} and the
+*                 list of generated field descriptors.
+*/
+function buildFormFromJsonSchema(schema, options) {
+	const doc = createPdf();
+	const form = doc.getForm();
+	const pageSize = options?.pageSize ?? [PageSizes.A4[0], PageSizes.A4[1]];
+	const [pageWidth, pageHeight] = pageSize;
+	const labelWidth = options?.labelWidth !== void 0 ? options.labelWidth : DEFAULT_LABEL_WIDTH;
+	const fields = [];
+	const fieldRefsByPage = /* @__PURE__ */ new Map();
+	const registry = doc.getRegistry();
+	const acroFormDict = form.toDict(registry);
+	const acroFormRef = registry.register(acroFormDict);
+	const fieldRefs = [];
+	let pageIndex = -1;
+	let cursorY = 0;
+	const fieldX = MARGIN + labelWidth;
+	const fieldWidth = Math.max(40, pageWidth - fieldX - MARGIN);
+	/** Start a fresh page and reset the vertical cursor. */
+	const newPage = () => {
+		doc.addPage(pageSize);
+		pageIndex += 1;
+		cursorY = pageHeight - TOP_MARGIN;
+	};
+	newPage();
+	const title = options?.title ?? schema.title;
+	if (title !== void 0 && title.length > 0) {
+		doc.getPage(pageIndex).drawText(title, {
+			x: MARGIN,
+			y: cursorY,
+			size: TITLE_SIZE,
+			color: rgb(0, 0, 0)
+		});
+		cursorY -= 36;
+	}
+	const properties = schema.type === "object" ? schema.properties : void 0;
+	const requiredSet = new Set(schema.required ?? []);
+	if (properties !== void 0) for (const [name, propSchema] of Object.entries(properties)) {
+		const prop = propSchema ?? {};
+		const { kind, options: dropdownOptions } = mapPropertyToKind(prop);
+		if (cursorY - ROW_HEIGHT < BOTTOM_MARGIN) newPage();
+		const page = doc.getPage(pageIndex);
+		const labelText = prop.title ?? name;
+		const required = requiredSet.has(name);
+		const label = required ? `${labelText} *` : labelText;
+		page.drawText(label, {
+			x: MARGIN,
+			y: cursorY - FIELD_HEIGHT + 6,
+			size: LABEL_SIZE,
+			color: required ? rgb(.6, 0, 0) : rgb(.1, .1, .1)
+		});
+		const y1 = cursorY - FIELD_HEIGHT;
+		const y2 = cursorY;
+		let createdDict;
+		if (kind === "checkbox") {
+			const cbSize = FIELD_HEIGHT;
+			createdDict = form.createCheckbox(name, pageIndex, [
+				fieldX,
+				y1,
+				fieldX + cbSize,
+				y2
+			]).getDict();
+		} else if (kind === "dropdown") createdDict = form.createDropdown(name, pageIndex, [
+			fieldX,
+			y1,
+			fieldX + fieldWidth,
+			y2
+		], dropdownOptions).getDict();
+		else {
+			createdDict = form.createTextField(name, pageIndex, [
+				fieldX,
+				y1,
+				fieldX + fieldWidth,
+				y2
+			]).getDict();
+			page.drawLine({
+				start: {
+					x: fieldX,
+					y: y1
+				},
+				end: {
+					x: fieldX + fieldWidth,
+					y: y1
+				},
+				thickness: .5,
+				color: rgb(.6, .6, .6)
+			});
+		}
+		const ref = registry.register(createdDict);
+		fieldRefs.push(ref);
+		const pageRefs = fieldRefsByPage.get(pageIndex) ?? [];
+		pageRefs.push(ref);
+		fieldRefsByPage.set(pageIndex, pageRefs);
+		fields.push({
+			name,
+			kind
+		});
+		cursorY -= ROW_HEIGHT;
+	}
+	acroFormDict.set("/Fields", PdfArray.of([...fieldRefs]));
+	doc.use(createAcroFormWiringPlugin(acroFormDict, acroFormRef, fieldRefsByPage));
+	return {
+		doc,
+		fields
+	};
+}
+//#endregion
+//#region src/runtime/serverAdapters.ts
+/**
+* Characters that are safe to leave unencoded inside the RFC 5987
+* `attr-char` production used by `filename*`.  Everything else is
+* percent-encoded from its UTF-8 bytes.
+*
+* `attr-char = ALPHA / DIGIT / "!" / "#" / "$" / "&" / "+" / "-" /
+*              "." / "^" / "_" / "`" / "|" / "~"`  (RFC 5987 §3.2.1)
+*/
+const RFC5987_ATTR_CHAR = /[A-Za-z0-9!#$&+\-.^_`|~]/;
+/** Reusable UTF-8 encoder for the `filename*` byte serialisation. */
+const utf8Encoder = new TextEncoder();
+/**
+* Percent-encode a string as an RFC 5987 `value-chars` sequence: every
+* byte that is not an `attr-char` is written as `%HH` (upper-case hex)
+* from its UTF-8 representation.
+*
+* @param value  The raw (possibly non-ASCII) string.
+* @returns      The `value-chars` portion of an `ext-value`.
+*/
+function encodeRfc5987(value) {
+	const bytes = utf8Encoder.encode(value);
+	let out = "";
+	for (const byte of bytes) {
+		const char = String.fromCharCode(byte);
+		if (byte < 128 && RFC5987_ATTR_CHAR.test(char)) out += char;
+		else out += `%${byte.toString(16).toUpperCase().padStart(2, "0")}`;
+	}
+	return out;
+}
+/**
+* A small transliteration table mapping common accented Latin letters to
+* their closest ASCII equivalent.  Used only for the *fallback* `filename`
+* parameter — the authoritative value is always carried by `filename*`.
+*
+* This is intentionally minimal: it covers the Latin-1 / Latin Extended-A
+* letters most likely to appear in document names so that legacy clients
+* (which ignore `filename*`) still receive a readable name.
+*/
+const TRANSLITERATIONS = new Map(Object.entries({
+	à: "a",
+	á: "a",
+	â: "a",
+	ã: "a",
+	ä: "a",
+	å: "a",
+	ā: "a",
+	ă: "a",
+	ą: "a",
+	ç: "c",
+	ć: "c",
+	č: "c",
+	è: "e",
+	é: "e",
+	ê: "e",
+	ë: "e",
+	ē: "e",
+	ė: "e",
+	ę: "e",
+	ě: "e",
+	ì: "i",
+	í: "i",
+	î: "i",
+	ï: "i",
+	ī: "i",
+	į: "i",
+	ñ: "n",
+	ń: "n",
+	ň: "n",
+	ò: "o",
+	ó: "o",
+	ô: "o",
+	õ: "o",
+	ö: "o",
+	ø: "o",
+	ō: "o",
+	ù: "u",
+	ú: "u",
+	û: "u",
+	ü: "u",
+	ū: "u",
+	ů: "u",
+	ý: "y",
+	ÿ: "y",
+	ž: "z",
+	ź: "z",
+	ż: "z",
+	ß: "ss",
+	æ: "ae",
+	œ: "oe",
+	À: "A",
+	Á: "A",
+	Â: "A",
+	Ã: "A",
+	Ä: "A",
+	Å: "A",
+	Ç: "C",
+	È: "E",
+	É: "E",
+	Ê: "E",
+	Ë: "E",
+	Ì: "I",
+	Í: "I",
+	Î: "I",
+	Ï: "I",
+	Ñ: "N",
+	Ò: "O",
+	Ó: "O",
+	Ô: "O",
+	Õ: "O",
+	Ö: "O",
+	Ø: "O",
+	Ù: "U",
+	Ú: "U",
+	Û: "U",
+	Ü: "U",
+	Ý: "Y"
+}));
+/**
+* Produce an ASCII-only fallback for a filename: accented Latin letters
+* are transliterated, any remaining non-ASCII characters are dropped, and
+* control characters are stripped.  The result is intended to be wrapped
+* in a `quoted-string` by {@link quoteFilename}.
+*
+* @param filename  The original, possibly non-ASCII filename.
+* @returns         An ASCII approximation (never empty: falls back to
+*                  `"file.pdf"` if nothing survives).
+*/
+function asciiFallback(filename) {
+	let out = "";
+	for (const char of filename) {
+		const code = char.codePointAt(0) ?? 0;
+		if (code >= 32 && code < 127) out += char;
+		else {
+			const replacement = TRANSLITERATIONS.get(char);
+			if (replacement !== void 0) out += replacement;
+		}
+	}
+	out = out.trim();
+	return out.length > 0 ? out : "file.pdf";
+}
+/**
+* Escape a string for use inside an HTTP `quoted-string` (RFC 9110 /
+* RFC 2616): backslash and double-quote are backslash-escaped.
+*
+* @param value  An ASCII string.
+* @returns      The escaped contents (without the surrounding quotes).
+*/
+function quoteFilename(value) {
+	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
+/**
+* Returns `true` when the string contains only printable ASCII and no
+* characters that would be illegal in a `quoted-string` filename.
+*/
+function isSimpleAscii(filename) {
+	for (const char of filename) {
+		const code = char.codePointAt(0) ?? 0;
+		if (code < 32 || code >= 127) return false;
+	}
+	return true;
+}
+/**
+* Build the value of the `Content-Disposition` header.
+*
+* @param download  `true` → `attachment`; otherwise `inline`.
+* @param filename  Optional suggested filename.
+* @returns         A complete header value, e.g.
+*                  `attachment; filename="report.pdf"` or, for non-ASCII,
+*                  `attachment; filename="resume.pdf"; filename*=UTF-8''r%C3%A9sum%C3%A9.pdf`.
+*/
+function contentDisposition(download, filename) {
+	const type = download ? "attachment" : "inline";
+	if (filename === void 0 || filename.length === 0) return type;
+	if (isSimpleAscii(filename) && !filename.includes("\"") && !filename.includes("\\")) return `${type}; filename="${filename}"`;
+	const quoted = quoteFilename(asciiFallback(filename));
+	if (isSimpleAscii(filename)) return `${type}; filename="${quoted}"`;
+	return `${type}; filename="${quoted}"; filename*=UTF-8''${encodeRfc5987(filename)}`;
+}
+/**
+* Build the set of HTTP response headers for serving a PDF body.
+*
+* Always includes `Content-Type: application/pdf`, a numeric
+* `Content-Length`, and a `Content-Disposition` (`inline` by default,
+* `attachment` when `options.download` is `true`).  `Cache-Control` and
+* `Last-Modified` are added only when supplied.
+*
+* Custom headers from `options.headers` are merged first so the core PDF
+* headers always win on conflict.
+*
+* @param byteLength  Length of the PDF body in bytes (the `Content-Length`).
+* @param options     Optional response shaping (see {@link PdfResponseOptions}).
+* @returns           A plain object of header name → value.
+*/
+function pdfHeaders(byteLength, options) {
+	const opts = options ?? {};
+	const headers = { ...opts.headers ?? {} };
+	headers["Content-Type"] = "application/pdf";
+	headers["Content-Length"] = String(byteLength);
+	headers["Content-Disposition"] = contentDisposition(opts.download === true, opts.filename);
+	if (opts.cacheControl !== void 0) headers["Cache-Control"] = opts.cacheControl;
+	if (opts.lastModified !== void 0) headers["Last-Modified"] = opts.lastModified.toUTCString();
+	return headers;
+}
+/**
+* Feature-detect the Web-standard `Response` constructor.
+*
+* @throws Error when `Response` is not a constructor in the current runtime.
+*/
+function assertResponseAvailable() {
+	if (typeof Response !== "function") throw new Error("pdfResponse: the Web-standard `Response` constructor is not available in this runtime. Use `sendPdfToNodeResponse(res, bytes)` for a classic Node `http.ServerResponse`, or upgrade to a runtime with the Fetch API (Node >=18, Deno, Bun, Cloudflare Workers, browsers).");
+}
+/**
+* Build a Web-standard {@link Response} that streams the given PDF bytes
+* to the client with the correct headers and status code.
+*
+* Works in any runtime with the Fetch API: Cloudflare Workers, Deno, Bun,
+* Node >=18, and browsers (e.g. inside a Service Worker).
+*
+* @param bytes    The PDF body.
+* @param options  Optional response shaping (see {@link PdfResponseOptions}).
+* @returns        A `Response` with status `options.status ?? 200`.
+* @throws         If the runtime lacks the `Response` constructor.
+*/
+function pdfResponse(bytes, options) {
+	assertResponseAvailable();
+	const opts = options ?? {};
+	const headers = pdfHeaders(bytes.byteLength, opts);
+	const body = bytes.slice();
+	return new Response(body, {
+		status: opts.status ?? 200,
+		headers
+	});
+}
+/**
+* Build a streaming Web-standard {@link Response} from a
+* `ReadableStream` of PDF bytes (e.g. from `doc.saveAsStream()`).
+*
+* Because the total size is generally unknown up-front, `Content-Length`
+* is **omitted** unless `options.byteLength` is supplied — allowing the
+* runtime to use chunked transfer encoding.
+*
+* @param stream   A readable stream of the PDF body.
+* @param options  Response shaping plus an optional known `byteLength`.
+* @returns        A streaming `Response`.
+* @throws         If the runtime lacks the `Response` constructor.
+*/
+function pdfStreamResponse(stream, options) {
+	assertResponseAvailable();
+	const opts = options ?? {};
+	const headers = opts.byteLength !== void 0 ? pdfHeaders(opts.byteLength, opts) : (() => {
+		const h = pdfHeaders(0, opts);
+		delete h["Content-Length"];
+		return h;
+	})();
+	return new Response(stream, {
+		status: opts.status ?? 200,
+		headers
+	});
+}
+/**
+* Send a PDF body to a classic Node-style response object
+* (`http.ServerResponse` or Express `res`).
+*
+* This calls {@link NodeServerResponseLike.writeHead} with the status and
+* {@link pdfHeaders}, then {@link NodeServerResponseLike.end} with the body.
+*
+* @param res      The response object (structural typing — no import).
+* @param bytes    The PDF body.
+* @param options  Optional response shaping (see {@link PdfResponseOptions}).
+*/
+function sendPdfToNodeResponse(res, bytes, options) {
+	const opts = options ?? {};
+	const headers = pdfHeaders(bytes.byteLength, opts);
+	res.writeHead(opts.status ?? 200, headers);
+	res.end(bytes);
+}
+//#endregion
 //#region src/render/matrix.ts
 /** The identity transform. */
 function identity() {
@@ -35994,6 +37844,6 @@ async function initWasm(options) {
 	wasmInitialized = true;
 }
 //#endregion
-export { feBlend as $, getLinearizationInfo as $a, encodeEan13 as $i, generateCiiXml as $n, generateUnderlineAppearance as $o, flattenForm as $r, validatePdfX as $t, buildSoftMaskNone as A, generatePdfAXmpBytes as Aa, applyPreset as Ai, decodeWoff as An, PdfCaretAnnotation as Ao, buildPieceInfo as Ar, parseVariableFont as At, redactRegions as B, isValidLevel as Ba, readEan8 as Bi, renderToPdf as Bn, PdfHighlightAnnotation as Bo, StreamingPdfParser as Br, verifyOfflineRevocation as Bt, tagTableHeaderCell as C, downscaleImage as Ca, toRoman as Ci, validateFieldValue as Cn, saveIncrementalWithSignaturePreservation as Co, SARIF_SCHEMA_URI as Cr, buildCoonsPatchShading as Ct, buildImageSoftMask as D, applyRedaction as Da, shrinkFontSize as Di, parseAcrobatDate as Dn, requestTimestamp as Do, PDF2_NAMESPACE as Dr, getColorGlyphLayers as Dt, buildColorKeyMask as E, recompressImage as Ea, estimateTextWidth as Ei, formatDate as En, parseTimestampResponse as Eo, MATHML_NAMESPACE as Er, buildTensorPatchShading as Et, attachAssociatedFiles as F, extractXmpMetadata as Fa, stripedPreset as Fi, createWorkerPool as Fn, PdfCircleAnnotation as Fo, tableToCsv as Fr, verifyRedactions as Ft, extractImages as G, buildOutputIntent as Ga, dataMatrixToOperators as Gi, generateXRechnungCii as Gn, generateCircleAppearance as Go, batchMerge as Gr, buildCertificateChain as Gt, compareImages as H, generateWinAnsiToUnicodeCmap as Ha, renderStyledBarcode as Hi, resolveFallback as Hn, PdfStrikeOutAnnotation as Ho, enforcePdfUa as Hr, validateCertificatePolicy as Ht, registerEmbeddedFile as I, parseXmpMetadata as Ia, readBarcode as Ii, buildPdfVtDParts as In, PdfLineAnnotation as Io, tableToJson as Ir, sanitizePdf as It, renderPageToCanvas as J, detectTransparency as Ja, encodeUpcA as Ji, buildFunctionShading as Jn, generateInkAppearance as Jo, getBookmarks as Jr, layoutColumns as Jt, generateThumbnail as K, SRGB_ICC_PROFILE as Ka, encodeDataMatrix as Ki, buildPdfA4Xmp as Kn, generateFreeTextAppearance as Ko, processBatch as Kr, validateCertificateChain as Kt, RenderCache as L, validateXmpMetadata as La, readCode128 as Li, buildVtDpm as Ln, PdfPolyLineAnnotation as Lo, accessibilityPlugin as Lr, scanPdfThreats as Lt, buildUnencryptedWrapper as M, stripProhibitedFeatures as Ma, borderedPreset as Mi, isWoff2 as Mn, PdfRedactAnnotation as Mo, buildRequirements as Mr, reorderVisual as Mt, attachOutputIntents as N, buildAfArray as Na, minimalPreset as Ni, readWoffHeader as Nn, PdfInkAnnotation as No, buildDPartRoot as Nr, resolveBidi as Nt, buildStencilMask as O, enforcePdfAFull as Oa, truncateText as Oi, AFNumber_Format as On, searchTextItems as Oo, buildNamespace as Or, parseColorFont as Ot, buildPageOutputIntent as P, createAssociatedFile as Pa, professionalPreset as Pi, signDeferred as Pn, PdfStampAnnotation as Po, extractTables as Pr, inspectEncryption as Pt, interpretPage as Q, delinearizePdf as Qa, ean8ToOperators as Qi, renderCodeFrame as Qn, generateStrikeOutAppearance as Qo, flattenFields as Qr, enforcePdfX as Qt, computeTileGrid as R, getProfile as Ra, readCode39 as Ri, gtsPdfVtVersion as Rn, PdfPolygonAnnotation as Ro, metadataPlugin as Rr, buildCertPath as Rt, tagTableDataCell as S, analyzeJpegMarkers as Sa, toAlpha as Si, setFieldVisibility as Sn, parseExistingTrailer as So, DEFAULT_SARIF_TOOL_NAME as Sr, xyzToLab as St, buildBlackPointCompensationExtGState as T, optimizeImage as Ta, ellipsisText as Ti, AFDate_FormatEx as Tn, buildTimestampRequest as To, toSarif as Tr, buildLatticeFormGouraudShading as Tt, comparePages as U, generateZapfDingbatsToUnicodeCmap as Ua, encodePdf417 as Ui, splitByScript as Un, PdfUnderlineAnnotation as Uo, validatePdfUa as Ur, validateExtendedKeyUsage as Ut, applyOcr as V, generateSymbolToUnicodeCmap as Va, calculateBarcodeDimensions as Vi, createRangeFetcher as Vn, PdfSquigglyAnnotation as Vo, PdfDocumentBuilder as Vr, EKU_OIDS as Vt, extractFonts as W, getToUnicodeCmap as Wa, pdf417ToOperators as Wi, generateOrderX as Wn, PdfFreeTextAnnotation as Wo, batchFlatten as Wr, validateKeyUsage as Wt, renderPageToImage as X, enforcePdfA as Xa, calculateEanCheckDigit as Xi, didYouMean as Xn, generateSquareAppearance as Xo, removeBookmark as Xr, layoutTextFlow as Xt, rasterize as Y, flattenTransparency as Ya, upcAToOperators as Yi, sampleShadingColor as Yn, generateLineAppearance as Yo, removeAllBookmarks as Yr, layoutParagraph as Yt, interpretContentStream as Z, validatePdfA as Za, ean13ToOperators as Zi, levenshtein as Zn, generateSquigglyAppearance as Zo, flattenField as Zr, buildPdfXOutputIntent as Zt, tagLink as _, convertTiffCmykToRgb as _a, UnexpectedFieldTypeError as _i, createSandbox as _n, getCertificationLevel as _o, buildDocTimeStampDict as _r, rgbToLab as _t, assembleFacturX as a, encodeCode39 as aa, FieldExistsAsNonTerminalError as ai, upscale8To16 as an, buildDssDictionary as ao, buildSampledTransferFunction as ar, PDFOperator as as, feOffset as at, tagParagraph as b, extractJpegMetadata as ba, formatDate$1 as bi, setFieldValue as bn, appendIncrementalUpdate as bo, buildLab as br, deviceRgbToXyz as bt, buildWtpdfIdentificationXmp as c, encodeCode128Values as ca, InvalidColorError as ci, decodeTileRegion as cn, addCounterSignature as co, buildType5Halftone as cr, ChangeTracker as cs, hasImageDecoder as ct, autoTagPage as d, canDirectEmbed as da, MissingOnValueCheckError as di, TrustStore as dn, addFieldLock as do, evaluateFunction as dr, detectNextGenFormat as dt, encodeEan8 as ea, BatchProcessingError as ei, downscale16To8 as en, isLinearized as eo, buildBoxDict as er, PdfLinkAnnotation as es, feColorMatrix as et, buildPdfUa2Xmp as f, embedTiffDirect as fa, NoSuchFieldError as fi, downloadCrl as fn, buildFieldLockDict as fo, markdownToPdf as fr, probeNextGenImage as ft, tagHeading as g, webpToPng as ga, StreamingParseError as gi, extractOcspUrl as gn, buildDocMdpReference as go, DEFAULT_DOC_TIMESTAMP_CONTENTS_SIZE as gr, rgbToHsv as gt, tagFigure as h, webpToJpeg as ha, RichTextFieldReadError as hi, checkCertificateStatus as hn, MdpPermission as ho, reconstructParagraphs as hr, rgbToHsl as ht, validateEn16931 as i, computeCode39CheckDigit as ia, FieldAlreadyExistsError as ii, summarizeBitDepth as in, optimizeIncrementalSave as io, STANDARD_SPOT_FUNCTIONS as ir, parseXmpMetadata$1 as is, feGaussianBlur as it, buildEncryptedPayload as j, countOccurrences as ja, applyTablePreset as ji, isWoff as jn, PdfPopupAnnotation as jo, buildRequirement as jr, resolveInstanceCoordinates as jt, buildSoftMaskGroupExtGState as k, generatePdfAXmp as ka, wrapText$2 as ki, formatNumber$1 as kn, PdfFileAttachmentAnnotation as ko, buildNamespacesArray as kr, normalizeAxisCoordinate as kt, convertPdfAConformanceXmp as l, valuesToModules as la, InvalidFieldNamePartError as li, parseTileInfo as ln, getCounterSignatures as lo, identityTransferFunction as lr, saveDocumentIncremental as ls, registerImageDecoder as lt, LIST_NUMBERING_KEY as m, recompressWebP as ma, RemovePageFromEmptyDocumentError as mi, isCertificateRevoked as mn, detectModifications as mo, reconstructLines as mr, hsvToRgb as mt, detectFacturXProfile as n, itfToOperators as na, EncryptedPdfError as ni, normalizeComponentDepth as nn, computeObjectHash as no, buildPdfX6OutputIntent as nr, buildXmpMetadata as ns, feComposite as nt, buildFacturXXmp as o, code128ToOperators as oa, FontNotEmbeddedError as oi, assembleTiles as on, embedLtvData as oo, buildThresholdHalftone as or, buildDeviceNColorSpace as os, decodeRegisteredImage as ot, validatePdfUa2 as p, encodePngFromPixels as pa, PluginError as pi, extractCrlUrls as pn, getFieldLocks as po, buildCollection as pr, hslToRgb as pt, renderDisplayListToCanvas as q, generateSrgbIccProfile as qa, calculateUpcCheckDigit as qi, pdfA4Rules as qn, generateHighlightAppearance as qo, addBookmark as qr, findHyphenationPoints as qt, parseCiiXml as r, code39ToOperators as ra, ExceededMaxLengthError as ri, offsetSignedToUnsigned as rn, findChangedObjects as ro, validateBoxGeometry as rr, createXmpStream as rs, feFlood as rt, buildPdfRIdentificationXmp as s, encodeCode128 as sa, ForeignPageError as si, decodeTile as sn, hasLtvData as so, buildType1Halftone as sr, buildSeparationColorSpace as ss, getImageDecoder as st, initWasm as t, encodeItf as ta, CombedTextLayoutError as ti, getComponentDepths as tn, linearizePdf as to, buildGtsPdfxVersion as tr, PdfTextAnnotation as ts, feColorMatrixSaturate as tt, preflightPdfA as u, PdfWorker as ua, InvalidPageSizeError as ui, verifySignatureDetailed as un, diffSignedContent as uo, nameHalftone as ur, saveIncremental as us, unregisterImageDecoder as ut, tagList as v, embedTiffCmyk as va, applyHeaderFooter as vi, getFieldValue as vn, setCertificationLevel as vo, buildCalGray as vr, rgbToXyz as vt, tagTableRow as w, estimateJpegQuality as wa, applyOverflow as wi, AFSpecial_Format as wn, validateByteRangeIntegrity as wo, toJsonReport as wr, buildFreeFormGouraudShading as wt, tagTable as x, injectJpegMetadata as xa, replaceTemplateVariables as xi, addVisibilityAction as xn, findExistingSignatures as xo, labToRgb as xr, parseIccTransform as xt, tagListItem as y, isCmykTiff as ya, applyHeaderFooterToPage as yi, resolveFieldReference as yn, validateSignatureChain as yo, buildCalRGB as yr, xyzToRgb as yt, renderPageTile as z, getSupportedLevels as za, readEan13 as zi, h as zn, PdfSquareAnnotation as zo, timestampPlugin as zr, extractEmbeddedRevocationData as zt };
+export { pdfHeaders as $, buildAfArray as $a, minimalPreset as $i, readWoffHeader as $n, PdfInkAnnotation as $o, buildDPartRoot as $r, resolveBidi as $t, buildSoftMaskNone as A, PdfWorker as Aa, InvalidPageSizeError as Ai, verifySignatureDetailed as An, diffSignedContent as Ao, nameHalftone as Ar, saveIncremental as As, unregisterImageDecoder as At, redactRegions as B, extractJpegMetadata as Ba, formatDate$1 as Bi, setFieldValue as Bn, appendIncrementalUpdate as Bo, buildLab as Br, deviceRgbToXyz as Bt, tagTableHeaderCell as C, code39ToOperators as Ca, ExceededMaxLengthError as Ci, offsetSignedToUnsigned as Cn, findChangedObjects as Co, validateBoxGeometry as Cr, createXmpStream as Cs, feFlood as Ct, buildImageSoftMask as D, encodeCode128 as Da, ForeignPageError as Di, decodeTile as Dn, hasLtvData as Do, buildType1Halftone as Dr, buildSeparationColorSpace as Ds, getImageDecoder as Dt, buildColorKeyMask as E, code128ToOperators as Ea, FontNotEmbeddedError as Ei, assembleTiles as En, embedLtvData as Eo, buildThresholdHalftone as Er, buildDeviceNColorSpace as Es, decodeRegisteredImage as Et, attachAssociatedFiles as F, webpToJpeg as Fa, RichTextFieldReadError as Fi, checkCertificateStatus as Fn, MdpPermission as Fo, reconstructParagraphs as Fr, rgbToHsl as Ft, extractImages as G, optimizeImage as Ga, ellipsisText as Gi, AFDate_FormatEx as Gn, buildTimestampRequest as Go, toSarif as Gr, buildLatticeFormGouraudShading as Gt, compareImages as H, analyzeJpegMarkers as Ha, toAlpha as Hi, setFieldVisibility as Hn, parseExistingTrailer as Ho, DEFAULT_SARIF_TOOL_NAME as Hr, xyzToLab as Ht, registerEmbeddedFile as I, webpToPng as Ia, StreamingParseError as Ii, extractOcspUrl as In, buildDocMdpReference as Io, DEFAULT_DOC_TIMESTAMP_CONTENTS_SIZE as Ir, rgbToHsv as It, renderPageToCanvas as J, enforcePdfAFull as Ja, truncateText as Ji, AFNumber_Format as Jn, searchTextItems as Jo, buildNamespace as Jr, parseColorFont as Jt, generateThumbnail as K, recompressImage as Ka, estimateTextWidth as Ki, formatDate as Kn, parseTimestampResponse as Ko, MATHML_NAMESPACE as Kr, buildTensorPatchShading as Kt, RenderCache as L, convertTiffCmykToRgb as La, UnexpectedFieldTypeError as Li, createSandbox as Ln, getCertificationLevel as Lo, buildDocTimeStampDict as Lr, rgbToLab as Lt, buildUnencryptedWrapper as M, embedTiffDirect as Ma, NoSuchFieldError as Mi, downloadCrl as Mn, buildFieldLockDict as Mo, markdownToPdf as Mr, probeNextGenImage as Mt, attachOutputIntents as N, encodePngFromPixels as Na, PluginError as Ni, extractCrlUrls as Nn, getFieldLocks as No, buildCollection as Nr, hslToRgb as Nt, buildStencilMask as O, encodeCode128Values as Oa, InvalidColorError as Oi, decodeTileRegion as On, addCounterSignature as Oo, buildType5Halftone as Or, ChangeTracker as Os, hasImageDecoder as Ot, buildPageOutputIntent as P, recompressWebP as Pa, RemovePageFromEmptyDocumentError as Pi, isCertificateRevoked as Pn, detectModifications as Po, reconstructLines as Pr, hsvToRgb as Pt, interpretPage as Q, stripProhibitedFeatures as Qa, borderedPreset as Qi, isWoff2 as Qn, PdfRedactAnnotation as Qo, buildRequirements as Qr, reorderVisual as Qt, computeTileGrid as R, embedTiffCmyk as Ra, applyHeaderFooter as Ri, getFieldValue as Rn, setCertificationLevel as Ro, buildCalGray as Rr, rgbToXyz as Rt, tagTableDataCell as S, itfToOperators as Sa, EncryptedPdfError as Si, normalizeComponentDepth as Sn, computeObjectHash as So, buildPdfX6OutputIntent as Sr, buildXmpMetadata as Ss, feComposite as St, buildBlackPointCompensationExtGState as T, encodeCode39 as Ta, FieldExistsAsNonTerminalError as Ti, upscale8To16 as Tn, buildDssDictionary as To, buildSampledTransferFunction as Tr, PDFOperator as Ts, feOffset as Tt, comparePages as U, downscaleImage as Ua, toRoman as Ui, validateFieldValue as Un, saveIncrementalWithSignaturePreservation as Uo, SARIF_SCHEMA_URI as Ur, buildCoonsPatchShading as Ut, applyOcr as V, injectJpegMetadata as Va, replaceTemplateVariables as Vi, addVisibilityAction as Vn, findExistingSignatures as Vo, labToRgb as Vr, parseIccTransform as Vt, extractFonts as W, estimateJpegQuality as Wa, applyOverflow as Wi, AFSpecial_Format as Wn, validateByteRangeIntegrity as Wo, toJsonReport as Wr, buildFreeFormGouraudShading as Wt, renderPageToImage as X, generatePdfAXmpBytes as Xa, applyPreset as Xi, decodeWoff as Xn, PdfCaretAnnotation as Xo, buildPieceInfo as Xr, parseVariableFont as Xt, rasterize as Y, generatePdfAXmp as Ya, wrapText$2 as Yi, formatNumber$1 as Yn, PdfFileAttachmentAnnotation as Yo, buildNamespacesArray as Yr, normalizeAxisCoordinate as Yt, interpretContentStream as Z, countOccurrences as Za, applyTablePreset as Zi, isWoff as Zn, PdfPopupAnnotation as Zo, buildRequirement as Zr, resolveInstanceCoordinates as Zt, tagLink as _, ean13ToOperators as _a, flattenField as _i, buildPdfXOutputIntent as _n, validatePdfA as _o, levenshtein as _r, generateSquigglyAppearance as _s, SharedRingBuffer as _t, assembleFacturX as a, readEan13 as aa, timestampPlugin as ai, extractEmbeddedRevocationData as an, getSupportedLevels as ao, h$1 as ar, PdfSquareAnnotation as as, h as at, tagParagraph as b, encodeEan8 as ba, BatchProcessingError as bi, downscale16To8 as bn, isLinearized as bo, buildBoxDict as br, PdfLinkAnnotation as bs, feColorMatrix as bt, buildWtpdfIdentificationXmp as c, renderStyledBarcode as ca, enforcePdfUa as ci, validateCertificatePolicy as cn, generateWinAnsiToUnicodeCmap as co, resolveFallback as cr, PdfStrikeOutAnnotation as cs, renderToPdf as ct, autoTagPage as d, dataMatrixToOperators as da, batchMerge as di, buildCertificateChain as dn, buildOutputIntent as do, generateXRechnungCii as dr, generateCircleAppearance as ds, isWasmSimdSupported as dt, professionalPreset as ea, extractTables as ei, inspectEncryption as en, createAssociatedFile as eo, signDeferred as er, PdfStampAnnotation as es, pdfResponse as et, buildPdfUa2Xmp as f, encodeDataMatrix as fa, processBatch as fi, validateCertificateChain as fn, SRGB_ICC_PROFILE as fo, buildPdfA4Xmp as fr, generateFreeTextAppearance as fs, MemoryBudget as ft, tagHeading as g, calculateEanCheckDigit as ga, removeBookmark as gi, layoutTextFlow as gn, enforcePdfA as go, didYouMean as gr, generateSquareAppearance as gs, SharedFlag as gt, tagFigure as h, upcAToOperators as ha, removeAllBookmarks as hi, layoutParagraph as hn, flattenTransparency as ho, sampleShadingColor as hr, generateLineAppearance as hs, SharedCounter as ht, validateEn16931 as i, readCode39 as ia, metadataPlugin as ii, buildCertPath as in, getProfile as io, gtsPdfVtVersion as ir, PdfPolygonAnnotation as is, Fragment as it, buildEncryptedPayload as j, canDirectEmbed as ja, MissingOnValueCheckError as ji, TrustStore as jn, addFieldLock as jo, evaluateFunction as jr, detectNextGenFormat as jt, buildSoftMaskGroupExtGState as k, valuesToModules as ka, InvalidFieldNamePartError as ki, parseTileInfo as kn, getCounterSignatures as ko, identityTransferFunction as kr, saveDocumentIncremental as ks, registerImageDecoder as kt, convertPdfAConformanceXmp as l, encodePdf417 as la, validatePdfUa as li, validateExtendedKeyUsage as ln, generateZapfDingbatsToUnicodeCmap as lo, splitByScript as lr, PdfUnderlineAnnotation as ls, SIMD_NOTE as lt, LIST_NUMBERING_KEY as m, encodeUpcA as ma, getBookmarks as mi, layoutColumns as mn, detectTransparency as mo, buildFunctionShading as mr, generateInkAppearance as ms, createMemoryBudget as mt, detectFacturXProfile as n, readBarcode as na, tableToJson as ni, sanitizePdf as nn, parseXmpMetadata as no, buildPdfVtDParts as nr, PdfLineAnnotation as ns, sendPdfToNodeResponse as nt, buildFacturXXmp as o, readEan8 as oa, StreamingPdfParser as oi, verifyOfflineRevocation as on, isValidLevel as oo, renderToPdf$1 as or, PdfHighlightAnnotation as os, jsx as ot, validatePdfUa2 as p, calculateUpcCheckDigit as pa, addBookmark as pi, findHyphenationPoints as pn, generateSrgbIccProfile as po, pdfA4Rules as pr, generateHighlightAppearance as ps, MemoryBudgetExceededError as pt, renderDisplayListToCanvas as q, applyRedaction as qa, shrinkFontSize as qi, parseAcrobatDate as qn, requestTimestamp as qo, PDF2_NAMESPACE as qr, getColorGlyphLayers as qt, parseCiiXml as r, readCode128 as ra, accessibilityPlugin as ri, scanPdfThreats as rn, validateXmpMetadata as ro, buildVtDpm as rr, PdfPolyLineAnnotation as rs, buildFormFromJsonSchema as rt, buildPdfRIdentificationXmp as s, calculateBarcodeDimensions as sa, PdfDocumentBuilder as si, EKU_OIDS as sn, generateSymbolToUnicodeCmap as so, createRangeFetcher as sr, PdfSquigglyAnnotation as ss, jsxs as st, initWasm as t, stripedPreset as ta, tableToCsv as ti, verifyRedactions as tn, extractXmpMetadata as to, createWorkerPool as tr, PdfCircleAnnotation as ts, pdfStreamResponse as tt, preflightPdfA as u, pdf417ToOperators as ua, batchFlatten as ui, validateKeyUsage as un, getToUnicodeCmap as uo, generateOrderX as ur, PdfFreeTextAnnotation as us, detectRuntimeCapabilities as ut, tagList as v, ean8ToOperators as va, flattenFields as vi, enforcePdfX as vn, delinearizePdf as vo, renderCodeFrame as vr, generateStrikeOutAppearance as vs, isSharedMemoryAvailable as vt, tagTableRow as w, computeCode39CheckDigit as wa, FieldAlreadyExistsError as wi, summarizeBitDepth as wn, optimizeIncrementalSave as wo, STANDARD_SPOT_FUNCTIONS as wr, parseXmpMetadata$1 as ws, feGaussianBlur as wt, tagTable as x, encodeItf as xa, CombedTextLayoutError as xi, getComponentDepths as xn, linearizePdf as xo, buildGtsPdfxVersion as xr, PdfTextAnnotation as xs, feColorMatrixSaturate as xt, tagListItem as y, encodeEan13 as ya, flattenForm as yi, validatePdfX as yn, getLinearizationInfo as yo, generateCiiXml as yr, generateUnderlineAppearance as ys, feBlend as yt, renderPageTile as z, isCmykTiff as za, applyHeaderFooterToPage as zi, resolveFieldReference as zn, validateSignatureChain as zo, buildCalRGB as zr, xyzToRgb as zt };
 
-//# sourceMappingURL=src-DlRTrvWg.mjs.map
+//# sourceMappingURL=src-wZnfMPwi.mjs.map