@embedpdf/engine-core 3.0.0-next.14 → 3.0.0-next.16

package/dist/Change-Ct-dB8D5.cjs

@@ -0,0 +1,1133 @@
+const require_calibrate = require("./calibrate-DJbi1wuK.cjs");
+const require_format = require("./format-Bp3QFSH1.cjs");
+//#region src/dto/DocumentOutline.ts
+/**
+* How much of an outline a read takes: the items, and how deep they nest.
+* Past either, the read stops and says `incomplete`.
+*/
+const OUTLINE_READ_LIMITS = {
+	items: 5e4,
+	depth: 128
+};
+//#endregion
+//#region src/outline/predict.ts
+/** A target as a read returns it: the target, and the `/A` action it is written as. */
+function targetFieldsOf(target) {
+	return target ? {
+		target,
+		action: require_calibrate.actionTreeOf(target)
+	} : {
+		target: null,
+		action: null
+	};
+}
+/** A colour as a read returns it: `#rrggbb` in lowercase digits, or `null`. */
+const colorAsRead = (color) => color ? color.toLowerCase() : null;
+/** `outline.create`: the new item. It has no children yet, so it isn't open. */
+function outlineItemOfDraft(ref, parent, draft) {
+	return {
+		ref,
+		parent,
+		title: draft.title,
+		...targetFieldsOf(draft.target ?? null),
+		open: false,
+		color: colorAsRead(draft.color),
+		bold: draft.bold ?? false,
+		italic: draft.italic ?? false
+	};
+}
+/**
+* `outline.update`: the item with the fields the patch names. `open` holds
+* only on an item with children (`hasChildren`): a leaf has no open state.
+* Returns `item` itself when the patch changes nothing.
+*/
+function outlineItemAfter(item, patch, hasChildren) {
+	const next = {
+		...item,
+		...patch.title !== void 0 ? { title: patch.title } : {},
+		...patch.target !== void 0 ? targetFieldsOf(patch.target) : {},
+		...patch.color !== void 0 ? { color: colorAsRead(patch.color) } : {},
+		...patch.bold !== void 0 ? { bold: patch.bold } : {},
+		...patch.italic !== void 0 ? { italic: patch.italic } : {},
+		...patch.open !== void 0 ? { open: patch.open && hasChildren } : {}
+	};
+	return patch.target === void 0 && next.title === item.title && next.color === item.color && next.bold === item.bold && next.italic === item.italic && next.open === item.open ? item : next;
+}
+/**
+* An item whose children a write changed: one left without children is no
+* longer open, and one that gains its first child stays closed, as a leaf
+* is. Returns `item` itself when that changes nothing.
+*/
+function outlineItemWithChildren(item, hasChildren) {
+	return item.open && !hasChildren ? {
+		...item,
+		open: false
+	} : item;
+}
+//#endregion
+//#region src/mutation/AttachmentMutationResults.ts
+/**
+* What a delete removed, as its `attachments.deleted` event names it for
+* listeners that didn't make the call.
+*/
+function deletedAttachmentOf(result) {
+	return result.meta.changed[0] ?? null;
+}
+//#endregion
+//#region src/forms/write.ts
+/** The shapes each family takes, for the message when a value doesn't fit. */
+const TAKES = {
+	text: "{ value }",
+	checkbox: "{ checked } or { value }",
+	radio: "{ value }",
+	combobox: "{ value }",
+	listbox: "{ selectedValues }"
+};
+/**
+* The write `value` makes for `field`, checked before anything is written:
+* the shape must be one the family takes, a toggle's value must be the
+* export value of one of its widgets (a radio group that must keep a choice
+* can't be cleared), and a choice must be option values (free text for a
+* dropdown that allows editing). `InvalidArg` otherwise.
+*/
+function fieldValueWriteOf(field, value) {
+	switch (field.family) {
+		case "text":
+			if ("value" in value) return {
+				kind: "text",
+				value: value.value ?? ""
+			};
+			break;
+		case "checkbox":
+			if ("checked" in value) {
+				if (!value.checked) return {
+					kind: "toggle",
+					state: null
+				};
+				const first = field.widgets[0];
+				if (!first) throw invalidValue(`'${field.name}' has no widget to check`);
+				return {
+					kind: "toggle",
+					state: first.onState
+				};
+			}
+			if ("value" in value) return {
+				kind: "toggle",
+				state: toggleStateOf(field, value.value)
+			};
+			break;
+		case "radio":
+			if ("value" in value) {
+				const state = toggleStateOf(field, value.value);
+				if (state === null && field.noToggleToOff) throw invalidValue(`'${field.name}' must keep a choice: it can't be cleared`);
+				return {
+					kind: "toggle",
+					state
+				};
+			}
+			break;
+		case "combobox":
+			if ("value" in value) return choiceOf(field, value.value === null ? [] : [value.value]);
+			break;
+		case "listbox":
+			if ("selectedValues" in value) return choiceOf(field, value.selectedValues);
+			break;
+		default: throw invalidValue(`${field.family} fields hold no value you can set`);
+	}
+	throw invalidValue(`a ${field.family} field takes ${TAKES[field.family]}, not ${shapeOf(value)}`);
+}
+/**
+* Check a choice field's default (`/DV`) before it is written: option values
+* (one free text for a dropdown that allows editing), none twice, and one
+* value unless the list box takes several. `InvalidArg` otherwise.
+*/
+function assertChoiceDefault(target, values) {
+	const invalid = (message) => new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, message, { details: { field: "defaultValue" } });
+	if (new Set(values).size !== values.length) throw invalid("the default values must not repeat");
+	if (values.length > 1 && !(target.family === "listbox" && target.multiSelect)) throw invalid(`a ${target.family === "listbox" ? "list without multiSelect" : "dropdown"} has one default`);
+	const freeText = target.family === "combobox" && target.edit === true;
+	const optionValues = new Set(target.options.map((option) => option.value));
+	const unknown = values.find((value) => !optionValues.has(value));
+	if (unknown !== void 0 && !freeText) throw invalid(`'${unknown}' is not an option value of the ${target.family === "listbox" ? "list" : "dropdown"}`);
+}
+/** Whether `write` would leave `field` as it is. */
+function isNoOpWrite(field, write) {
+	switch (write.kind) {
+		case "text": return field.family === "text" && field.value === write.value;
+		case "toggle": return (field.family === "checkbox" || field.family === "radio") && field.widgets.every((widget) => widget.checked === (widget.onState === write.state));
+		case "choice":
+			if (field.family === "combobox") return write.values.length === 0 ? field.value === "" : field.value === write.values[0];
+			return field.family === "listbox" && field.selectedValues.length === write.values.length && field.selectedValues.every((value, index) => value === write.values[index]);
+	}
+}
+/**
+* Whether a reset would leave `field` as it is: its value is its default, and
+* a checkbox's or radio group's buttons show that default.
+*/
+function isAtDefault(field) {
+	if (field.valueEntry.kind === "unsupported") return false;
+	if (!valueEntriesEqual(field.valueEntry, field.defaultValueEntry)) return false;
+	if (field.family !== "checkbox" && field.family !== "radio") return true;
+	const entry = field.defaultValueEntry;
+	const state = entry.kind === "scalar" ? entry.value : null;
+	return field.widgets.every((widget) => widget.checked === (widget.onState === state));
+}
+/** Whether two value entries hold the same value. */
+function valueEntriesEqual(left, right) {
+	if (left.kind !== right.kind) return false;
+	if (left.kind === "scalar" && right.kind === "scalar") return left.value === right.value;
+	if (left.kind === "array" && right.kind === "array") return left.values.length === right.values.length && left.values.every((value, index) => value === right.values[index]);
+	return true;
+}
+/** A checkbox's or radio group's on-state for an export value; `'Off'` and `null` clear it. */
+function toggleStateOf(field, exportValue) {
+	if (exportValue === null || exportValue === "Off") return null;
+	const widget = field.widgets.find((candidate) => candidate.exportValue === exportValue);
+	if (!widget) throw invalidValue(`no widget of '${field.name}' has the export value '${exportValue}'`);
+	return widget.onState;
+}
+function choiceOf(field, values) {
+	if (new Set(values).size !== values.length) throw invalidValue("the values must not repeat");
+	if (field.family === "listbox" && !field.multiSelect && values.length > 1) throw invalidValue(`'${field.name}' takes one value (it has no multiSelect)`);
+	const optionValues = new Set(field.options.map((option) => option.value));
+	const freeText = field.family === "combobox" && field.edit && values.length === 1;
+	const unknown = values.find((value) => !optionValues.has(value));
+	if (!freeText && unknown !== void 0) throw invalidValue(`'${unknown}' is not an option value of '${field.name}'`);
+	return {
+		kind: "choice",
+		values
+	};
+}
+function shapeOf(value) {
+	if ("checked" in value) return "{ checked }";
+	if ("selectedValues" in value) return "{ selectedValues }";
+	return "{ value }";
+}
+function invalidValue(message) {
+	return new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, message, { details: { field: "value" } });
+}
+//#endregion
+//#region src/forms/widgets.ts
+/**
+* A widget placement or patch as a `family` widget takes it. `/MK /CA` is a
+* push button's caption and a checkbox's or radio button's symbol
+* (`checkStyle`), so each goes on its own family's widgets only: on another
+* widget, a `null` (as its row reads) is dropped, and a value is refused.
+*/
+function fitWidgetToFamily(family, value) {
+	const toggle = family === "checkbox" || family === "radio";
+	return fitToFamily(family, fitToFamily(family, value, "caption", family === "pushbutton", "a push button's"), "checkStyle", toggle, "a checkbox's or radio button's");
+}
+function fitToFamily(family, value, key, takes, whose) {
+	if (takes || value[key] === void 0) return value;
+	if (value[key] !== null) {
+		const widget = family === "unknown" ? "this widget" : `a ${family} field's widget`;
+		throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, `'${key}' applies to ${whose} widgets, not to ${widget}`, { details: { field: key } });
+	}
+	const { [key]: _none, ...rest } = value;
+	return rest;
+}
+/**
+* `forms.updateWidget`: the row a widget patch leaves, as an annotation
+* patch leaves it (a move keeps the look), checked against the widget's
+* family first. A new box or turn moves where it stands (`standingRectOf`).
+*/
+function widgetAfterPatch(row, patch) {
+	const fitted = fitWidgetToFamily(row.fieldFamily, patch);
+	const after = require_calibrate.applyAnnotationPatch(row, {
+		subtype: "widget",
+		...fitted
+	});
+	if (![
+		"box",
+		"rect",
+		"rotation"
+	].some((key) => key in fitted)) return after;
+	return {
+		...after,
+		rect: standingRectOf(after.box, after.rotation)
+	};
+}
+/**
+* Where a widget stands on the page: its box, with its sides swapped under a
+* quarter turn (its contents turn, the frame keeps its place).
+*/
+function standingRectOf(box, rotation) {
+	const turn = ((rotation ?? 0) % 360 + 360) % 360;
+	if (turn !== 90 && turn !== 270) return box;
+	const { x, y, width, height } = box;
+	return {
+		...box,
+		x: x + (width - height) / 2,
+		y: y + (height - width) / 2,
+		width: height,
+		height: width
+	};
+}
+//#endregion
+//#region src/forms/predict.ts
+/**
+* `forms.setValue`: a text field holds the text, cut to its maximum length
+* (in characters); a checkbox checks every widget with the target's export
+* value and on-state; a radio group checks the first button with the value,
+* or every one with it when its radios move in unison; a choice field holds
+* its option values in option order, or a dropdown's free text. Refuses what
+* the engine refuses (`fieldValueWriteOf`).
+*/
+function fieldAfterValue(current, value) {
+	const { field } = current;
+	const write = fieldValueWriteOf(field, value);
+	switch (write.kind) {
+		case "text": {
+			if (field.family !== "text") return current;
+			const text = firstCharacters(write.value, field.maxLength);
+			if (text === field.value) return current;
+			return redrawn({
+				...field,
+				value: text,
+				valueEntry: {
+					kind: "scalar",
+					value: text
+				}
+			}, current);
+		}
+		case "toggle": {
+			if (field.family !== "checkbox" && field.family !== "radio") return current;
+			const target = field.widgets.findIndex((widget) => widget.onState === write.state);
+			return toggled(current, write.state === null ? -1 : target);
+		}
+		case "choice":
+			if (field.family !== "combobox" && field.family !== "listbox") return current;
+			return redrawn(choiceFieldWith(field, write.values), current);
+	}
+}
+/**
+* `forms.reset`: back to the default value. A text field holds its default
+* (or nothing); a choice field its default options; a checkbox or radio
+* group checks the widget its default names, or none.
+*/
+function fieldAfterReset(current) {
+	const { field } = current;
+	const defaults = field.defaultValueEntry;
+	switch (field.family) {
+		case "text": {
+			if (defaults.kind === "array" || defaults.kind === "unsupported") throw notReset(field);
+			const value = defaults.kind === "scalar" ? defaults.value : "";
+			const entry = defaults.kind === "scalar" ? defaults : { kind: "none" };
+			return redrawn({
+				...field,
+				value,
+				valueEntry: entry
+			}, current);
+		}
+		case "checkbox":
+		case "radio": {
+			if (defaults.kind === "array" || defaults.kind === "unsupported") throw notReset(field);
+			const state = defaults.kind === "scalar" ? defaults.value : null;
+			if (state === null || state === "Off") return toggled(current, -1);
+			const target = widgetNamedBy(field.widgets, state);
+			if (target < 0) throw notReset(field);
+			return toggled(current, target);
+		}
+		case "combobox":
+		case "listbox": {
+			if (defaults.kind === "unsupported") throw notReset(field);
+			let values = defaults.kind === "scalar" ? [defaults.value] : defaults.kind === "array" ? [...defaults.values] : [];
+			if (values.length === 1 && values[0] === "" && !choiceMatches(field, values)) values = [];
+			if (!choiceMatches(field, values) && !freeTextAllowed(field, values)) throw notReset(field);
+			return redrawn(choiceFieldWith(field, values), current);
+		}
+		default: throw notReset(field);
+	}
+}
+/**
+* `forms.setDisplay`, on each widget's flags, as Acrobat's `Field.display`
+* sets them: visible and printed; hidden; visible but not printed; printed
+* but not shown on screen.
+*/
+function widgetsAfterDisplay(widgets, display) {
+	const flags = DISPLAY_FLAGS[display];
+	return widgets.map((row) => Object.keys(flags).every((key) => row[key] === flags[key]) ? row : {
+		...row,
+		...flags
+	});
+}
+const DISPLAY_FLAGS = {
+	visible: {
+		invisible: false,
+		hidden: false,
+		noView: false,
+		print: true
+	},
+	hidden: {
+		invisible: false,
+		hidden: true,
+		noView: false,
+		print: true
+	},
+	noPrint: {
+		invisible: false,
+		hidden: false,
+		noView: false,
+		print: false
+	},
+	noView: {
+		hidden: false,
+		noView: true,
+		print: true
+	}
+};
+/**
+* The default (`/DV`) a draft gives its field: a text field's or dropdown's
+* one value, a list box's option values in option order; none without one.
+*/
+function defaultEntryOfDraft(draft) {
+	if ((draft.family === "combobox" || draft.family === "listbox") && draft.defaultValue !== void 0) {
+		const values = Array.isArray(draft.defaultValue) ? draft.defaultValue : [draft.defaultValue];
+		assertChoiceDefault({
+			...draft,
+			options: draft.options ?? []
+		}, values);
+	}
+	switch (draft.family) {
+		case "text":
+		case "combobox": return draft.defaultValue !== void 0 ? scalar(draft.defaultValue) : none();
+		case "listbox": return choiceEntryOf(inOptionOrder((draft.options ?? []).map(optionOf), draft.defaultValue ?? []));
+		default: return none();
+	}
+}
+/**
+* `forms.create`: the field and its widgets as a read of them returns them.
+* Every flag the draft doesn't set is off, the value is empty (a default
+* only sets the default), a checkbox's export value is `'Yes'` unless its
+* widget names one, and a toggle's widgets start off.
+*/
+function formFieldOfDraft(draft, context) {
+	const placements = draft.widgets ?? [];
+	const rows = placements.map((placement, at) => widgetRowOfPlacement(draft, placement, {
+		ref: context.widgets[at],
+		field: context.objectNumber,
+		nm: context.widgetNames?.[at]
+	}));
+	const widgets = rows.map((row) => require_format.formWidget(objectNumberOf(row.ref), row.page));
+	const options = (draft.family === "combobox" || draft.family === "listbox" ? draft.options ?? [] : []).map(optionOf);
+	const base = {
+		ref: {
+			kind: "objectNumber",
+			objectNumber: context.objectNumber
+		},
+		name: draft.name,
+		origin: "acroform",
+		readOnly: draft.readOnly ?? false,
+		required: draft.required ?? false,
+		noExport: draft.noExport ?? false,
+		alternateName: draft.alternateName ?? null,
+		mappingName: draft.mappingName ?? null,
+		valueEntry: { kind: "none" },
+		defaultValueEntry: { kind: "none" },
+		groupId: draft.groupId ?? context.groupId ?? null,
+		createdBy: context.createdBy ?? null,
+		createdAt: context.createdAt ?? null,
+		filledBy: null,
+		filledByName: null,
+		filledAt: null,
+		importedBy: null
+	};
+	let field;
+	switch (draft.family) {
+		case "text": {
+			const defaultValue = draft.defaultValue ?? "";
+			field = {
+				...base,
+				family: "text",
+				defaultValueEntry: defaultEntryOfDraft(draft),
+				value: "",
+				defaultValue,
+				maxLength: draft.maxLength ?? null,
+				multiline: draft.multiline ?? false,
+				password: draft.password ?? false,
+				comb: draft.comb ?? false,
+				widgets
+			};
+			break;
+		}
+		case "checkbox": {
+			const toggles = placements.map((placement, at) => toggleWidgetOf(widgets[at], placement.exportValue ?? "Yes"));
+			field = {
+				...base,
+				family: "checkbox",
+				checked: false,
+				exportValue: toggles[0]?.exportValue ?? "Yes",
+				widgets: toggles
+			};
+			break;
+		}
+		case "radio": {
+			const toggles = placements.map((placement, at) => toggleWidgetOf(widgets[at], placement.exportValue ?? ""));
+			field = {
+				...base,
+				family: "radio",
+				value: "Off",
+				radiosInUnison: draft.radiosInUnison ?? false,
+				noToggleToOff: draft.noToggleToOff ?? false,
+				widgets: toggles
+			};
+			break;
+		}
+		case "combobox":
+			field = {
+				...base,
+				family: "combobox",
+				defaultValueEntry: defaultEntryOfDraft(draft),
+				value: "",
+				defaultValue: draft.defaultValue ?? "",
+				edit: draft.edit ?? false,
+				options,
+				widgets
+			};
+			break;
+		case "listbox": {
+			const defaults = draft.defaultValue ?? [];
+			field = {
+				...base,
+				family: "listbox",
+				defaultValueEntry: defaultEntryOfDraft(draft),
+				selectedValues: [],
+				defaultValue: inOptionOrder(options, defaults),
+				multiSelect: draft.multiSelect ?? false,
+				options,
+				topIndex: 0,
+				widgets
+			};
+			break;
+		}
+		default: field = {
+			...base,
+			family: draft.family,
+			widgets
+		};
+	}
+	return {
+		field,
+		widgets: rows
+	};
+}
+/**
+* `forms.update`: the settings the patch names. A new name replaces the
+* field's own segment of its dotted name; new options keep what is still
+* selected (an editable dropdown keeps its free text) and its default the
+* same way; `null` clears a limit, a name or a default.
+*/
+function formFieldAfter(current, patch) {
+	const given = patch;
+	let field = { ...current.field };
+	if (patch.name !== void 0) {
+		const parent = field.name.lastIndexOf(".");
+		field.name = parent < 0 ? patch.name : `${field.name.slice(0, parent + 1)}${patch.name}`;
+	}
+	for (const flag of FLAGS) if (typeof given[flag] === "boolean" && flag in field) field[flag] = given[flag];
+	if (patch.alternateName !== void 0) field.alternateName = patch.alternateName || null;
+	if (patch.mappingName !== void 0) field.mappingName = patch.mappingName || null;
+	if (patch.groupId !== void 0) field.groupId = patch.groupId;
+	if (field.family === "text") {
+		if ("maxLength" in patch && patch.maxLength !== void 0) field.maxLength = patch.maxLength;
+		if ("defaultValue" in patch && patch.defaultValue !== void 0) {
+			const value = patch.defaultValue;
+			field.defaultValue = value ?? "";
+			field.defaultValueEntry = value === null ? none() : scalar(value);
+		}
+	}
+	let redraw = false;
+	if (field.family === "combobox" || field.family === "listbox") {
+		if ("options" in patch && patch.options) {
+			field = withOptions(field, patch.options.map(optionOf));
+			redraw = true;
+		}
+		if ("defaultValue" in patch && patch.defaultValue !== void 0) {
+			const values = patch.defaultValue === null ? [] : Array.isArray(patch.defaultValue) ? patch.defaultValue : [patch.defaultValue];
+			assertChoiceDefault(field, values);
+			field = withDefault(field, values);
+		}
+	}
+	const after = {
+		...current,
+		field
+	};
+	return redraw ? redrawn(after.field, after) : after;
+}
+const FLAGS = [
+	"readOnly",
+	"required",
+	"noExport",
+	"multiline",
+	"password",
+	"comb",
+	"radiosInUnison",
+	"noToggleToOff",
+	"edit",
+	"multiSelect"
+];
+/** The first `limit` characters of `text` (characters, as the file counts them); all without a limit. */
+function firstCharacters(text, limit) {
+	if (!limit) return text;
+	const characters = Array.from(text);
+	return characters.length > limit ? characters.slice(0, limit).join("") : text;
+}
+/** The field, with every widget's appearance drawn again (a text or choice write). */
+function redrawn(field, current) {
+	return {
+		field,
+		widgets: current.widgets.map((row) => row.hasAppearance ? row : {
+			...row,
+			hasAppearance: true
+		})
+	};
+}
+/**
+* The widget a checkbox's or radio group's default names: the one whose
+* on-state it is, or, when none is, the one at that position (a field with
+* `/Opt` written by a tool that names its widgets by position). `-1`: none.
+*/
+function widgetNamedBy(widgets, state) {
+	const named = widgets.findIndex((widget) => widget.onState === state);
+	if (named >= 0 || !/^\d+$/.test(state)) return named;
+	return Number(state) < widgets.length ? Number(state) : -1;
+}
+/**
+* A checkbox or radio group with widget `target` checked (`-1`: none), and
+* the widgets that go with it: every widget with its export value and
+* on-state for a checkbox or radios in unison, otherwise that one. Its value
+* names the checked widget's on-state (`/V` names the appearance state that
+* is on), or `Off`.
+*/
+function toggled(current, target) {
+	const field = current.field;
+	if (field.family !== "checkbox" && field.family !== "radio") return current;
+	const unison = field.family === "checkbox" || field.radiosInUnison;
+	const on = target >= 0 ? field.widgets[target] : null;
+	const toggles = field.widgets.map((widget, at) => {
+		const checked = on !== null && (unison ? widget.exportValue === on.exportValue && widget.onState === on.onState : at === target);
+		return widget.checked === checked ? widget : {
+			...widget,
+			checked
+		};
+	});
+	const valueEntry = scalar(on ? on.onState : "Off");
+	const next = field.family === "checkbox" ? {
+		...field,
+		widgets: toggles,
+		valueEntry,
+		checked: toggles.some((widget) => widget.checked)
+	} : {
+		...field,
+		widgets: toggles,
+		valueEntry,
+		value: toggles.find((widget) => widget.checked)?.exportValue ?? "Off"
+	};
+	const states = new Map(toggles.map((widget) => [widget.objectNumber, widget.checked ? widget.onState : "Off"]));
+	return {
+		field: next,
+		widgets: current.widgets.map((row) => {
+			const state = states.get(objectNumberOf(row.ref));
+			return state === void 0 || row.appearanceState === state ? row : {
+				...row,
+				appearanceState: state
+			};
+		})
+	};
+}
+/** The option indexes `values` name, each the first option with that value, in option order. */
+function matchedIndexes(options, values) {
+	const indexes = /* @__PURE__ */ new Set();
+	for (const value of values) {
+		const at = options.findIndex((option) => option.value === value);
+		if (at >= 0) indexes.add(at);
+	}
+	return [...indexes].sort((left, right) => left - right);
+}
+const choiceMatches = (field, values) => values.every((value) => field.options.some((option) => option.value === value));
+const freeTextAllowed = (field, values) => field.family === "combobox" && field.edit && values.length === 1;
+/** A choice field holding `values`: its options' selection, its value and `/V`. */
+function choiceFieldWith(field, values) {
+	const matched = choiceMatches(field, values) ? matchedIndexes(field.options, values) : [];
+	const freeText = values.length > 0 && matched.length === 0;
+	const options = field.options.map((option, at) => {
+		const selected = matched.includes(at);
+		return option.selected === selected ? option : {
+			...option,
+			selected
+		};
+	});
+	const chosen = freeText ? [...values] : matched.map((at) => field.options[at].value);
+	const valueEntry = choiceEntryOf(chosen);
+	if (field.family === "combobox") return {
+		...field,
+		options,
+		valueEntry,
+		value: chosen[0] ?? ""
+	};
+	return {
+		...field,
+		options,
+		valueEntry,
+		selectedValues: chosen
+	};
+}
+/** How `/V` (or `/DV`) holds choice values: none, one string, or an array. */
+function choiceEntryOf(values) {
+	if (values.length === 0) return none();
+	return values.length === 1 ? scalar(values[0]) : {
+		kind: "array",
+		values: [...values]
+	};
+}
+/** `values` that are option values, in option order. */
+function inOptionOrder(options, values) {
+	return matchedIndexes(options, values).map((at) => options[at].value);
+}
+/** A choice field with new options: what is still an option stays selected, and stays its default. */
+function withOptions(field, options) {
+	const exports = options.map((option) => option.value);
+	const keepsFreeText = field.family === "combobox" && field.edit;
+	const kept = keptValues(field.family === "combobox" ? field.value === "" ? [] : [field.value] : field.selectedValues, exports, keepsFreeText);
+	const reselected = choiceFieldWith(field.family === "listbox" ? {
+		...field,
+		options,
+		topIndex: topRowOf(field.topIndex, options)
+	} : {
+		...field,
+		options
+	}, kept);
+	const defaults = valuesOfEntry(field.defaultValueEntry);
+	if (field.defaultValueEntry.kind === "none") return reselected;
+	return withDefault(reselected, keptValues(defaults, exports, keepsFreeText), true);
+}
+/** A list box's top row: an option's position, the last one past the end. */
+function topRowOf(topIndex, options) {
+	return Math.max(0, Math.min(topIndex, options.length - 1));
+}
+/** The values still among `exports`; free text survives when nothing else does. */
+function keptValues(values, exports, keepFreeText) {
+	const kept = values.filter((value) => exports.includes(value));
+	return kept.length === 0 && keepFreeText && values.length > 0 ? [...values] : kept;
+}
+/**
+* A choice field's default set to `values` (option order; a dropdown's free
+* text as it is). `filtered`: what new options left of the old default,
+* where none left is an empty default rather than no default.
+*/
+function withDefault(field, values, filtered = false) {
+	if (values.length === 0) {
+		const entry = !filtered ? none() : field.family === "listbox" && field.multiSelect ? {
+			kind: "array",
+			values: []
+		} : scalar("");
+		return field.family === "combobox" ? {
+			...field,
+			defaultValueEntry: entry,
+			defaultValue: ""
+		} : {
+			...field,
+			defaultValueEntry: entry,
+			defaultValue: []
+		};
+	}
+	const matched = choiceMatches(field, values);
+	const ordered = matched ? inOptionOrder(field.options, values) : [...values];
+	const entry = matched ? choiceEntryOf(ordered) : scalar(values[0]);
+	return field.family === "combobox" ? {
+		...field,
+		defaultValueEntry: entry,
+		defaultValue: ordered[0] ?? ""
+	} : {
+		...field,
+		defaultValueEntry: entry,
+		defaultValue: ordered
+	};
+}
+function valuesOfEntry(entry) {
+	if (entry.kind === "scalar") return [entry.value];
+	if (entry.kind === "array") return [...entry.values];
+	return [];
+}
+/** A new widget's row: its placement and look, and what attaching it to the field gives it. */
+function widgetRowOfPlacement(draft, placement, at) {
+	const { page: _page, exportValue: _exportValue, ...look } = placement;
+	const row = require_calibrate.annotationOfDraft({
+		subtype: "widget",
+		...look
+	}, {
+		ref: at.ref,
+		...at.nm !== void 0 ? { nm: at.nm } : {}
+	});
+	const toggle = draft.family === "checkbox" || draft.family === "radio";
+	return {
+		...row,
+		rect: standingRectOf(row.box, row.rotation),
+		field: {
+			kind: "objectNumber",
+			objectNumber: at.field
+		},
+		fieldFamily: draft.family,
+		print: true,
+		hasAppearance: draft.family !== "signature",
+		appearanceState: toggle ? "Off" : null,
+		caption: draft.family === "pushbutton" ? placement.caption ?? null : null
+	};
+}
+function toggleWidgetOf(widget, exportValue) {
+	return {
+		...widget,
+		onState: exportValue,
+		exportValue,
+		checked: false
+	};
+}
+const optionOf = (input) => ({
+	label: input.label,
+	value: input.value,
+	selected: false
+});
+const objectNumberOf = (ref) => ref.kind === "objectNumber" ? ref.objectNumber : 0;
+const scalar = (value) => ({
+	kind: "scalar",
+	value
+});
+const none = () => ({ kind: "none" });
+function notReset(field) {
+	return new require_format.EngineError(require_format.EngineErrorCode.Unknown, `'${field.name}' could not be reset`);
+}
+//#endregion
+//#region src/forms/effects.ts
+/**
+* A script run's effects as the ops of one change, in their order: what a
+* form commit sends with `doc.apply`, all or nothing.
+*/
+function formEffectOps(effects) {
+	return effects.map((effect) => {
+		switch (effect.kind) {
+			case "setValue": return {
+				type: "forms.setValue",
+				field: effect.ref,
+				value: effect.value
+			};
+			case "setDisplay": return {
+				type: "forms.setDisplay",
+				field: effect.ref,
+				display: effect.display
+			};
+			case "setAppearanceText": return {
+				type: "forms.setAppearanceText",
+				field: effect.ref,
+				text: effect.text
+			};
+			case "reset": return {
+				type: "forms.reset",
+				fields: effect.refs
+			};
+		}
+	});
+}
+//#endregion
+//#region src/mutation/Change.ts
+/** Whether an item is an op an undo left alone entirely. */
+function isSkippedItem(item) {
+	return item.type === "skipped";
+}
+/**
+* Whether an item wrote to the document: not an op an undo left alone, nor
+* an import that left every row of its bundle out.
+*/
+function itemWrote(item) {
+	switch (item.type) {
+		case "skipped": return false;
+		case "annotations.import": return item.annotations.length > 0;
+		case "forms.import":
+		case "forms.importValues": return item.fields.length > 0;
+		default: return true;
+	}
+}
+/** Whether a change is an undo (`{ undoOf }`) rather than a list of ops. */
+function isUndoChange(change) {
+	return "undoOf" in change;
+}
+/**
+* The object numbers a change's creates name: each must be one its editing
+* session holds. An undo names none; what it restores keeps its numbers.
+*/
+function objectNumbersNamedBy(change) {
+	if (isUndoChange(change)) return [];
+	const named = [];
+	for (const op of change.ops) switch (op.type) {
+		case "annotations.create":
+			if (op.objectNumber !== void 0) named.push(op.objectNumber);
+			break;
+		case "forms.create":
+			if (op.objectNumber !== void 0) named.push(op.objectNumber);
+			named.push(...op.widgetObjectNumbers ?? []);
+			break;
+		case "forms.addWidget":
+			if (op.objectNumber !== void 0) named.push(op.objectNumber);
+			if (op.splitObjectNumber !== void 0) named.push(op.splitObjectNumber);
+			break;
+		case "outline.create":
+			if (op.objectNumber !== void 0) named.push(op.objectNumber);
+			break;
+		case "pages.insertBlank":
+			named.push(...op.objectNumbers ?? []);
+			break;
+		default: break;
+	}
+	return named;
+}
+/**
+* The object numbers a change's ops refer to: every `{ kind: 'objectNumber' }`
+* ref anywhere in them, the annotation or field an op writes and the parent
+* a reply names among them. A change that refers to a number only a refused
+* change creates can't apply. An undo refers to none: it names its change.
+*/
+function objectNumbersReferencedBy(change) {
+	if (isUndoChange(change)) return [];
+	const referenced = /* @__PURE__ */ new Set();
+	const visit = (value) => {
+		if (Array.isArray(value)) {
+			value.forEach(visit);
+			return;
+		}
+		if (value === null || typeof value !== "object" || ArrayBuffer.isView(value)) return;
+		const record = value;
+		if (record.kind === "objectNumber" && typeof record.objectNumber === "number") referenced.add(record.objectNumber);
+		for (const field of Object.values(record)) visit(field);
+	};
+	change.ops.forEach(visit);
+	return [...referenced];
+}
+/**
+* A change with bytes it owns, ready to send: each op's resources copied
+* (`resolveAnnotationResources`), a file attachment's `file` completed from
+* its `File` (`withFileFromResource`), a signature appearance copied.
+* `buffers` lists every copy, for a worker's transfer list. The caller's
+* bytes are only read.
+*/
+async function resolveChangeResources(change) {
+	if (isUndoChange(change)) return {
+		change,
+		buffers: []
+	};
+	const buffers = [];
+	const ops = [];
+	for (const op of change.ops) switch (op.type) {
+		case "annotations.create": {
+			const { resources, ...rest } = op;
+			const wire = await require_calibrate.resolveAnnotationResources(resources);
+			buffers.push(...require_calibrate.annotationResourceBuffers(wire));
+			ops.push({
+				...rest,
+				data: require_calibrate.withFileFromResource(op.data, resources),
+				...require_calibrate.hasAnnotationResources(wire) ? { resources: wire } : {}
+			});
+			break;
+		}
+		case "annotations.update": {
+			const { resources, ...rest } = op;
+			const wire = await require_calibrate.resolveAnnotationResources(resources);
+			buffers.push(...require_calibrate.annotationResourceBuffers(wire));
+			ops.push({
+				...rest,
+				...require_calibrate.hasAnnotationResources(wire) ? { resources: wire } : {}
+			});
+			break;
+		}
+		case "forms.setSignatureAppearance": {
+			const pdf = op.appearance.pdf.slice();
+			buffers.push(pdf.buffer);
+			ops.push({
+				...op,
+				appearance: { pdf }
+			});
+			break;
+		}
+		case "pages.insert": {
+			const source = op.source.slice();
+			buffers.push(source.buffer);
+			ops.push({
+				...op,
+				source
+			});
+			break;
+		}
+		case "attachments.create": {
+			const wire = await require_calibrate.resolveAnnotationResources(op.resources);
+			buffers.push(...require_calibrate.annotationResourceBuffers(wire));
+			ops.push({
+				...op,
+				resources: wire
+			});
+			break;
+		}
+		default: ops.push(op);
+	}
+	return {
+		change: { ops },
+		buffers
+	};
+}
+//#endregion
+Object.defineProperty(exports, "OUTLINE_READ_LIMITS", {
+	enumerable: true,
+	get: function() {
+		return OUTLINE_READ_LIMITS;
+	}
+});
+Object.defineProperty(exports, "assertChoiceDefault", {
+	enumerable: true,
+	get: function() {
+		return assertChoiceDefault;
+	}
+});
+Object.defineProperty(exports, "defaultEntryOfDraft", {
+	enumerable: true,
+	get: function() {
+		return defaultEntryOfDraft;
+	}
+});
+Object.defineProperty(exports, "deletedAttachmentOf", {
+	enumerable: true,
+	get: function() {
+		return deletedAttachmentOf;
+	}
+});
+Object.defineProperty(exports, "fieldAfterReset", {
+	enumerable: true,
+	get: function() {
+		return fieldAfterReset;
+	}
+});
+Object.defineProperty(exports, "fieldAfterValue", {
+	enumerable: true,
+	get: function() {
+		return fieldAfterValue;
+	}
+});
+Object.defineProperty(exports, "fieldValueWriteOf", {
+	enumerable: true,
+	get: function() {
+		return fieldValueWriteOf;
+	}
+});
+Object.defineProperty(exports, "fitWidgetToFamily", {
+	enumerable: true,
+	get: function() {
+		return fitWidgetToFamily;
+	}
+});
+Object.defineProperty(exports, "formEffectOps", {
+	enumerable: true,
+	get: function() {
+		return formEffectOps;
+	}
+});
+Object.defineProperty(exports, "formFieldAfter", {
+	enumerable: true,
+	get: function() {
+		return formFieldAfter;
+	}
+});
+Object.defineProperty(exports, "formFieldOfDraft", {
+	enumerable: true,
+	get: function() {
+		return formFieldOfDraft;
+	}
+});
+Object.defineProperty(exports, "isAtDefault", {
+	enumerable: true,
+	get: function() {
+		return isAtDefault;
+	}
+});
+Object.defineProperty(exports, "isNoOpWrite", {
+	enumerable: true,
+	get: function() {
+		return isNoOpWrite;
+	}
+});
+Object.defineProperty(exports, "isSkippedItem", {
+	enumerable: true,
+	get: function() {
+		return isSkippedItem;
+	}
+});
+Object.defineProperty(exports, "isUndoChange", {
+	enumerable: true,
+	get: function() {
+		return isUndoChange;
+	}
+});
+Object.defineProperty(exports, "itemWrote", {
+	enumerable: true,
+	get: function() {
+		return itemWrote;
+	}
+});
+Object.defineProperty(exports, "objectNumbersNamedBy", {
+	enumerable: true,
+	get: function() {
+		return objectNumbersNamedBy;
+	}
+});
+Object.defineProperty(exports, "objectNumbersReferencedBy", {
+	enumerable: true,
+	get: function() {
+		return objectNumbersReferencedBy;
+	}
+});
+Object.defineProperty(exports, "outlineItemAfter", {
+	enumerable: true,
+	get: function() {
+		return outlineItemAfter;
+	}
+});
+Object.defineProperty(exports, "outlineItemOfDraft", {
+	enumerable: true,
+	get: function() {
+		return outlineItemOfDraft;
+	}
+});
+Object.defineProperty(exports, "outlineItemWithChildren", {
+	enumerable: true,
+	get: function() {
+		return outlineItemWithChildren;
+	}
+});
+Object.defineProperty(exports, "resolveChangeResources", {
+	enumerable: true,
+	get: function() {
+		return resolveChangeResources;
+	}
+});
+Object.defineProperty(exports, "topRowOf", {
+	enumerable: true,
+	get: function() {
+		return topRowOf;
+	}
+});
+Object.defineProperty(exports, "valueEntriesEqual", {
+	enumerable: true,
+	get: function() {
+		return valueEntriesEqual;
+	}
+});
+Object.defineProperty(exports, "widgetAfterPatch", {
+	enumerable: true,
+	get: function() {
+		return widgetAfterPatch;
+	}
+});
+Object.defineProperty(exports, "widgetsAfterDisplay", {
+	enumerable: true,
+	get: function() {
+		return widgetsAfterDisplay;
+	}
+});
+
+//# sourceMappingURL=Change-Ct-dB8D5.cjs.map