modern-pdf-lib 0.15.0 → 0.19.9

package/dist/pdfForm-9gd40uz9.cjs

@@ -0,0 +1,1796 @@
+const require_pdfObjects = require('./pdfObjects-1veop1_d.cjs');
+
+//#region src/form/pdfField.ts
+/**
+* @module form/pdfField
+*
+* Base class for all PDF form fields (AcroForm fields).
+*
+* Each concrete field type extends this class and implements
+* `getValue()`, `setValue()`, and `generateAppearance()`.
+*
+* Reference: PDF 1.7 spec, SS12.7 (Interactive Forms).
+*/
+/** Common field flags (/Ff) — bit positions (0-indexed). */
+const FieldFlags = {
+	ReadOnly: 1,
+	Required: 2,
+	NoExport: 4,
+	Multiline: 4096,
+	Password: 8192,
+	DoNotScroll: 1 << 20,
+	RichText: 1 << 25,
+	NoToggleToOff: 16384,
+	Radio: 32768,
+	Pushbutton: 65536,
+	RadiosInUnison: 1 << 25,
+	Combo: 1 << 17,
+	Edit: 1 << 18,
+	Sort: 1 << 19,
+	MultiSelect: 1 << 21
+};
+/**
+* Resolve an object that may be a PdfRef using a resolver function.
+* If it is not a ref, return as-is.
+*/
+function resolveIfRef(obj, resolver) {
+	if (obj === void 0) return void 0;
+	if (obj.kind === "ref") return resolver(obj);
+	return obj;
+}
+/**
+* Extract a numeric value from a PdfObject.
+*/
+function numVal(obj) {
+	if (obj !== void 0 && obj.kind === "number") return obj.value;
+}
+/**
+* Extract a string value from a PdfObject.
+*/
+function strVal(obj) {
+	if (obj !== void 0 && obj.kind === "string") return obj.value;
+}
+/**
+* Extract a name value (without leading `/`) from a PdfObject.
+*/
+function nameVal(obj) {
+	if (obj !== void 0 && obj.kind === "name") {
+		const val = obj.value;
+		return val.startsWith("/") ? val.slice(1) : val;
+	}
+}
+/**
+* Abstract base class for all AcroForm field types.
+*
+* Each field holds a reference to the underlying field dictionary
+* (which may be a merged field+widget dictionary in simple forms)
+* and an optional separate widget annotation dictionary.
+*/
+var PdfField = class {
+	/** The fully-qualified field name. */
+	name;
+	/**
+	* The underlying field dictionary (may contain both field and widget
+	* entries for simple one-widget fields).
+	*/
+	dict;
+	/**
+	* The widget annotation dictionary. For merged field+widget dicts,
+	* this is the same object as `dict`.
+	*/
+	widgetDict;
+	/** Parent field dictionary chain for building full names. */
+	parentNames;
+	constructor(name, dict, widgetDict, parentNames = []) {
+		this.name = name;
+		this.dict = dict;
+		this.widgetDict = widgetDict;
+		this.parentNames = parentNames;
+	}
+	/** Get the partial field name (/T entry). */
+	getName() {
+		return this.name;
+	}
+	/**
+	* Get the fully qualified field name (Parent.Child.Name format).
+	* Per PDF spec SS12.7.3.2, the full name is formed by concatenating
+	* ancestor /T values with periods.
+	*/
+	getFullName() {
+		if (this.parentNames.length === 0) return this.name;
+		return [...this.parentNames, this.name].join(".");
+	}
+	/** Return the underlying field dictionary (for internal use by PdfForm). */
+	getDict() {
+		return this.dict;
+	}
+	/** Get the raw /Ff (field flags) integer value. */
+	getFieldFlags() {
+		return numVal(this.dict.get("/Ff")) ?? 0;
+	}
+	/** Set the raw /Ff (field flags) integer value. */
+	setFieldFlags(flags) {
+		this.dict.set("/Ff", require_pdfObjects.PdfNumber.of(flags));
+	}
+	/** Check if a specific flag bit is set. */
+	hasFlag(flag) {
+		return (this.getFieldFlags() & flag) !== 0;
+	}
+	/** Set or clear a specific flag bit. */
+	setFlag(flag, on) {
+		const current = this.getFieldFlags();
+		if (on) this.setFieldFlags(current | flag);
+		else this.setFieldFlags(current & ~flag);
+	}
+	/** Whether the field is read-only. */
+	isReadOnly() {
+		return this.hasFlag(FieldFlags.ReadOnly);
+	}
+	/** Set the read-only flag. */
+	setReadOnly(readOnly) {
+		this.setFlag(FieldFlags.ReadOnly, readOnly);
+	}
+	/** Whether the field is required. */
+	isRequired() {
+		return this.hasFlag(FieldFlags.Required);
+	}
+	/** Set the required flag. */
+	setRequired(required) {
+		this.setFlag(FieldFlags.Required, required);
+	}
+	/** Whether the field should not be exported. */
+	isNoExport() {
+		return this.hasFlag(FieldFlags.NoExport);
+	}
+	/** Whether the field is exported (inverse of NoExport flag). */
+	isExported() {
+		return !this.hasFlag(FieldFlags.NoExport);
+	}
+	/** Enable exporting this field (clear the NoExport flag). */
+	enableExporting() {
+		this.setFlag(FieldFlags.NoExport, false);
+	}
+	/** Disable exporting this field (set the NoExport flag). */
+	disableExporting() {
+		this.setFlag(FieldFlags.NoExport, true);
+	}
+	/**
+	* Get the field's widget rectangle as `[x1, y1, x2, y2]`.
+	* The /Rect entry comes from the widget annotation dictionary.
+	*/
+	getRect() {
+		const rectObj = this.widgetDict.get("/Rect");
+		if (rectObj !== void 0 && rectObj.kind === "array") {
+			const arr = rectObj;
+			return [
+				numVal(arr.items[0]) ?? 0,
+				numVal(arr.items[1]) ?? 0,
+				numVal(arr.items[2]) ?? 0,
+				numVal(arr.items[3]) ?? 0
+			];
+		}
+		return [
+			0,
+			0,
+			0,
+			0
+		];
+	}
+	/**
+	* Add this field's widget annotation to a page.
+	*
+	* Ensures the widget dict has `/Type /Annot` and `/Subtype /Widget`,
+	* then adds it to the page's annotation list so it appears in the
+	* rendered PDF.
+	*
+	* @param page  A page that implements {@link WidgetAnnotationHost}.
+	*/
+	addToPage(page) {
+		if (!this.widgetDict.has("/Type")) this.widgetDict.set("/Type", require_pdfObjects.PdfName.of("Annot"));
+		if (!this.widgetDict.has("/Subtype")) this.widgetDict.set("/Subtype", require_pdfObjects.PdfName.of("Widget"));
+		page.addWidgetAnnotation(this.widgetDict);
+	}
+	/**
+	* Get the underlying widget annotation dictionary.
+	* @internal
+	*/
+	getWidgetDict() {
+		return this.widgetDict;
+	}
+};
+
+//#endregion
+//#region src/form/fieldAppearance.ts
+/**
+* @module form/fieldAppearance
+*
+* Generates PDF appearance streams (/AP /N) for AcroForm fields.
+*
+* Each generator creates a PdfStream whose content is a valid PDF
+* content stream that visually renders the field's current value.
+*
+* Reference: PDF 1.7 spec, SS12.5.5 (Appearance Streams),
+*            SS12.7.3.3 (Variable Text).
+*/
+/** Format a number for PDF content stream output. */
+function n$2(value) {
+	if (Number.isInteger(value)) return value.toString();
+	const s = value.toFixed(6).replace(/\.?0+$/, "");
+	return s === "-0" ? "0" : s;
+}
+/** Escape a string for use in a PDF literal string. */
+function escapePdf(text) {
+	return text.replace(/\\/g, "\\\\").replace(/\(/g, "\\(").replace(/\)/g, "\\)").replace(/\r/g, "\\r").replace(/\n/g, "\\n");
+}
+/**
+* Generate the appearance stream for a text field.
+*
+* The stream renders the text value within the widget rectangle,
+* using Tf/Td/Tj operators. Handles single-line and multiline,
+* alignment (quadding), and auto font-size calculation.
+*/
+function generateTextAppearance(options) {
+	const { value, rect, fontName = "Helv", fontSize: requestedSize = 0, alignment = 0, multiline = false, borderWidth = 1 } = options;
+	const width = rect[2] - rect[0];
+	const height = rect[3] - rect[1];
+	const padding = borderWidth + 1;
+	let fontSize = requestedSize;
+	if (fontSize <= 0) if (multiline) fontSize = 10;
+	else fontSize = Math.min(Math.max(height - 2 * padding, 4), 20);
+	let ops = "";
+	ops += `/Tx BMC\n`;
+	ops += `q\n`;
+	ops += `${n$2(padding)} ${n$2(padding)} ${n$2(width - 2 * padding)} ${n$2(height - 2 * padding)} re\n`;
+	ops += `W\n`;
+	ops += `n\n`;
+	ops += `BT\n`;
+	ops += `/${fontName} ${n$2(fontSize)} Tf\n`;
+	ops += `0 g\n`;
+	if (multiline) {
+		const lines = value.split("\n");
+		const lineHeight = fontSize * 1.2;
+		const startY = height - padding - fontSize;
+		for (let i = 0; i < lines.length; i++) {
+			const line = lines[i] ?? "";
+			const tx = computeAlignmentOffset(line, fontSize, width - 2 * padding, alignment);
+			const ty = startY - i * lineHeight;
+			if (ty < padding) break;
+			ops += `${n$2(tx + padding)} ${n$2(ty)} Td\n`;
+			ops += `(${escapePdf(line)}) Tj\n`;
+			if (i < lines.length - 1) ops += `${n$2(-(tx + padding))} ${n$2(-ty)} Td\n`;
+		}
+	} else {
+		const tx = computeAlignmentOffset(value, fontSize, width - 2 * padding, alignment);
+		const ty = (height - fontSize) / 2;
+		ops += `${n$2(tx + padding)} ${n$2(ty)} Td\n`;
+		ops += `(${escapePdf(value)}) Tj\n`;
+	}
+	ops += `ET\n`;
+	ops += `Q\n`;
+	ops += `EMC\n`;
+	return buildAppearanceStream(ops, width, height);
+}
+/**
+* Compute horizontal text offset for alignment.
+* Rough approximation: assume average char width = fontSize * 0.5.
+*/
+function computeAlignmentOffset(text, fontSize, availableWidth, alignment) {
+	const textWidth = text.length * fontSize * .5;
+	switch (alignment) {
+		case 1: return Math.max(0, (availableWidth - textWidth) / 2);
+		case 2: return Math.max(0, availableWidth - textWidth);
+		default: return 0;
+	}
+}
+/**
+* Generate the appearance stream for a checkbox — checked state.
+*
+* Renders a checkmark (a simple cross/tick path) inside the widget
+* rectangle when checked, or an empty box when unchecked.
+*/
+function generateCheckboxAppearance(options) {
+	const { checked, rect } = options;
+	const width = rect[2] - rect[0];
+	const height = rect[3] - rect[1];
+	let ops = "";
+	if (checked) {
+		const margin = Math.min(width, height) * .15;
+		const x1 = margin;
+		const y1 = height * .5;
+		const x2 = width * .4;
+		const y2 = margin;
+		const x3 = width - margin;
+		const y3 = height - margin;
+		ops += `q\n`;
+		ops += `${n$2(2)} w\n`;
+		ops += `0 0 0 RG\n`;
+		ops += `${n$2(x1)} ${n$2(y1)} m\n`;
+		ops += `${n$2(x2)} ${n$2(y2)} l\n`;
+		ops += `${n$2(x3)} ${n$2(y3)} l\n`;
+		ops += `S\n`;
+		ops += `Q\n`;
+	}
+	return buildAppearanceStream(ops, width, height);
+}
+/**
+* Generate the appearance stream for a radio button option.
+*
+* Selected: filled circle inside the widget.
+* Unselected: empty circle (border only).
+*/
+function generateRadioAppearance(options) {
+	const { selected, rect } = options;
+	const width = rect[2] - rect[0];
+	const height = rect[3] - rect[1];
+	const cx = width / 2;
+	const cy = height / 2;
+	const outerRadius = Math.min(cx, cy) - 1;
+	let ops = "";
+	ops += `q\n`;
+	ops += `0 0 0 RG\n`;
+	ops += `0.5 w\n`;
+	ops += circlePath(cx, cy, outerRadius);
+	ops += `S\n`;
+	ops += `Q\n`;
+	if (selected) {
+		const innerRadius = outerRadius * .5;
+		ops += `q\n`;
+		ops += `0 0 0 rg\n`;
+		ops += circlePath(cx, cy, innerRadius);
+		ops += `f\n`;
+		ops += `Q\n`;
+	}
+	return buildAppearanceStream(ops, width, height);
+}
+/**
+* Generate the appearance stream for a dropdown (combo box).
+* Renders the selected value text, similar to a text field.
+*/
+function generateDropdownAppearance(options) {
+	return generateTextAppearance({
+		value: options.value,
+		rect: options.rect,
+		fontName: options.fontName,
+		fontSize: options.fontSize,
+		alignment: 0,
+		multiline: false
+	});
+}
+/**
+* Generate the appearance stream for a listbox.
+* Renders visible options with highlighting for selected items.
+*/
+function generateListboxAppearance(options) {
+	const { options: items, selected, rect, fontName = "Helv", fontSize = 10 } = options;
+	const width = rect[2] - rect[0];
+	const height = rect[3] - rect[1];
+	const lineHeight = fontSize * 1.4;
+	const padding = 2;
+	const selectedSet = new Set(selected);
+	let ops = "";
+	ops += `q\n`;
+	ops += `${n$2(0)} ${n$2(0)} ${n$2(width)} ${n$2(height)} re\n`;
+	ops += `W\n`;
+	ops += `n\n`;
+	const visibleItems = Math.floor(height / lineHeight);
+	const renderCount = Math.min(items.length, visibleItems);
+	for (let i = 0; i < renderCount; i++) {
+		const item = items[i] ?? "";
+		const y = height - (i + 1) * lineHeight;
+		if (selectedSet.has(item)) {
+			ops += `0 0 0.5 rg\n`;
+			ops += `${n$2(0)} ${n$2(y)} ${n$2(width)} ${n$2(lineHeight)} re\n`;
+			ops += `f\n`;
+			ops += `1 1 1 rg\n`;
+		} else ops += `0 0 0 rg\n`;
+		ops += `BT\n`;
+		ops += `/${fontName} ${n$2(fontSize)} Tf\n`;
+		ops += `${n$2(padding)} ${n$2(y + lineHeight * .25)} Td\n`;
+		ops += `(${escapePdf(item)}) Tj\n`;
+		ops += `ET\n`;
+	}
+	ops += `Q\n`;
+	return buildAppearanceStream(ops, width, height);
+}
+/**
+* Generate the appearance stream for a pushbutton.
+* Renders a 3D-ish raised button with centered caption text.
+*/
+function generateButtonAppearance(options) {
+	const { caption, rect, fontName = "Helv", fontSize: requestedSize = 0 } = options;
+	const width = rect[2] - rect[0];
+	const height = rect[3] - rect[1];
+	let fontSize = requestedSize;
+	if (fontSize <= 0) fontSize = Math.min(Math.max(height - 6, 4), 16);
+	let ops = "";
+	ops += `q\n`;
+	ops += `0.75 g\n`;
+	ops += `${n$2(0)} ${n$2(0)} ${n$2(width)} ${n$2(height)} re\n`;
+	ops += `f\n`;
+	ops += `Q\n`;
+	const tx = (width - caption.length * fontSize * .5) / 2;
+	const ty = (height - fontSize) / 2;
+	ops += `BT\n`;
+	ops += `/${fontName} ${n$2(fontSize)} Tf\n`;
+	ops += `0 g\n`;
+	ops += `${n$2(tx)} ${n$2(ty)} Td\n`;
+	ops += `(${escapePdf(caption)}) Tj\n`;
+	ops += `ET\n`;
+	return buildAppearanceStream(ops, width, height);
+}
+/**
+* Generate the appearance stream for a signature field.
+*
+* Unsigned: dashed border rectangle.
+* Signed: "Signed" text with a line through it.
+*/
+function generateSignatureAppearance(options) {
+	const { signed, rect } = options;
+	const width = rect[2] - rect[0];
+	const height = rect[3] - rect[1];
+	let ops = "";
+	if (signed) {
+		ops += `q\n`;
+		ops += `0.8 g\n`;
+		ops += `${n$2(0)} ${n$2(0)} ${n$2(width)} ${n$2(height)} re\n`;
+		ops += `f\n`;
+		ops += `Q\n`;
+		ops += `BT\n`;
+		ops += `/Helv 10 Tf\n`;
+		ops += `0 g\n`;
+		const tx = (width - 30) / 2;
+		const ty = (height - 10) / 2;
+		ops += `${n$2(tx)} ${n$2(ty)} Td\n`;
+		ops += `(Signed) Tj\n`;
+		ops += `ET\n`;
+	} else {
+		ops += `q\n`;
+		ops += `[3 3] 0 d\n`;
+		ops += `0.5 G\n`;
+		ops += `0.5 w\n`;
+		ops += `${n$2(1)} ${n$2(1)} ${n$2(width - 2)} ${n$2(height - 2)} re\n`;
+		ops += `S\n`;
+		ops += `Q\n`;
+	}
+	return buildAppearanceStream(ops, width, height);
+}
+/**
+* Build a PdfStream from content stream operators with proper BBox.
+*/
+function buildAppearanceStream(operators, width, height) {
+	const dict = new require_pdfObjects.PdfDict();
+	dict.set("/Type", require_pdfObjects.PdfName.of("XObject"));
+	dict.set("/Subtype", require_pdfObjects.PdfName.of("Form"));
+	dict.set("/BBox", require_pdfObjects.PdfArray.fromNumbers([
+		0,
+		0,
+		width,
+		height
+	]));
+	const resources = new require_pdfObjects.PdfDict();
+	const fontDict = new require_pdfObjects.PdfDict();
+	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"));
+	fontDict.set("/Helv", helvetica);
+	resources.set("/Font", fontDict);
+	dict.set("/Resources", resources);
+	return require_pdfObjects.PdfStream.fromString(operators, dict);
+}
+/**
+* Approximate circle path using 4 cubic Bezier curves.
+*/
+function circlePath(cx, cy, radius) {
+	const kappa = .5522847498;
+	const ox = radius * kappa;
+	const oy = radius * kappa;
+	let ops = "";
+	ops += `${n$2(cx)} ${n$2(cy + radius)} m\n`;
+	ops += `${n$2(cx + ox)} ${n$2(cy + radius)} ${n$2(cx + radius)} ${n$2(cy + oy)} ${n$2(cx + radius)} ${n$2(cy)} c\n`;
+	ops += `${n$2(cx + radius)} ${n$2(cy - oy)} ${n$2(cx + ox)} ${n$2(cy - radius)} ${n$2(cx)} ${n$2(cy - radius)} c\n`;
+	ops += `${n$2(cx - ox)} ${n$2(cy - radius)} ${n$2(cx - radius)} ${n$2(cy - oy)} ${n$2(cx - radius)} ${n$2(cy)} c\n`;
+	ops += `${n$2(cx - radius)} ${n$2(cy + oy)} ${n$2(cx - ox)} ${n$2(cy + radius)} ${n$2(cx)} ${n$2(cy + radius)} c\n`;
+	return ops;
+}
+
+//#endregion
+//#region src/form/fields/textField.ts
+/**
+* @module form/fields/textField
+*
+* PDF text form field (/FT /Tx).
+*
+* Reference: PDF 1.7 spec, SS12.7.4.3 (Text Fields).
+*/
+/** Format a number for PDF content stream output. */
+function n$1(value) {
+	if (Number.isInteger(value)) return value.toString();
+	const s = value.toFixed(6).replace(/\.?0+$/, "");
+	return s === "-0" ? "0" : s;
+}
+/**
+* A PDF text form field (/FT /Tx).
+*
+* Stores a string value and supports properties like alignment,
+* multiline mode, password masking, and maximum length.
+*/
+var PdfTextField = class extends PdfField {
+	fieldType = "text";
+	/** Get the text value of this field. */
+	getText() {
+		return strVal(this.dict.get("/V")) ?? "";
+	}
+	/**
+	* Set the text value of this field.
+	* Also updates /V and removes /AP to force regeneration.
+	*/
+	setText(value) {
+		this.dict.set("/V", require_pdfObjects.PdfString.literal(value));
+		this.widgetDict.delete("/AP");
+	}
+	/** Alias for getText(). */
+	getValue() {
+		return this.getText();
+	}
+	/** Alias for setText(). */
+	setValue(value) {
+		this.setText(typeof value === "string" ? value : String(value));
+	}
+	/**
+	* Get the font size from the /DA (default appearance) string.
+	* Returns 0 if the font size is not specified or is auto.
+	*/
+	getFontSize() {
+		const da = strVal(this.dict.get("/DA"));
+		if (da === void 0) return 0;
+		const match = da.match(/\/(\w+)\s+([\d.]+)\s+Tf/);
+		if (match?.[2] !== void 0) return parseFloat(match[2]);
+		return 0;
+	}
+	/**
+	* Set the font size in the /DA string.
+	* Creates or updates the /DA entry.
+	*/
+	setFontSize(size) {
+		const fontName = this.getFontName();
+		this.dict.set("/DA", require_pdfObjects.PdfString.literal(`/${fontName} ${size} Tf 0 g`));
+		this.widgetDict.delete("/AP");
+	}
+	/**
+	* Get the font name from the /DA string.
+	* Returns "Helv" (Helvetica) as default.
+	*/
+	getFontName() {
+		const da = strVal(this.dict.get("/DA"));
+		if (da === void 0) return "Helv";
+		return da.match(/\/(\w+)\s+[\d.]+\s+Tf/)?.[1] ?? "Helv";
+	}
+	/**
+	* Get the text alignment.
+	* /Q: 0 = left, 1 = center, 2 = right.
+	*/
+	getAlignment() {
+		switch (numVal(this.dict.get("/Q"))) {
+			case 1: return "center";
+			case 2: return "right";
+			default: return "left";
+		}
+	}
+	/** Set the text alignment. */
+	setAlignment(align) {
+		const q = align === "center" ? 1 : align === "right" ? 2 : 0;
+		this.dict.set("/Q", require_pdfObjects.PdfNumber.of(q));
+		this.widgetDict.delete("/AP");
+	}
+	/** Whether this is a multiline text field. */
+	isMultiline() {
+		return this.hasFlag(FieldFlags.Multiline);
+	}
+	/** Set the multiline flag. */
+	setMultiline(multiline) {
+		this.setFlag(FieldFlags.Multiline, multiline);
+	}
+	/** Whether this is a password field. */
+	isPassword() {
+		return this.hasFlag(FieldFlags.Password);
+	}
+	/** Get the maximum length, or undefined if no limit. */
+	getMaxLength() {
+		return numVal(this.dict.get("/MaxLen"));
+	}
+	/** Set the maximum length. */
+	setMaxLength(maxLength) {
+		this.dict.set("/MaxLen", require_pdfObjects.PdfNumber.of(maxLength));
+	}
+	/**
+	* Set an image on this text field.
+	*
+	* Creates an appearance stream that paints the image XObject scaled
+	* to fit the widget rectangle. This replaces the text appearance.
+	*
+	* @param imageRef  An object with `name` (resource name) and `ref` (PdfRef)
+	*                  pointing to the image XObject, plus `width` and `height`.
+	*/
+	setImage(imageRef) {
+		const rect = this.getRect();
+		const fieldW = Math.abs(rect[2] - rect[0]);
+		const fieldH = Math.abs(rect[3] - rect[1]);
+		const scaleX = fieldW / imageRef.width;
+		const scaleY = fieldH / imageRef.height;
+		const scale = Math.min(scaleX, scaleY);
+		const drawW = imageRef.width * scale;
+		const drawH = imageRef.height * scale;
+		const offsetX = (fieldW - drawW) / 2;
+		const offsetY = (fieldH - drawH) / 2;
+		const ops = `q\n${n$1(drawW)} 0 0 ${n$1(drawH)} ${n$1(offsetX)} ${n$1(offsetY)} cm\n/${imageRef.name} Do\nQ\n`;
+		const apDict = new require_pdfObjects.PdfDict();
+		apDict.set("/Type", require_pdfObjects.PdfName.of("XObject"));
+		apDict.set("/Subtype", require_pdfObjects.PdfName.of("Form"));
+		apDict.set("/BBox", require_pdfObjects.PdfArray.fromNumbers([
+			0,
+			0,
+			fieldW,
+			fieldH
+		]));
+		const resources = new require_pdfObjects.PdfDict();
+		const xObjectDict = new require_pdfObjects.PdfDict();
+		xObjectDict.set(`/${imageRef.name}`, imageRef.ref);
+		resources.set("/XObject", xObjectDict);
+		apDict.set("/Resources", resources);
+		const stream = require_pdfObjects.PdfStream.fromString(ops, apDict);
+		const apWrapper = new require_pdfObjects.PdfDict();
+		apWrapper.set("/N", stream);
+		this.widgetDict.set("/AP", apWrapper);
+	}
+	/** Generate the appearance stream for this text field. */
+	generateAppearance() {
+		return generateTextAppearance({
+			value: this.getText(),
+			rect: this.getRect(),
+			fontName: this.getFontName(),
+			fontSize: this.getFontSize(),
+			alignment: {
+				left: 0,
+				center: 1,
+				right: 2
+			}[this.getAlignment()],
+			multiline: this.isMultiline()
+		});
+	}
+};
+
+//#endregion
+//#region src/form/fields/checkboxField.ts
+/**
+* @module form/fields/checkboxField
+*
+* PDF checkbox form field (/FT /Btn without Radio or Pushbutton flags).
+*
+* Reference: PDF 1.7 spec, SS12.7.4.2.1 (Check Boxes).
+*/
+/**
+* A PDF checkbox form field (/FT /Btn).
+*
+* The value is either the "on" name (typically "Yes") or "/Off".
+* The /AS (appearance state) entry controls which appearance is shown.
+*/
+var PdfCheckboxField = class extends PdfField {
+	fieldType = "checkbox";
+	/**
+	* Check whether the checkbox is currently checked.
+	*
+	* The checkbox is checked when /V or /AS is not "/Off".
+	*/
+	isChecked() {
+		const v = nameVal(this.dict.get("/V"));
+		if (v !== void 0) return v !== "Off";
+		const as = nameVal(this.widgetDict.get("/AS"));
+		return as !== void 0 && as !== "Off";
+	}
+	/** Check the checkbox (set to the "on" value). */
+	check() {
+		const onValue = this.getOnValue();
+		this.dict.set("/V", require_pdfObjects.PdfName.of(onValue));
+		this.widgetDict.set("/AS", require_pdfObjects.PdfName.of(onValue));
+		this.widgetDict.delete("/AP");
+	}
+	/** Uncheck the checkbox (set to /Off). */
+	uncheck() {
+		this.dict.set("/V", require_pdfObjects.PdfName.of("Off"));
+		this.widgetDict.set("/AS", require_pdfObjects.PdfName.of("Off"));
+		this.widgetDict.delete("/AP");
+	}
+	/** Toggle the checkbox. */
+	toggle() {
+		if (this.isChecked()) this.uncheck();
+		else this.check();
+	}
+	/**
+	* Get the "on" value name for this checkbox.
+	*
+	* Examines the /AP /N dictionary for a key that is not "/Off".
+	* Falls back to "Yes" if no appearance dictionary is found.
+	*/
+	getOnValue() {
+		const ap = this.widgetDict.get("/AP");
+		if (ap !== void 0 && ap.kind === "dict") {
+			const nObj = ap.get("/N");
+			if (nObj !== void 0 && nObj.kind === "dict") {
+				const nDict = nObj;
+				for (const [key] of nDict) {
+					const cleanKey = key.startsWith("/") ? key.slice(1) : key;
+					if (cleanKey !== "Off") return cleanKey;
+				}
+			}
+		}
+		const v = nameVal(this.dict.get("/V"));
+		if (v !== void 0 && v !== "Off") return v;
+		return "Yes";
+	}
+	/** Get the value: "Yes"/"Off" as boolean for convenience. */
+	getValue() {
+		return this.isChecked();
+	}
+	/** Set the value as boolean. */
+	setValue(value) {
+		if (typeof value === "boolean") if (value) this.check();
+		else this.uncheck();
+		else {
+			const str = typeof value === "string" ? value : String(value);
+			if (str === "Off" || str === "false" || str === "0" || str === "") this.uncheck();
+			else this.check();
+		}
+	}
+	/** Generate the appearance stream for this checkbox. */
+	generateAppearance() {
+		return generateCheckboxAppearance({
+			checked: this.isChecked(),
+			rect: this.getRect()
+		});
+	}
+};
+
+//#endregion
+//#region src/form/fields/radioGroup.ts
+/**
+* @module form/fields/radioGroup
+*
+* PDF radio button group (/FT /Btn with Radio flag set).
+*
+* A radio group is a single field with multiple widget annotations
+* (one per option). The /V entry on the field indicates which option
+* is selected.
+*
+* Reference: PDF 1.7 spec, SS12.7.4.2.2 (Radio Buttons).
+*/
+/**
+* A PDF radio button group (/FT /Btn with Radio flag).
+*
+* Multiple widget annotations represent the individual options.
+* The field's /V value is the name of the selected option.
+*/
+var PdfRadioGroup = class extends PdfField {
+	fieldType = "radio";
+	/** The individual widget annotation dictionaries. */
+	widgets;
+	constructor(name, dict, widgetDict, parentNames = [], widgets = []) {
+		super(name, dict, widgetDict, parentNames);
+		this.widgets = widgets.length > 0 ? widgets : [widgetDict];
+	}
+	/**
+	* Add all radio button widgets to a page.
+	*
+	* Unlike other field types that have a single widget, a radio group
+	* has multiple widget annotations (one per option). This override
+	* adds all of them.
+	*/
+	addToPage(page) {
+		for (const widget of this.widgets) {
+			if (!widget.has("/Type")) widget.set("/Type", require_pdfObjects.PdfName.of("Annot"));
+			if (!widget.has("/Subtype")) widget.set("/Subtype", require_pdfObjects.PdfName.of("Widget"));
+			page.addWidgetAnnotation(widget);
+		}
+	}
+	/**
+	* Get the currently selected option name.
+	* Returns undefined if no option is selected.
+	*/
+	getSelected() {
+		const v = nameVal(this.dict.get("/V"));
+		if (v !== void 0 && v !== "Off") return v;
+	}
+	/**
+	* Select an option by its name.
+	*
+	* Sets /V on the field and updates /AS on each widget to
+	* show the correct appearance state.
+	*/
+	select(optionName) {
+		this.dict.set("/V", require_pdfObjects.PdfName.of(optionName));
+		for (const widget of this.widgets) {
+			if (this.getWidgetOptionName(widget) === optionName) widget.set("/AS", require_pdfObjects.PdfName.of(optionName));
+			else widget.set("/AS", require_pdfObjects.PdfName.of("Off"));
+			widget.delete("/AP");
+		}
+	}
+	/**
+	* Get the list of option names available in this radio group.
+	* Derived from the /AP /N dictionaries of each widget.
+	*/
+	getOptions() {
+		const options = [];
+		for (const widget of this.widgets) {
+			const optName = this.getWidgetOptionName(widget);
+			if (optName !== void 0) options.push(optName);
+		}
+		return options;
+	}
+	/** Get the widget annotation dictionaries. */
+	getWidgets() {
+		return [...this.widgets];
+	}
+	/** Get the value: the selected option name or undefined. */
+	getValue() {
+		return this.getSelected() ?? "";
+	}
+	/** Set the value: select the named option. */
+	setValue(value) {
+		const str = typeof value === "string" ? value : String(value);
+		this.select(str);
+	}
+	/**
+	* Get the option name for a widget annotation.
+	* Looks in the /AP /N dictionary for a key that is not "Off".
+	*/
+	getWidgetOptionName(widget) {
+		const ap = widget.get("/AP");
+		if (ap !== void 0 && ap.kind === "dict") {
+			const nObj = ap.get("/N");
+			if (nObj !== void 0 && nObj.kind === "dict") {
+				const nDict = nObj;
+				for (const [key] of nDict) {
+					const cleanKey = key.startsWith("/") ? key.slice(1) : key;
+					if (cleanKey !== "Off") return cleanKey;
+				}
+			}
+		}
+	}
+	/**
+	* Generate the appearance stream for the first widget.
+	* For full appearance generation, use generateAppearanceForWidget().
+	*/
+	generateAppearance() {
+		const selected = this.getSelected();
+		const firstWidget = this.widgets[0] ?? this.widgetDict;
+		return generateRadioAppearance({
+			selected: this.getWidgetOptionName(firstWidget) === selected,
+			rect: this.getRect()
+		});
+	}
+};
+
+//#endregion
+//#region src/form/fields/dropdownField.ts
+/**
+* @module form/fields/dropdownField
+*
+* PDF dropdown (combo box) form field (/FT /Ch with Combo flag).
+*
+* Reference: PDF 1.7 spec, SS12.7.4.4 (Choice Fields).
+*/
+/**
+* A PDF dropdown (combo box) field (/FT /Ch with Combo flag).
+*
+* Options are stored in the /Opt array. The selected value is in /V.
+* Optionally editable (bit 18 of /Ff).
+*/
+var PdfDropdownField = class extends PdfField {
+	fieldType = "dropdown";
+	/** Get the currently selected value. */
+	getSelected() {
+		return strVal(this.dict.get("/V")) ?? "";
+	}
+	/** Select a value from the options. */
+	select(value) {
+		this.dict.set("/V", require_pdfObjects.PdfString.literal(value));
+		this.widgetDict.delete("/AP");
+	}
+	/** Alias for getSelected(). */
+	getValue() {
+		return this.getSelected();
+	}
+	/** Alias for select(). */
+	setValue(value) {
+		this.select(typeof value === "string" ? value : String(value));
+	}
+	/**
+	* Get the list of options.
+	*
+	* /Opt may be an array of strings, or an array of two-element arrays
+	* where element [0] is the export value and element [1] is the display
+	* value. We return the display values (or export values if no display).
+	*/
+	getOptions() {
+		const optObj = this.dict.get("/Opt");
+		if (optObj === void 0 || optObj.kind !== "array") return [];
+		const arr = optObj;
+		const options = [];
+		for (const item of arr.items) if (item.kind === "string") options.push(item.value);
+		else if (item.kind === "array") {
+			const subArr = item;
+			const display = subArr.items[1] ?? subArr.items[0];
+			if (display !== void 0 && display.kind === "string") options.push(display.value);
+		}
+		return options;
+	}
+	/** Set the list of options. */
+	setOptions(options) {
+		const arr = require_pdfObjects.PdfArray.of(options.map((o) => require_pdfObjects.PdfString.literal(o)));
+		this.dict.set("/Opt", arr);
+		this.widgetDict.delete("/AP");
+	}
+	/** Whether the dropdown allows manual text entry. */
+	isEditable() {
+		return this.hasFlag(FieldFlags.Edit);
+	}
+	/** Set whether the dropdown allows manual text entry. */
+	setEditable(editable) {
+		this.setFlag(FieldFlags.Edit, editable);
+	}
+	/** Generate the appearance stream for this dropdown. */
+	generateAppearance() {
+		return generateDropdownAppearance({
+			value: this.getSelected(),
+			rect: this.getRect()
+		});
+	}
+};
+
+//#endregion
+//#region src/form/fields/listboxField.ts
+/**
+* @module form/fields/listboxField
+*
+* PDF listbox form field (/FT /Ch without Combo flag).
+*
+* Reference: PDF 1.7 spec, SS12.7.4.4 (Choice Fields).
+*/
+/**
+* A PDF listbox field (/FT /Ch without Combo flag).
+*
+* Displays a scrollable list of options. May allow multi-select.
+* The /V entry holds the selected value(s).
+*/
+var PdfListboxField = class extends PdfField {
+	fieldType = "listbox";
+	/**
+	* Get the currently selected value(s).
+	*
+	* Returns an array of strings (may contain one element for
+	* single-select listboxes).
+	*/
+	getSelected() {
+		const v = this.dict.get("/V");
+		if (v === void 0) return [];
+		if (v.kind === "string") return [v.value];
+		if (v.kind === "array") return v.items.filter((item) => item.kind === "string").map((item) => item.value);
+		return [];
+	}
+	/** Select one or more values. */
+	select(values) {
+		if (values.length === 1) this.dict.set("/V", require_pdfObjects.PdfString.literal(values[0]));
+		else {
+			const arr = require_pdfObjects.PdfArray.of(values.map((v) => require_pdfObjects.PdfString.literal(v)));
+			this.dict.set("/V", arr);
+		}
+		this.widgetDict.delete("/AP");
+	}
+	/** Get value as string array. */
+	getValue() {
+		return this.getSelected();
+	}
+	/** Set value from string array. */
+	setValue(value) {
+		if (Array.isArray(value)) this.select(value);
+		else this.select([String(value)]);
+	}
+	/** Get the list of options. */
+	getOptions() {
+		const optObj = this.dict.get("/Opt");
+		if (optObj === void 0 || optObj.kind !== "array") return [];
+		const arr = optObj;
+		const options = [];
+		for (const item of arr.items) if (item.kind === "string") options.push(item.value);
+		else if (item.kind === "array") {
+			const subArr = item;
+			const display = subArr.items[1] ?? subArr.items[0];
+			if (display !== void 0 && display.kind === "string") options.push(display.value);
+		}
+		return options;
+	}
+	/** Set the list of options. */
+	setOptions(options) {
+		const arr = require_pdfObjects.PdfArray.of(options.map((o) => require_pdfObjects.PdfString.literal(o)));
+		this.dict.set("/Opt", arr);
+		this.widgetDict.delete("/AP");
+	}
+	/** Generate the appearance stream for this listbox. */
+	generateAppearance() {
+		return generateListboxAppearance({
+			options: this.getOptions(),
+			selected: this.getSelected(),
+			rect: this.getRect()
+		});
+	}
+};
+
+//#endregion
+//#region src/form/fields/buttonField.ts
+/**
+* @module form/fields/buttonField
+*
+* PDF pushbutton form field (/FT /Btn with Pushbutton flag).
+*
+* Reference: PDF 1.7 spec, SS12.7.4.2.3 (Push-Buttons).
+*/
+/** Format a number for PDF content stream output. */
+function n(value) {
+	if (Number.isInteger(value)) return value.toString();
+	const s = value.toFixed(6).replace(/\.?0+$/, "");
+	return s === "-0" ? "0" : s;
+}
+/**
+* A PDF pushbutton field (/FT /Btn with Pushbutton flag).
+*
+* Pushbuttons have no permanent value. They may have an associated
+* action (e.g. JavaScript, submit form, reset form) and display a
+* caption via the /MK dictionary.
+*/
+var PdfButtonField = class extends PdfField {
+	fieldType = "button";
+	/**
+	* Get the button caption from the /MK dictionary.
+	* Returns undefined if no caption is set.
+	*/
+	getCaption() {
+		const mk = this.widgetDict.get("/MK");
+		if (mk !== void 0 && mk.kind === "dict") return strVal(mk.get("/CA"));
+	}
+	/**
+	* Set the button caption in the /MK dictionary.
+	* Creates the /MK dictionary if it does not exist.
+	*/
+	setCaption(caption) {
+		let mk = this.widgetDict.get("/MK");
+		if (mk === void 0 || mk.kind !== "dict") {
+			mk = new require_pdfObjects.PdfDict();
+			this.widgetDict.set("/MK", mk);
+		}
+		mk.set("/CA", require_pdfObjects.PdfString.literal(caption));
+		this.widgetDict.delete("/AP");
+	}
+	/**
+	* Set an image on this button field.
+	*
+	* Creates an appearance stream that paints the image XObject scaled
+	* to fit the widget rectangle.
+	*
+	* @param imageRef  An object with `name` (resource name) and `ref` (PdfRef)
+	*                  pointing to the image XObject, plus `width` and `height`.
+	*/
+	setImage(imageRef) {
+		const rect = this.getRect();
+		const fieldW = Math.abs(rect[2] - rect[0]);
+		const fieldH = Math.abs(rect[3] - rect[1]);
+		const scaleX = fieldW / imageRef.width;
+		const scaleY = fieldH / imageRef.height;
+		const scale = Math.min(scaleX, scaleY);
+		const drawW = imageRef.width * scale;
+		const drawH = imageRef.height * scale;
+		const offsetX = (fieldW - drawW) / 2;
+		const offsetY = (fieldH - drawH) / 2;
+		const ops = `q\n${n(drawW)} 0 0 ${n(drawH)} ${n(offsetX)} ${n(offsetY)} cm\n/${imageRef.name} Do\nQ\n`;
+		const apDict = new require_pdfObjects.PdfDict();
+		apDict.set("/Type", require_pdfObjects.PdfName.of("XObject"));
+		apDict.set("/Subtype", require_pdfObjects.PdfName.of("Form"));
+		apDict.set("/BBox", require_pdfObjects.PdfArray.fromNumbers([
+			0,
+			0,
+			fieldW,
+			fieldH
+		]));
+		const resources = new require_pdfObjects.PdfDict();
+		const xObjectDict = new require_pdfObjects.PdfDict();
+		xObjectDict.set(`/${imageRef.name}`, imageRef.ref);
+		resources.set("/XObject", xObjectDict);
+		apDict.set("/Resources", resources);
+		const stream = require_pdfObjects.PdfStream.fromString(ops, apDict);
+		const apWrapper = new require_pdfObjects.PdfDict();
+		apWrapper.set("/N", stream);
+		this.widgetDict.set("/AP", apWrapper);
+	}
+	/** Pushbuttons have no value; returns empty string. */
+	getValue() {
+		return "";
+	}
+	/** Pushbuttons have no value; no-op. */
+	setValue(_value) {}
+	/** Generate the appearance stream for this button. */
+	generateAppearance() {
+		return generateButtonAppearance({
+			caption: this.getCaption() ?? "",
+			rect: this.getRect()
+		});
+	}
+};
+
+//#endregion
+//#region src/form/fields/signatureField.ts
+/**
+* A PDF signature form field (/FT /Sig).
+*
+* The /V entry is a signature dictionary containing the cryptographic
+* signature data. This class provides read access to check whether the
+* field is signed, but does not implement signing (see Phase 6).
+*/
+var PdfSignatureField = class extends PdfField {
+	fieldType = "signature";
+	/**
+	* Whether this signature field has been signed.
+	* A signed field has a /V entry that is a dictionary.
+	*/
+	isSigned() {
+		const v = this.dict.get("/V");
+		return v !== void 0 && v.kind === "dict";
+	}
+	/**
+	* Get the signature dictionary, if signed.
+	* Returns undefined if the field has not been signed.
+	*/
+	getSignatureValue() {
+		const v = this.dict.get("/V");
+		if (v !== void 0 && v.kind === "dict") return v;
+	}
+	/** Get value: returns "signed" or "unsigned". */
+	getValue() {
+		return this.isSigned() ? "signed" : "unsigned";
+	}
+	/** Signature fields cannot be set via setValue. */
+	setValue(_value) {}
+	/** Generate the appearance stream for this signature field. */
+	generateAppearance() {
+		return generateSignatureAppearance({
+			signed: this.isSigned(),
+			rect: this.getRect()
+		});
+	}
+};
+
+//#endregion
+//#region src/form/pdfForm.ts
+/**
+* @module form/pdfForm
+*
+* The main AcroForm class — manages the field tree, provides typed
+* field accessors, and implements fill/flatten operations.
+*
+* Reference: PDF 1.7 spec, SS12.7 (Interactive Forms).
+*/
+/**
+* Determine the field type from a field dictionary.
+*
+* Uses /FT (field type) and /Ff (field flags) to distinguish
+* between the various field subtypes.
+*/
+function classifyField(dict, resolver) {
+	const ft = nameVal(resolveIfRef(dict.get("/FT"), resolver));
+	if (ft === void 0) return void 0;
+	switch (ft) {
+		case "Tx": return "text";
+		case "Btn": {
+			const ff = numVal(resolveIfRef(dict.get("/Ff"), resolver)) ?? 0;
+			if (ff & FieldFlags.Pushbutton) return "button";
+			if (ff & FieldFlags.Radio) return "radio";
+			return "checkbox";
+		}
+		case "Ch":
+			if ((numVal(resolveIfRef(dict.get("/Ff"), resolver)) ?? 0) & FieldFlags.Combo) return "dropdown";
+			return "listbox";
+		case "Sig": return "signature";
+		default: return;
+	}
+}
+/**
+* Resolve a PdfObject if it is a PdfRef using the resolver.
+*/
+function resolveObj(obj, resolver) {
+	if (obj.kind === "ref") return resolver(obj);
+	return obj;
+}
+/**
+* Create the appropriate PdfField subclass for a given field dictionary.
+*/
+function createFieldInstance(type, name, dict, widgetDict, parentNames, widgets) {
+	switch (type) {
+		case "text": return new PdfTextField(name, dict, widgetDict, parentNames);
+		case "checkbox": return new PdfCheckboxField(name, dict, widgetDict, parentNames);
+		case "radio": return new PdfRadioGroup(name, dict, widgetDict, parentNames, widgets);
+		case "dropdown": return new PdfDropdownField(name, dict, widgetDict, parentNames);
+		case "listbox": return new PdfListboxField(name, dict, widgetDict, parentNames);
+		case "button": return new PdfButtonField(name, dict, widgetDict, parentNames);
+		case "signature": return new PdfSignatureField(name, dict, widgetDict, parentNames);
+	}
+}
+/**
+* Represents a PDF document's interactive form (AcroForm).
+*
+* Provides access to all form fields, bulk fill, and flatten operations.
+*/
+var PdfForm = class PdfForm {
+	/** All fields in the form (flat list). */
+	fields;
+	/** The underlying /AcroForm dictionary. */
+	acroFormDict;
+	/** Map from field name to field for fast lookup. */
+	fieldsByName;
+	constructor(fields, acroFormDict) {
+		this.fields = fields;
+		this.acroFormDict = acroFormDict;
+		this.fieldsByName = /* @__PURE__ */ new Map();
+		for (const field of fields) {
+			this.fieldsByName.set(field.getFullName(), field);
+			if (field.getName() !== field.getFullName()) this.fieldsByName.set(field.getName(), field);
+		}
+	}
+	/**
+	* Build a PdfForm from a parsed /AcroForm dictionary.
+	*
+	* Traverses the /Fields array and resolves indirect references to
+	* construct the field tree, then flattens it into a list of concrete
+	* field instances.
+	*
+	* @param acroFormDict  The /AcroForm dictionary from the document catalog.
+	* @param resolver      Function to resolve PdfRef to PdfObject.
+	*/
+	static fromDict(acroFormDict, resolver) {
+		const fieldsObj = resolveIfRef(acroFormDict.get("/Fields"), resolver);
+		if (fieldsObj === void 0 || fieldsObj.kind !== "array") return new PdfForm([], acroFormDict);
+		const fieldsArray = fieldsObj;
+		const fields = [];
+		for (const item of fieldsArray.items) {
+			const fieldDict = resolveObj(item, resolver);
+			if (fieldDict.kind !== "dict") continue;
+			PdfForm.traverseFieldTree(fieldDict, resolver, [], fields);
+		}
+		return new PdfForm(fields, acroFormDict);
+	}
+	/**
+	* Recursively traverse the field tree rooted at `dict`.
+	*
+	* The AcroForm field tree uses /Kids for both child fields and
+	* widget annotations. A node is a field if it has /FT; it is a
+	* widget annotation if it has /Subtype /Widget.
+	*/
+	static traverseFieldTree(dict, resolver, parentNames, result) {
+		const name = strVal(dict.get("/T")) ?? "";
+		const type = classifyField(dict, resolver);
+		const kidsObj = resolveIfRef(dict.get("/Kids"), resolver);
+		if (type !== void 0) if (kidsObj !== void 0 && kidsObj.kind === "array") {
+			const kidsArr = kidsObj;
+			const widgets = [];
+			for (const kid of kidsArr.items) {
+				const kidDict = resolveObj(kid, resolver);
+				if (kidDict.kind === "dict") {
+					const kidPdfDict = kidDict;
+					if (nameVal(kidPdfDict.get("/Subtype")) === "Widget") widgets.push(kidPdfDict);
+					else if (classifyField(kidPdfDict, resolver) !== void 0) {
+						PdfForm.traverseFieldTree(kidPdfDict, resolver, [...parentNames, name], result);
+						continue;
+					} else widgets.push(kidPdfDict);
+				}
+			}
+			const field = createFieldInstance(type, name, dict, widgets[0] ?? dict, parentNames, widgets);
+			result.push(field);
+		} else {
+			const field = createFieldInstance(type, name, dict, dict, parentNames, []);
+			result.push(field);
+		}
+		else if (kidsObj !== void 0 && kidsObj.kind === "array") {
+			const kidsArr = kidsObj;
+			for (const kid of kidsArr.items) {
+				const kidDict = resolveObj(kid, resolver);
+				if (kidDict.kind === "dict") PdfForm.traverseFieldTree(kidDict, resolver, name !== "" ? [...parentNames, name] : parentNames, result);
+			}
+		}
+	}
+	/** Get all fields in the form. */
+	getFields() {
+		return [...this.fields];
+	}
+	/**
+	* Get a field by name (partial or fully-qualified).
+	* Returns undefined if not found.
+	*/
+	getField(name) {
+		return this.fieldsByName.get(name);
+	}
+	/**
+	* Get a text field by name.
+	* Throws if the field is not found or is not a text field.
+	*/
+	getTextField(name) {
+		const field = this.getField(name);
+		if (field === void 0) throw new Error(`Form field "${name}" not found.`);
+		if (field.fieldType !== "text") throw new Error(`Form field "${name}" is a ${field.fieldType} field, not a text field.`);
+		return field;
+	}
+	/**
+	* Get a checkbox field by name.
+	* Throws if the field is not found or is not a checkbox.
+	*/
+	getCheckbox(name) {
+		const field = this.getField(name);
+		if (field === void 0) throw new Error(`Form field "${name}" not found.`);
+		if (field.fieldType !== "checkbox") throw new Error(`Form field "${name}" is a ${field.fieldType} field, not a checkbox.`);
+		return field;
+	}
+	/**
+	* Get a radio group by name.
+	* Throws if the field is not found or is not a radio group.
+	*/
+	getRadioGroup(name) {
+		const field = this.getField(name);
+		if (field === void 0) throw new Error(`Form field "${name}" not found.`);
+		if (field.fieldType !== "radio") throw new Error(`Form field "${name}" is a ${field.fieldType} field, not a radio group.`);
+		return field;
+	}
+	/**
+	* Get a dropdown field by name.
+	* Throws if the field is not found or is not a dropdown.
+	*/
+	getDropdown(name) {
+		const field = this.getField(name);
+		if (field === void 0) throw new Error(`Form field "${name}" not found.`);
+		if (field.fieldType !== "dropdown") throw new Error(`Form field "${name}" is a ${field.fieldType} field, not a dropdown.`);
+		return field;
+	}
+	/**
+	* Get a listbox field by name.
+	* Throws if the field is not found or is not a listbox.
+	*/
+	getListbox(name) {
+		const field = this.getField(name);
+		if (field === void 0) throw new Error(`Form field "${name}" not found.`);
+		if (field.fieldType !== "listbox") throw new Error(`Form field "${name}" is a ${field.fieldType} field, not a listbox.`);
+		return field;
+	}
+	/**
+	* Get a button field by name.
+	* Throws if the field is not found or is not a button.
+	*/
+	getButton(name) {
+		const field = this.getField(name);
+		if (field === void 0) throw new Error(`Form field "${name}" not found.`);
+		if (field.fieldType !== "button") throw new Error(`Form field "${name}" is a ${field.fieldType} field, not a button.`);
+		return field;
+	}
+	/**
+	* Get a signature field by name.
+	* Throws if the field is not found or is not a signature field.
+	*/
+	getSignatureField(name) {
+		const field = this.getField(name);
+		if (field === void 0) throw new Error(`Form field "${name}" not found.`);
+		if (field.fieldType !== "signature") throw new Error(`Form field "${name}" is a ${field.fieldType} field, not a signature field.`);
+		return field;
+	}
+	/**
+	* Fill multiple fields at once.
+	*
+	* Accepts a record where keys are field names and values are the
+	* field values to set.  Strings map to text/dropdown/listbox values;
+	* booleans map to checkbox checked states.
+	*
+	* @param values  A mapping of field name to value.
+	* @throws        If a field name is not found.
+	*/
+	fill(values) {
+		for (const [name, value] of Object.entries(values)) {
+			const field = this.getField(name);
+			if (field === void 0) throw new Error(`Form field "${name}" not found.`);
+			field.setValue(value);
+		}
+	}
+	/**
+	* Flatten the form: burn field values into the page content streams
+	* and remove the interactive form structure.
+	*
+	* After flattening, the document is no longer interactive — field
+	* values become static page content. This is done by:
+	*
+	* 1. Generating appearance streams for all fields that lack them
+	* 2. Removing the /AcroForm entry from the catalog
+	* 3. Removing /Widget annotations from page /Annots arrays
+	*
+	* Note: In this implementation, we mark the form as flattened by
+	* setting a flag and clearing the /Fields array. The appearance
+	* streams remain as page annotations will reference them.
+	*/
+	flatten() {
+		for (const field of this.fields) field.generateAppearance();
+		this.acroFormDict.set("/Fields", new require_pdfObjects.PdfArray());
+		this.acroFormDict.delete("/NeedAppearances");
+	}
+	/**
+	* Check whether the AcroForm dictionary contains XFA data.
+	*
+	* XFA (XML Forms Architecture) data causes PDF viewers to use the
+	* XFA renderer instead of the standard AcroForm renderer. Use
+	* {@link deleteXFA} to remove it.
+	*
+	* @returns `true` if the form has an /XFA entry.
+	*/
+	hasXFA() {
+		return this.acroFormDict.has("/XFA");
+	}
+	/**
+	* Remove the /XFA entry from the AcroForm dictionary, if present.
+	*
+	* XFA (XML Forms Architecture) data can cause PDF viewers to use the
+	* XFA renderer instead of the standard AcroForm renderer, which is
+	* often undesirable.  Removing /XFA forces viewers to fall back to
+	* the AcroForm fields.
+	*
+	* After removing /XFA, `/NeedAppearances` is set to `true` so that
+	* the viewer knows it must generate appearances for the AcroForm
+	* fields (since XFA appearances are no longer available).
+	*
+	* This method is a no-op if the AcroForm dictionary does not contain
+	* an /XFA entry.
+	*/
+	deleteXFA() {
+		if (!this.acroFormDict.has("/XFA")) return;
+		this.acroFormDict.delete("/XFA");
+		this.acroFormDict.set("/NeedAppearances", require_pdfObjects.PdfBool.TRUE);
+	}
+	/**
+	* Create a new text field and add it to the form.
+	*
+	* @param name  Field name.
+	* @param page  Page index (zero-based) where the widget appears.
+	* @param rect  Widget rectangle [x1, y1, x2, y2].
+	* @returns     The newly created text field.
+	*/
+	createTextField(name, page, rect) {
+		const dict = this.createFieldDict(name, "Tx", rect);
+		dict.set("/DA", require_pdfObjects.PdfString.literal("/Helv 0 Tf 0 g"));
+		const field = new PdfTextField(name, dict, dict);
+		this.fields.push(field);
+		this.fieldsByName.set(name, field);
+		this.addFieldToAcroForm(dict);
+		return field;
+	}
+	/**
+	* Create a new checkbox and add it to the form.
+	*
+	* @param name  Field name.
+	* @param page  Page index (zero-based).
+	* @param rect  Widget rectangle [x1, y1, x2, y2].
+	* @returns     The newly created checkbox field.
+	*/
+	createCheckbox(name, page, rect) {
+		const dict = this.createFieldDict(name, "Btn", rect);
+		dict.set("/V", require_pdfObjects.PdfName.of("Off"));
+		dict.set("/AS", require_pdfObjects.PdfName.of("Off"));
+		const field = new PdfCheckboxField(name, dict, dict);
+		this.fields.push(field);
+		this.fieldsByName.set(name, field);
+		this.addFieldToAcroForm(dict);
+		return field;
+	}
+	/**
+	* Create a new dropdown and add it to the form.
+	*
+	* @param name     Field name.
+	* @param page     Page index (zero-based).
+	* @param rect     Widget rectangle [x1, y1, x2, y2].
+	* @param options  The list of option strings.
+	* @returns        The newly created dropdown field.
+	*/
+	createDropdown(name, page, rect, options) {
+		const dict = this.createFieldDict(name, "Ch", rect);
+		dict.set("/Ff", require_pdfObjects.PdfNumber.of(FieldFlags.Combo));
+		dict.set("/Opt", require_pdfObjects.PdfArray.of(options.map((o) => require_pdfObjects.PdfString.literal(o))));
+		dict.set("/DA", require_pdfObjects.PdfString.literal("/Helv 0 Tf 0 g"));
+		const field = new PdfDropdownField(name, dict, dict);
+		this.fields.push(field);
+		this.fieldsByName.set(name, field);
+		this.addFieldToAcroForm(dict);
+		return field;
+	}
+	/**
+	* Create a new radio button group and add it to the form.
+	*
+	* A radio group is a single field with multiple widget annotations,
+	* one per rectangle in `rects`.  Each widget corresponds to an
+	* option; if `options` is supplied the n-th option labels the n-th
+	* widget, otherwise options default to `"Option0"`, `"Option1"`, etc.
+	*
+	* @param name     Field name.
+	* @param page     The PdfPage where the widgets appear (unused for
+	*                 positioning in the low-level dict, but reserved
+	*                 for future page-level annotation linking).
+	* @param rects    Array of widget rectangles `{x, y, width, height}`.
+	* @param options  Optional option labels (one per rect).
+	* @returns        The newly created radio group.
+	*/
+	createRadioGroup(name, page, rects, options) {
+		const fieldDict = new require_pdfObjects.PdfDict();
+		fieldDict.set("/FT", require_pdfObjects.PdfName.of("Btn"));
+		fieldDict.set("/Ff", require_pdfObjects.PdfNumber.of(FieldFlags.Radio | FieldFlags.NoToggleToOff));
+		fieldDict.set("/T", require_pdfObjects.PdfString.literal(name));
+		fieldDict.set("/V", require_pdfObjects.PdfName.of("Off"));
+		const widgets = [];
+		const kidsArr = new require_pdfObjects.PdfArray();
+		for (let i = 0; i < rects.length; i++) {
+			const r = rects[i];
+			const optName = options?.[i] ?? `Option${i}`;
+			const rect = [
+				r.x,
+				r.y,
+				r.x + r.width,
+				r.y + r.height
+			];
+			const widgetDict = new require_pdfObjects.PdfDict();
+			widgetDict.set("/Type", require_pdfObjects.PdfName.of("Annot"));
+			widgetDict.set("/Subtype", require_pdfObjects.PdfName.of("Widget"));
+			widgetDict.set("/Rect", require_pdfObjects.PdfArray.fromNumbers(rect));
+			widgetDict.set("/AS", require_pdfObjects.PdfName.of("Off"));
+			widgetDict.set("/Parent", fieldDict);
+			const nDict = new require_pdfObjects.PdfDict();
+			nDict.set(`/${optName}`, new require_pdfObjects.PdfStream(new require_pdfObjects.PdfDict(), new Uint8Array(0)));
+			nDict.set("/Off", new require_pdfObjects.PdfStream(new require_pdfObjects.PdfDict(), new Uint8Array(0)));
+			const apDict = new require_pdfObjects.PdfDict();
+			apDict.set("/N", nDict);
+			widgetDict.set("/AP", apDict);
+			widgets.push(widgetDict);
+			kidsArr.push(widgetDict);
+		}
+		fieldDict.set("/Kids", kidsArr);
+		const field = new PdfRadioGroup(name, fieldDict, widgets[0] ?? fieldDict, [], widgets);
+		this.fields.push(field);
+		this.fieldsByName.set(name, field);
+		this.addFieldToAcroForm(fieldDict);
+		return field;
+	}
+	/**
+	* Create a new push button and add it to the form.
+	*
+	* @param name   Field name.
+	* @param page   The PdfPage where the widget appears.
+	* @param rect   Widget rectangle `{x, y, width, height}`.
+	* @param label  Optional button caption.
+	* @returns      The newly created button field.
+	*/
+	createButton(name, page, rect, label) {
+		const pdfRect = [
+			rect.x,
+			rect.y,
+			rect.x + rect.width,
+			rect.y + rect.height
+		];
+		const dict = this.createFieldDict(name, "Btn", pdfRect);
+		dict.set("/Ff", require_pdfObjects.PdfNumber.of(FieldFlags.Pushbutton));
+		if (label !== void 0) {
+			const mk = new require_pdfObjects.PdfDict();
+			mk.set("/CA", require_pdfObjects.PdfString.literal(label));
+			dict.set("/MK", mk);
+		}
+		const field = new PdfButtonField(name, dict, dict);
+		this.fields.push(field);
+		this.fieldsByName.set(name, field);
+		this.addFieldToAcroForm(dict);
+		return field;
+	}
+	/**
+	* Create a new listbox and add it to the form.
+	*
+	* A listbox is a choice field (/FT /Ch) without the Combo flag,
+	* displaying a scrollable list of options.
+	*
+	* @param name     Field name.
+	* @param page     The PdfPage where the widget appears.
+	* @param rect     Widget rectangle `{x, y, width, height}`.
+	* @param options  The list of option strings.
+	* @returns        The newly created listbox field.
+	*/
+	createListbox(name, page, rect, options) {
+		const pdfRect = [
+			rect.x,
+			rect.y,
+			rect.x + rect.width,
+			rect.y + rect.height
+		];
+		const dict = this.createFieldDict(name, "Ch", pdfRect);
+		dict.set("/Opt", require_pdfObjects.PdfArray.of(options.map((o) => require_pdfObjects.PdfString.literal(o))));
+		dict.set("/DA", require_pdfObjects.PdfString.literal("/Helv 0 Tf 0 g"));
+		const field = new PdfListboxField(name, dict, dict);
+		this.fields.push(field);
+		this.fieldsByName.set(name, field);
+		this.addFieldToAcroForm(dict);
+		return field;
+	}
+	/**
+	* Remove a field from the form by name.
+	*
+	* Removes the field from the internal field list, the name index,
+	* and the /Fields array in the AcroForm dictionary.
+	*
+	* @param name  The field name (partial or fully-qualified).
+	* @throws      If no field with the given name exists.
+	*/
+	removeField(name) {
+		const field = this.fieldsByName.get(name);
+		if (field === void 0) throw new Error(`Form field "${name}" not found.`);
+		const idx = this.fields.indexOf(field);
+		if (idx !== -1) this.fields.splice(idx, 1);
+		this.fieldsByName.delete(field.getFullName());
+		if (field.getName() !== field.getFullName()) this.fieldsByName.delete(field.getName());
+		const fieldsObj = this.acroFormDict.get("/Fields");
+		if (fieldsObj !== void 0 && fieldsObj.kind === "array") {
+			const fieldsArr = fieldsObj;
+			const fieldDict = field.getDict();
+			const newArr = new require_pdfObjects.PdfArray(fieldsArr.items.filter((item) => item !== fieldDict));
+			this.acroFormDict.set("/Fields", newArr);
+		}
+	}
+	/**
+	* Serialize the form back to a PdfDict.
+	*
+	* Updates /NeedAppearances if appearances need to be generated
+	* by the viewer.
+	*/
+	toDict(registry) {
+		if (this.acroFormDict.get("/DR") === void 0) {
+			const resources = new require_pdfObjects.PdfDict();
+			const fontDict = new require_pdfObjects.PdfDict();
+			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"));
+			fontDict.set("/Helv", helvetica);
+			resources.set("/Font", fontDict);
+			this.acroFormDict.set("/DR", resources);
+		}
+		return this.acroFormDict;
+	}
+	/**
+	* Create a basic field dictionary with common entries.
+	*/
+	createFieldDict(name, fieldType, rect) {
+		const dict = new require_pdfObjects.PdfDict();
+		dict.set("/Type", require_pdfObjects.PdfName.of("Annot"));
+		dict.set("/Subtype", require_pdfObjects.PdfName.of("Widget"));
+		dict.set("/FT", require_pdfObjects.PdfName.of(fieldType));
+		dict.set("/T", require_pdfObjects.PdfString.literal(name));
+		dict.set("/Rect", require_pdfObjects.PdfArray.fromNumbers(rect));
+		return dict;
+	}
+	/**
+	* Add a field dictionary to the /Fields array in the AcroForm.
+	*/
+	addFieldToAcroForm(fieldDict) {
+		let fieldsObj = this.acroFormDict.get("/Fields");
+		if (fieldsObj === void 0 || fieldsObj.kind !== "array") {
+			fieldsObj = new require_pdfObjects.PdfArray();
+			this.acroFormDict.set("/Fields", fieldsObj);
+		}
+		fieldsObj.push(fieldDict);
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'FieldFlags', {
+  enumerable: true,
+  get: function () {
+    return FieldFlags;
+  }
+});
+Object.defineProperty(exports, 'PdfButtonField', {
+  enumerable: true,
+  get: function () {
+    return PdfButtonField;
+  }
+});
+Object.defineProperty(exports, 'PdfCheckboxField', {
+  enumerable: true,
+  get: function () {
+    return PdfCheckboxField;
+  }
+});
+Object.defineProperty(exports, 'PdfDropdownField', {
+  enumerable: true,
+  get: function () {
+    return PdfDropdownField;
+  }
+});
+Object.defineProperty(exports, 'PdfField', {
+  enumerable: true,
+  get: function () {
+    return PdfField;
+  }
+});
+Object.defineProperty(exports, 'PdfForm', {
+  enumerable: true,
+  get: function () {
+    return PdfForm;
+  }
+});
+Object.defineProperty(exports, 'PdfListboxField', {
+  enumerable: true,
+  get: function () {
+    return PdfListboxField;
+  }
+});
+Object.defineProperty(exports, 'PdfRadioGroup', {
+  enumerable: true,
+  get: function () {
+    return PdfRadioGroup;
+  }
+});
+Object.defineProperty(exports, 'PdfSignatureField', {
+  enumerable: true,
+  get: function () {
+    return PdfSignatureField;
+  }
+});
+Object.defineProperty(exports, 'PdfTextField', {
+  enumerable: true,
+  get: function () {
+    return PdfTextField;
+  }
+});
+Object.defineProperty(exports, 'generateButtonAppearance', {
+  enumerable: true,
+  get: function () {
+    return generateButtonAppearance;
+  }
+});
+Object.defineProperty(exports, 'generateCheckboxAppearance', {
+  enumerable: true,
+  get: function () {
+    return generateCheckboxAppearance;
+  }
+});
+Object.defineProperty(exports, 'generateDropdownAppearance', {
+  enumerable: true,
+  get: function () {
+    return generateDropdownAppearance;
+  }
+});
+Object.defineProperty(exports, 'generateListboxAppearance', {
+  enumerable: true,
+  get: function () {
+    return generateListboxAppearance;
+  }
+});
+Object.defineProperty(exports, 'generateRadioAppearance', {
+  enumerable: true,
+  get: function () {
+    return generateRadioAppearance;
+  }
+});
+Object.defineProperty(exports, 'generateSignatureAppearance', {
+  enumerable: true,
+  get: function () {
+    return generateSignatureAppearance;
+  }
+});
+Object.defineProperty(exports, 'generateTextAppearance', {
+  enumerable: true,
+  get: function () {
+    return generateTextAppearance;
+  }
+});
+//# sourceMappingURL=pdfForm-9gd40uz9.cjs.map