modern-pdf-lib 0.38.0 → 0.40.0

package/dist/{src-B0gmgVEs.cjs → src-aDYhSnal.cjs}

@@ -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 = require_pdfDocument.createPdf();
 	const body = await doc.embedFont(require_pdfDocument.StandardFonts.Helvetica);
 	const bold = await doc.embedFont(require_pdfDocument.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,260 +32167,2110 @@ function feBlend(a, b, mode) {
 	return out;
 }
 //#endregion
-//#region src/render/matrix.ts
-/** The identity transform. */
-function identity() {
-	return [
-		1,
-		0,
-		0,
-		1,
-		0,
-		0
-	];
-}
+//#region src/runtime/sharedConcurrency.ts
 /**
-* Concatenate two transforms: the result applies `m` **first**, then `n`
-* (i.e. `point · m · n`). This matches the PDF `cm` operator, where the new
-* CTM is `cmMatrix × CTM`.
+* @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'`.
 */
-function multiply(m, n) {
-	return [
-		m[0] * n[0] + m[1] * n[2],
-		m[0] * n[1] + m[1] * n[3],
-		m[2] * n[0] + m[3] * n[2],
-		m[2] * n[1] + m[3] * n[3],
-		m[4] * n[0] + m[5] * n[2] + n[4],
-		m[4] * n[1] + m[5] * n[3] + n[5]
-	];
-}
-/** Apply a transform to a point, returning the transformed `[x, y]`. */
-function applyToPoint(m, x, y) {
-	return [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];
-}
-/** A pure translation transform. */
-function translation(tx, ty) {
-	return [
-		1,
-		0,
-		0,
-		1,
-		tx,
-		ty
-	];
-}
 /**
-* The magnitude by which `m` scales lengths — the geometric mean of the
-* x- and y-axis scale factors (`sqrt(|det|)`). Used to map a user-space line
-* width to device space.
+* Bytes per `Int32Array` element. Atomics operate on 32-bit integer views.
 */
-function meanScale(m) {
-	const det = m[0] * m[3] - m[1] * m[2];
-	return Math.sqrt(Math.abs(det));
+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);
 }
-//#endregion
-//#region src/render/interpreter.ts
 /**
-* @module render/interpreter
+* Report whether shared-memory concurrency is usable in this runtime.
 *
-* Executes a parsed PDF content stream through a graphics-state machine,
-* producing a resolution-independent {@link DisplayList} (page space, y-up).
-* This is the foundation the rasterizer and Canvas adapter render from.
+* 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.
 *
-* Supported operators: graphics state (`q`/`Q`/`cm`/`w`/`J`/`j`/`gs`), path
-* construction (`m`/`l`/`c`/`v`/`y`/`re`/`h`), path painting
-* (`f`/`F`/`f*`/`S`/`s`/`B`/`B*`/`b`/`b*`/`n`), clipping (`W`/`W*`), color
-* (`rg`/`RG`/`g`/`G`/`k`/`K`/`cs`/`CS`/`sc`/`scn`/`SC`/`SCN`), text
-* (`BT`/`ET`/`Tf`/`Td`/`TD`/`Tm`/`T*`/`Tc`/`Tw`/`Tz`/`TL`/`Ts`/`Tr`/`Tj`/`TJ`/`'`/`"`),
-* and XObjects (`Do`, recursing into form XObjects). Bézier curves are
-* flattened to polylines.
+* 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.
 *
-* @packageDocumentation
+* @returns `true` iff shared-memory primitives can be constructed and used.
 */
