@embedpdf/engine-core 3.0.0-next.13 → 3.0.0-next.15

package/dist/Change-CKoxfTNY.js

@@ -0,0 +1,889 @@
+import { a as formWidget, h as EngineError, y as EngineErrorCode } from "./format-Dgg428Kb.js";
+import { dt as hasAnnotationResources, f as applyAnnotationPatch, ft as resolveAnnotationResources, lt as annotationResourceBuffers, pt as withFileFromResource, u as annotationOfDraft } from "./calibrate-7T3fnP8-.js";
+//#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 EngineError(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 EngineError(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 EngineError(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 = 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) => 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 = 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 EngineError(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;
+		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 resolveAnnotationResources(resources);
+			buffers.push(...annotationResourceBuffers(wire));
+			ops.push({
+				...rest,
+				data: withFileFromResource(op.data, resources),
+				...hasAnnotationResources(wire) ? { resources: wire } : {}
+			});
+			break;
+		}
+		case "annotations.update": {
+			const { resources, ...rest } = op;
+			const wire = await resolveAnnotationResources(resources);
+			buffers.push(...annotationResourceBuffers(wire));
+			ops.push({
+				...rest,
+				...hasAnnotationResources(wire) ? { resources: wire } : {}
+			});
+			break;
+		}
+		case "forms.setSignatureAppearance": {
+			const pdf = op.appearance.pdf.slice();
+			buffers.push(pdf.buffer);
+			ops.push({
+				...op,
+				appearance: { pdf }
+			});
+			break;
+		}
+		default: ops.push(op);
+	}
+	return {
+		change: { ops },
+		buffers
+	};
+}
+//#endregion
+export { deletedAttachmentOf as S, assertChoiceDefault as _, objectNumbersReferencedBy as a, isNoOpWrite as b, defaultEntryOfDraft as c, formFieldAfter as d, formFieldOfDraft as f, widgetAfterPatch as g, fitWidgetToFamily as h, objectNumbersNamedBy as i, fieldAfterReset as l, widgetsAfterDisplay as m, isUndoChange as n, resolveChangeResources as o, topRowOf as p, itemWrote as r, formEffectOps as s, isSkippedItem as t, fieldAfterValue as u, fieldValueWriteOf as v, valueEntriesEqual as x, isAtDefault as y };
+
+//# sourceMappingURL=Change-CKoxfTNY.js.map