-function initialState$1() {
-	return {
-		ctm: identity(),
-		fill: [
-			0,
-			0,
-			0,
-			255
-		],
-		stroke: [
-			0,
-			0,
-			0,
-			255
-		],
-		lineWidth: 1,
-		lineCap: 0,
-		lineJoin: 0,
-		fillAlpha: 1,
-		strokeAlpha: 1,
-		clip: void 0,
-		font: void 0,
-		fontSize: 0,
-		charSpace: 0,
-		wordSpace: 0,
-		hScale: 1,
-		leading: 0,
-		rise: 0,
-		renderMode: 0
-	};
-}
-function cloneState(s) {
-	return { ...s };
-}
-function num$2(op) {
-	return typeof op === "number" ? op : 0;
-}
-function nameOf(op) {
-	if (op instanceof require_pdfObjects.PdfName) return op.value.replace(/^\//, "");
-	if (typeof op === "string") return op.replace(/^\//, "");
-}
-function clamp255(v) {
-	return Math.max(0, Math.min(255, Math.round(v * 255)));
-}
-function grayRgba(g) {
-	const v = clamp255(g);
-	return [
-		v,
-		v,
-		v,
-		255
-	];
-}
-function rgbRgba(r, g, b) {
-	return [
-		clamp255(r),
-		clamp255(g),
-		clamp255(b),
-		255
-	];
-}
-function cmykRgba(c, m, y, k) {
-	const [r, g, b] = require_pdfDocument.cmykToRgb(c, m, y, k);
-	return [
-		clamp255(r),
-		clamp255(g),
-		clamp255(b),
-		255
-	];
-}
-/** Interpret `sc`/`scn` numeric components by arity → RGBA. */
-function componentsToRgba(comps) {
-	if (comps.length === 1) return grayRgba(comps[0]);
-	if (comps.length === 3) return rgbRgba(comps[0], comps[1], comps[2]);
-	if (comps.length === 4) return cmykRgba(comps[0], comps[1], comps[2], comps[3]);
-}
-const BEZIER_STEPS = 16;
-function flattenCubic(out, p0, p1, p2, p3) {
-	for (let i = 1; i <= BEZIER_STEPS; i++) {
-		const t = i / BEZIER_STEPS;
-		const mt = 1 - t;
-		const a = mt * mt * mt;
-		const b = 3 * mt * mt * t;
-		const c = 3 * mt * t * t;
-		const d = t * t * t;
-		out.push(a * p0[0] + b * p1[0] + c * p2[0] + d * p3[0], a * p0[1] + b * p1[1] + c * p2[1] + d * p3[1]);
+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;
 	}
 }
 /**
-* Execute a parsed content stream into a {@link DisplayList}.
+* 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`.
 *
-* @param operators - Output of {@link parseContentStream}.
-* @param options   - Page dimensions and (optional) resources/registry.
+* All mutations use `Atomics`, so increments from concurrent agents never
+* lose updates.
 */
-function interpretContentStream(operators, options) {
-	const items = [];
-	const origin = options.origin ?? [0, 0];
-	interpretInto(items, operators, initialState$1(), options, 0);
-	return {
-		items,
-		width: options.width,
-		height: options.height,
-		origin
-	};
-}
-const MAX_FORM_DEPTH = 12;
-function interpretInto(items, operators, startState, options, depth) {
-	const stack = [];
-	let gs = startState;
-	let path = [];
-	let cur = null;
-	let curUser = [0, 0];
-	let curPage = [0, 0];
-	let pendingClip = null;
-	let tm = identity();
-	let tlm = identity();
-	const startSub = (x, y) => {
-		if (cur && cur.length >= 4) path.push({
-			points: cur,
-			closed: false
-		});
-		curUser = [x, y];
-		curPage = applyToPoint(gs.ctm, x, y);
-		cur = [curPage[0], curPage[1]];
-	};
-	const lineTo = (x, y) => {
-		if (!cur) startSub(x, y);
-		curUser = [x, y];
-		curPage = applyToPoint(gs.ctm, x, y);
-		cur.push(curPage[0], curPage[1]);
-	};
-	const finishPath = () => {
-		if (cur && cur.length >= 4) path.push({
-			points: cur,
-			closed: false
-		});
-		const result = path;
-		path = [];
-		cur = null;
-		return result;
-	};
-	const applyClipIfPending = (subs) => {
-		if (pendingClip) {
-			gs = {
-				...gs,
-				clip: subs.map((s) => ({
-					points: s.points.slice(),
-					closed: true
-				}))
-			};
-			pendingClip = null;
-		}
-	};
-	const pushOpen = (closed) => {
-		if (cur && cur.length >= 4) path.push({
-			points: cur,
-			closed
-		});
-		cur = null;
-	};
-	for (const { operator, operands } of operators) switch (operator) {
-		case "q":
-			stack.push(cloneState(gs));
-			break;
-		case "Q":
-			if (stack.length) gs = stack.pop();
-			break;
-		case "cm":
-			gs = {
-				...gs,
-				ctm: multiply([
-					num$2(operands[0]),
-					num$2(operands[1]),
-					num$2(operands[2]),
-					num$2(operands[3]),
-					num$2(operands[4]),
-					num$2(operands[5])
-				], gs.ctm)
-			};
-			break;
-		case "w":
-			gs = {
-				...gs,
-				lineWidth: num$2(operands[0])
+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 = require_pdfDocument.createPdf();
+	const ctx = new RenderContext(doc);
+	await ctx.init();
+	const docSize = resolvePageSize(documentEl?.props["size"], require_pdfDocument.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", require_pdfObjects.PdfArray.of([...refs]));
+		},
+		onBuildCatalog(catalog) {
+			if (!acroFormDict.has("/DR")) {
+				const helvetica = new require_pdfObjects.PdfDict();
+				helvetica.set("/Type", require_pdfObjects.PdfName.of("Font"));
+				helvetica.set("/Subtype", require_pdfObjects.PdfName.of("Type1"));
+				helvetica.set("/BaseFont", require_pdfObjects.PdfName.of("Helvetica"));
+				const fontDict = new require_pdfObjects.PdfDict();
+				fontDict.set("/Helv", helvetica);
+				const resources = new require_pdfObjects.PdfDict();
+				resources.set("/Font", fontDict);
+				acroFormDict.set("/DR", resources);
+			}
+			if (!acroFormDict.has("/DA")) acroFormDict.set("/DA", require_pdfObjects.PdfString.literal("/Helv 0 Tf 0 g"));
+			acroFormDict.set("/NeedAppearances", require_pdfObjects.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 = require_pdfDocument.createPdf();
+	const form = doc.getForm();
+	const pageSize = options?.pageSize ?? [require_pdfDocument.PageSizes.A4[0], require_pdfDocument.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: require_pdfDocument.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 ? require_pdfDocument.rgb(.6, 0, 0) : require_pdfDocument.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: require_pdfDocument.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", require_pdfObjects.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() {
+	return [
+		1,
+		0,
+		0,
+		1,
+		0,
+		0
+	];
+}
+/**
+* Concatenate two transforms: the result applies `m` **first**, then `n`
+* (i.e. `point · m · n`). This matches the PDF `cm` operator, where the new
+* CTM is `cmMatrix × CTM`.
+*/
+function multiply(m, n) {
+	return [
+		m[0] * n[0] + m[1] * n[2],
+		m[0] * n[1] + m[1] * n[3],
+		m[2] * n[0] + m[3] * n[2],
+		m[2] * n[1] + m[3] * n[3],
+		m[4] * n[0] + m[5] * n[2] + n[4],
+		m[4] * n[1] + m[5] * n[3] + n[5]
+	];
+}
+/** Apply a transform to a point, returning the transformed `[x, y]`. */
+function applyToPoint(m, x, y) {
+	return [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];
+}
+/** A pure translation transform. */
+function translation(tx, ty) {
+	return [
+		1,
+		0,
+		0,
+		1,
+		tx,
+		ty
+	];
+}
+/**
+* The magnitude by which `m` scales lengths — the geometric mean of the
+* x- and y-axis scale factors (`sqrt(|det|)`). Used to map a user-space line
+* width to device space.
+*/
+function meanScale(m) {
+	const det = m[0] * m[3] - m[1] * m[2];
+	return Math.sqrt(Math.abs(det));
+}
+//#endregion
+//#region src/render/interpreter.ts
+/**
+* @module render/interpreter
+*
+* Executes a parsed PDF content stream through a graphics-state machine,
+* producing a resolution-independent {@link DisplayList} (page space, y-up).
+* This is the foundation the rasterizer and Canvas adapter render from.
+*
+* Supported operators: graphics state (`q`/`Q`/`cm`/`w`/`J`/`j`/`gs`), path
+* construction (`m`/`l`/`c`/`v`/`y`/`re`/`h`), path painting
+* (`f`/`F`/`f*`/`S`/`s`/`B`/`B*`/`b`/`b*`/`n`), clipping (`W`/`W*`), color
+* (`rg`/`RG`/`g`/`G`/`k`/`K`/`cs`/`CS`/`sc`/`scn`/`SC`/`SCN`), text
+* (`BT`/`ET`/`Tf`/`Td`/`TD`/`Tm`/`T*`/`Tc`/`Tw`/`Tz`/`TL`/`Ts`/`Tr`/`Tj`/`TJ`/`'`/`"`),
+* and XObjects (`Do`, recursing into form XObjects). Bézier curves are
+* flattened to polylines.
+*
+* @packageDocumentation
+*/
+function initialState$1() {
+	return {
+		ctm: identity(),
+		fill: [
+			0,
+			0,
+			0,
+			255
+		],
+		stroke: [
+			0,
+			0,
+			0,
+			255
+		],
+		lineWidth: 1,
+		lineCap: 0,
+		lineJoin: 0,
+		fillAlpha: 1,
+		strokeAlpha: 1,
+		clip: void 0,
+		font: void 0,
+		fontSize: 0,
+		charSpace: 0,
+		wordSpace: 0,
+		hScale: 1,
+		leading: 0,
+		rise: 0,
+		renderMode: 0
+	};
+}
+function cloneState(s) {
+	return { ...s };
+}
+function num$2(op) {
+	return typeof op === "number" ? op : 0;
+}
+function nameOf(op) {
+	if (op instanceof require_pdfObjects.PdfName) return op.value.replace(/^\//, "");
+	if (typeof op === "string") return op.replace(/^\//, "");
+}
+function clamp255(v) {
+	return Math.max(0, Math.min(255, Math.round(v * 255)));
+}
+function grayRgba(g) {
+	const v = clamp255(g);
+	return [
+		v,
+		v,
+		v,
+		255
+	];
+}
+function rgbRgba(r, g, b) {
+	return [
+		clamp255(r),
+		clamp255(g),
+		clamp255(b),
+		255
+	];
+}
+function cmykRgba(c, m, y, k) {
+	const [r, g, b] = require_pdfDocument.cmykToRgb(c, m, y, k);
+	return [
+		clamp255(r),
+		clamp255(g),
+		clamp255(b),
+		255
+	];
+}
+/** Interpret `sc`/`scn` numeric components by arity → RGBA. */
+function componentsToRgba(comps) {
+	if (comps.length === 1) return grayRgba(comps[0]);
+	if (comps.length === 3) return rgbRgba(comps[0], comps[1], comps[2]);
+	if (comps.length === 4) return cmykRgba(comps[0], comps[1], comps[2], comps[3]);
+}
+const BEZIER_STEPS = 16;
+function flattenCubic(out, p0, p1, p2, p3) {
+	for (let i = 1; i <= BEZIER_STEPS; i++) {
+		const t = i / BEZIER_STEPS;
+		const mt = 1 - t;
+		const a = mt * mt * mt;
+		const b = 3 * mt * mt * t;
+		const c = 3 * mt * t * t;
+		const d = t * t * t;
+		out.push(a * p0[0] + b * p1[0] + c * p2[0] + d * p3[0], a * p0[1] + b * p1[1] + c * p2[1] + d * p3[1]);
+	}
+}
+/**
+* Execute a parsed content stream into a {@link DisplayList}.
+*
+* @param operators - Output of {@link parseContentStream}.
+* @param options   - Page dimensions and (optional) resources/registry.
+*/
+function interpretContentStream(operators, options) {
+	const items = [];
+	const origin = options.origin ?? [0, 0];
+	interpretInto(items, operators, initialState$1(), options, 0);
+	return {
+		items,
+		width: options.width,
+		height: options.height,
+		origin
+	};
+}
+const MAX_FORM_DEPTH = 12;
+function interpretInto(items, operators, startState, options, depth) {
+	const stack = [];
+	let gs = startState;
+	let path = [];
+	let cur = null;
+	let curUser = [0, 0];
+	let curPage = [0, 0];
+	let pendingClip = null;
+	let tm = identity();
+	let tlm = identity();
+	const startSub = (x, y) => {
+		if (cur && cur.length >= 4) path.push({
+			points: cur,
+			closed: false
+		});
+		curUser = [x, y];
+		curPage = applyToPoint(gs.ctm, x, y);
+		cur = [curPage[0], curPage[1]];
+	};
+	const lineTo = (x, y) => {
+		if (!cur) startSub(x, y);
+		curUser = [x, y];
+		curPage = applyToPoint(gs.ctm, x, y);
+		cur.push(curPage[0], curPage[1]);
+	};
+	const finishPath = () => {
+		if (cur && cur.length >= 4) path.push({
+			points: cur,
+			closed: false
+		});
+		const result = path;
+		path = [];
+		cur = null;
+		return result;
+	};
+	const applyClipIfPending = (subs) => {
+		if (pendingClip) {
+			gs = {
+				...gs,
+				clip: subs.map((s) => ({
+					points: s.points.slice(),
+					closed: true
+				}))
+			};
+			pendingClip = null;
+		}
+	};
+	const pushOpen = (closed) => {
+		if (cur && cur.length >= 4) path.push({
+			points: cur,
+			closed
+		});
+		cur = null;
+	};
+	for (const { operator, operands } of operators) switch (operator) {
+		case "q":
+			stack.push(cloneState(gs));
+			break;
+		case "Q":
+			if (stack.length) gs = stack.pop();
+			break;
+		case "cm":
+			gs = {
+				...gs,
+				ctm: multiply([
+					num$2(operands[0]),
+					num$2(operands[1]),
+					num$2(operands[2]),
+					num$2(operands[3]),
+					num$2(operands[4]),
+					num$2(operands[5])
+				], gs.ctm)
+			};
+			break;
+		case "w":
+			gs = {
+				...gs,
+				lineWidth: num$2(operands[0])
 			};
 			break;
 		case "J":
@@ -36084,6 +37934,12 @@ Object.defineProperty(exports, "ForeignPageError", {
 		return ForeignPageError;
 	}
 });
+Object.defineProperty(exports, "Fragment", {
+	enumerable: true,
+	get: function() {
+		return Fragment;
+	}
+});
 Object.defineProperty(exports, "InvalidColorError", {
 	enumerable: true,
 	get: function() {
@@ -36120,6 +37976,18 @@ Object.defineProperty(exports, "MdpPermission", {
 		return MdpPermission;
 	}
 });
+Object.defineProperty(exports, "MemoryBudget", {
+	enumerable: true,
+	get: function() {
+		return MemoryBudget;
+	}
+});
+Object.defineProperty(exports, "MemoryBudgetExceededError", {
+	enumerable: true,
+	get: function() {
+		return MemoryBudgetExceededError;
+	}
+});
 Object.defineProperty(exports, "MissingOnValueCheckError", {
 	enumerable: true,
 	get: function() {
@@ -36294,6 +38162,12 @@ Object.defineProperty(exports, "SARIF_SCHEMA_URI", {
 		return SARIF_SCHEMA_URI;
 	}
 });
+Object.defineProperty(exports, "SIMD_NOTE", {
+	enumerable: true,
+	get: function() {
+		return SIMD_NOTE;
+	}
+});
 Object.defineProperty(exports, "SRGB_ICC_PROFILE", {
 	enumerable: true,
 	get: function() {
@@ -36306,6 +38180,24 @@ Object.defineProperty(exports, "STANDARD_SPOT_FUNCTIONS", {
 		return STANDARD_SPOT_FUNCTIONS;
 	}
 });
+Object.defineProperty(exports, "SharedCounter", {
+	enumerable: true,
+	get: function() {
+		return SharedCounter;
+	}
+});
+Object.defineProperty(exports, "SharedFlag", {
+	enumerable: true,
+	get: function() {
+		return SharedFlag;
+	}
+});
+Object.defineProperty(exports, "SharedRingBuffer", {
+	enumerable: true,
+	get: function() {
+		return SharedRingBuffer;
+	}
+});
 Object.defineProperty(exports, "StreamingParseError", {
 	enumerable: true,
 	get: function() {
@@ -36570,6 +38462,12 @@ Object.defineProperty(exports, "buildFieldLockDict", {
 		return buildFieldLockDict;
 	}
 });
+Object.defineProperty(exports, "buildFormFromJsonSchema", {
+	enumerable: true,
+	get: function() {
+		return buildFormFromJsonSchema;
+	}
+});
 Object.defineProperty(exports, "buildFreeFormGouraudShading", {
 	enumerable: true,
 	get: function() {
@@ -36864,6 +38762,12 @@ Object.defineProperty(exports, "createAssociatedFile", {
 		return createAssociatedFile;
 	}
 });
+Object.defineProperty(exports, "createMemoryBudget", {
+	enumerable: true,
+	get: function() {
+		return createMemoryBudget;
+	}
+});
 Object.defineProperty(exports, "createRangeFetcher", {
 	enumerable: true,
 	get: function() {
@@ -36942,6 +38846,12 @@ Object.defineProperty(exports, "detectNextGenFormat", {
 		return detectNextGenFormat;
 	}
 });
+Object.defineProperty(exports, "detectRuntimeCapabilities", {
+	enumerable: true,
+	get: function() {
+		return detectRuntimeCapabilities;
+	}
+});
 Object.defineProperty(exports, "detectTransparency", {
 	enumerable: true,
 	get: function() {
@@ -37470,6 +39380,12 @@ Object.defineProperty(exports, "h", {
 		return h;
 	}
 });
+Object.defineProperty(exports, "h$1", {
+	enumerable: true,
+	get: function() {
+		return h$1;
+	}
+});
 Object.defineProperty(exports, "hasImageDecoder", {
 	enumerable: true,
 	get: function() {
@@ -37548,12 +39464,24 @@ Object.defineProperty(exports, "isLinearized", {
 		return isLinearized;
 	}
 });
+Object.defineProperty(exports, "isSharedMemoryAvailable", {
+	enumerable: true,
+	get: function() {
+		return isSharedMemoryAvailable;
+	}
+});
 Object.defineProperty(exports, "isValidLevel", {
 	enumerable: true,
 	get: function() {
 		return isValidLevel;
 	}
 });
+Object.defineProperty(exports, "isWasmSimdSupported", {
+	enumerable: true,
+	get: function() {
+		return isWasmSimdSupported;
+	}
+});
 Object.defineProperty(exports, "isWoff", {
 	enumerable: true,
 	get: function() {
@@ -37572,6 +39500,18 @@ Object.defineProperty(exports, "itfToOperators", {
 		return itfToOperators;
 	}
 });
+Object.defineProperty(exports, "jsx", {
+	enumerable: true,
+	get: function() {
+		return jsx;
+	}
+});
+Object.defineProperty(exports, "jsxs", {
+	enumerable: true,
+	get: function() {
+		return jsxs;
+	}
+});
 Object.defineProperty(exports, "labToRgb", {
 	enumerable: true,
 	get: function() {
@@ -37734,6 +39674,24 @@ Object.defineProperty(exports, "pdfA4Rules", {
 		return pdfA4Rules;
 	}
 });
+Object.defineProperty(exports, "pdfHeaders", {
+	enumerable: true,
+	get: function() {
+		return pdfHeaders;
+	}
+});
+Object.defineProperty(exports, "pdfResponse", {
+	enumerable: true,
+	get: function() {
+		return pdfResponse;
+	}
+});
+Object.defineProperty(exports, "pdfStreamResponse", {
+	enumerable: true,
+	get: function() {
+		return pdfStreamResponse;
+	}
+});
 Object.defineProperty(exports, "preflightPdfA", {
 	enumerable: true,
 	get: function() {
@@ -37896,6 +39854,12 @@ Object.defineProperty(exports, "renderToPdf", {
 		return renderToPdf;
 	}
 });
+Object.defineProperty(exports, "renderToPdf$1", {
+	enumerable: true,
+	get: function() {
+		return renderToPdf$1;
+	}
+});
 Object.defineProperty(exports, "reorderVisual", {
 	enumerable: true,
 	get: function() {
@@ -38004,6 +39968,12 @@ Object.defineProperty(exports, "searchTextItems", {
 		return searchTextItems;
 	}
 });
+Object.defineProperty(exports, "sendPdfToNodeResponse", {
+	enumerable: true,
+	get: function() {
+		return sendPdfToNodeResponse;
+	}
+});
 Object.defineProperty(exports, "setCertificationLevel", {
 	enumerable: true,
 	get: function() {
@@ -38323,4 +40293,4 @@ Object.defineProperty(exports, "xyzToRgb", {
 	}
 });
 
-//# sourceMappingURL=src-B0gmgVEs.cjs.map
+//# sourceMappingURL=src-aDYhSnal.cjs.map