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

package/dist/viewport-BJW13EGZ.js

@@ -0,0 +1,540 @@
+import { G as assertRowResources, H as assertKnownFields, J as isBundlePageRef, U as assertResourceIds, V as assertBundlePages, W as assertResourcesNamed, Y as isRecord, q as invalidBundle } from "./resolveAnnotationDraft-CUpf0SMh.js";
+import { h as EngineError, u as encodePageKey, v as _defineProperty, y as EngineErrorCode } from "./format-Dgg428Kb.js";
+import { at as DEFAULT_BUNDLE_LIMITS, c as foldText, gt as AbortError, it as bundleCodec, l as toOriginalRange, ot as assertWithinLimit, st as manifestBytesOf } from "./calibrate-7T3fnP8-.js";
+//#region src/promise/AbortablePromise.ts
+let _Symbol$species;
+_Symbol$species = Symbol.species;
+/**
+* Awaitable Promise subclass with abort and progress.
+*
+* Symbol.species returns plain Promise so chained .then/.catch/.finally
+* return regular promises and never try to synthesize a new
+* AbortablePromise (which would have no executor).
+*
+* Settlement contract:
+*   - The first settlement wins. resolve/reject handed to the executor
+*     are wrapped so that any subsequent call (whether by the executor,
+*     by abort(), or by both racing) becomes a silent no-op.
+*   - abort() rejects the public promise with AbortError immediately,
+*     even if the executor never observes the AbortSignal. The executor
+*     still receives the AbortSignal so it can stop real work
+*     cooperatively (release a queue slot, abort fetch, post a worker
+*     abort, etc.). Anything the executor does after that — including
+*     a late resolve(value), a late reject(error), or a rejected inner
+*     Promise inside AbortablePromise.run — is dropped silently.
+*   - abort() after settlement is a no-op.
+*/
+var AbortablePromise = class AbortablePromise extends Promise {
+	static get [_Symbol$species]() {
+		return Promise;
+	}
+	constructor(executor) {
+		const ctrl = new AbortController();
+		const progressCbs = /* @__PURE__ */ new Set();
+		const state = { settled: false };
+		let capturedReject;
+		super((resolve, reject) => {
+			capturedReject = reject;
+			const wrappedResolve = (value) => {
+				if (state.settled) return;
+				state.settled = true;
+				resolve(value);
+			};
+			const wrappedReject = (reason) => {
+				if (state.settled) return;
+				state.settled = true;
+				reject(reason);
+			};
+			const progress = (p) => {
+				if (state.settled) return;
+				for (const cb of progressCbs) try {
+					cb(p);
+				} catch {}
+			};
+			executor(wrappedResolve, wrappedReject, progress, ctrl.signal);
+		});
+		_defineProperty(this, "signal", void 0);
+		_defineProperty(this, "_ctrl", void 0);
+		_defineProperty(this, "_progressCbs", void 0);
+		_defineProperty(this, "_state", void 0);
+		_defineProperty(this, "_internalReject", void 0);
+		this._ctrl = ctrl;
+		this.signal = ctrl.signal;
+		this._progressCbs = progressCbs;
+		this._state = state;
+		this._internalReject = capturedReject;
+	}
+	/**
+	* Abort the underlying operation.
+	*
+	* - If the promise has already settled, this is a no-op.
+	* - Otherwise the public promise rejects synchronously with an
+	*   AbortError (wrapping the supplied reason if it is not already an
+	*   AbortError) and the AbortSignal fires for any cooperative
+	*   cancellation the executor wired up.
+	*/
+	abort(reason) {
+		if (this._state.settled) return;
+		if (this._ctrl.signal.aborted) return;
+		const err = reason instanceof AbortError ? reason : new AbortError(reason);
+		this._state.settled = true;
+		this._ctrl.abort(err);
+		this._internalReject(err);
+	}
+	/**
+	* Abort this call when `signal` aborts, at once if it already has: the
+	* bridge to code that cancels with an `AbortController` (a framework's
+	* cleanup, a `fetch`). The listener is removed when the call settles.
+	* Returns this promise, so `await call().abortWith(signal)` reads as one.
+	*/
+	abortWith(signal) {
+		if (signal.aborted) {
+			this.abort(signal.reason);
+			return this;
+		}
+		const onAbort = () => this.abort(signal.reason);
+		signal.addEventListener("abort", onAbort, { once: true });
+		const detach = () => signal.removeEventListener("abort", onAbort);
+		Promise.prototype.then.call(this, detach, detach);
+		return this;
+	}
+	/**
+	* Subscribe to progress events. Returns an unsubscribe function.
+	*
+	* @internal No engine method reports progress today; this is plumbing for
+	* one that will, typed then per method. Not part of the public contract.
+	*/
+	onProgress(cb) {
+		this._progressCbs.add(cb);
+		return () => {
+			this._progressCbs.delete(cb);
+		};
+	}
+	/**
+	* Wrap a value in an already-resolved AbortablePromise. Mirrors Promise.resolve.
+	*/
+	static resolveValue(value) {
+		return new AbortablePromise((resolve) => resolve(value));
+	}
+	/**
+	* Wrap a thrown reason in an already-rejected AbortablePromise.
+	*/
+	static rejectReason(reason) {
+		return new AbortablePromise((_resolve, reject) => reject(reason));
+	}
+	/**
+	* Run an async function as an AbortablePromise so callers get .abort() and .signal.
+	* The async function receives the AbortSignal (and a progress emitter) so it can
+	* cooperate with the abort.
+	*
+	* If abort() fires while the inner async function is still running, the
+	* public promise rejects with AbortError immediately. The inner async
+	* function's eventual settlement (resolve or reject) is funneled through
+	* the wrapped settlers and silently dropped — including a late rejection
+	* from the underlying work, which prevents an UnhandledRejection because
+	* the .then(resolve, reject) below "handles" it via the no-op.
+	*/
+	static run(fn) {
+		return new AbortablePromise((resolve, reject, progress, signal) => {
+			fn(signal, progress).then(resolve, reject);
+		});
+	}
+};
+//#endregion
+//#region src/identity/ObjectNumbers.ts
+/**
+* The highest object number a document should reach: Acrobat documents
+* 8,388,607 objects per file, and the interoperable rule keeps every object
+* number at or below it. A write that would pass it is refused with
+* `LayerFull`.
+*/
+const OBJECT_NUMBER_CEILING = 8388607;
+/**
+* The last object number handed out to sessions: issuing stops here, which
+* leaves the numbers above it to the objects the engine makes for itself
+* (appearance streams, fonts) until the ceiling.
+*/
+const OBJECT_NUMBER_ISSUE_LIMIT = 8e6;
+/**
+* Runs of numbers as an HTTP header value, inclusive like an HTTP `Range`:
+* `1003-1035, 2040-2042` (`EmbedPDF-Object-Numbers`).
+*/
+function formatObjectNumberRanges(ranges) {
+	return ranges.map(({ first, count }) => `${first}-${first + count - 1}`).join(", ");
+}
+/** The runs a {@link formatObjectNumberRanges} header value names; `[]` for one that names none. */
+function parseObjectNumberRanges(value) {
+	const ranges = [];
+	for (const part of (value ?? "").split(",")) {
+		const match = /^\s*(\d+)-(\d+)\s*$/.exec(part);
+		if (!match) continue;
+		const first = Number(match[1]);
+		const last = Number(match[2]);
+		if (last >= first) ranges.push({
+			first,
+			count: last - first + 1
+		});
+	}
+	return ranges;
+}
+/** Every number in `ranges`, in order. */
+function objectNumbersIn(ranges) {
+	const numbers = [];
+	for (const { first, count } of ranges) for (let i = 0; i < count; i++) numbers.push(first + i);
+	return numbers;
+}
+/** The manifest's keys, in the order a file writes them. */
+const FORM_BUNDLE_KEYS = [
+	"format",
+	"version",
+	"pages",
+	"fields",
+	"widgets",
+	"calculationOrder"
+];
+/** The resource roles a widget names: none yet. */
+const WIDGET_RESOURCE_ROLES = [];
+const BUNDLE_FIELDS = [...FORM_BUNDLE_KEYS, "resources"];
+const FIELD_ROW_FIELDS = ["data"];
+const WIDGET_ROW_FIELDS = ["data", "resources"];
+/**
+* Check a bundle before anything uses it, the checks cheapest first: its
+* format, its counts and sizes against `limits` (`PayloadTooLarge`), its
+* shape and references (`InvalidArg`), then every resource against its id.
+*/
+async function assertFormBundle(bundle, limits = DEFAULT_BUNDLE_LIMITS) {
+	const resources = isRecord(bundle?.resources) ? bundle.resources : invalidBundle("form", "no resources");
+	const sizes = /* @__PURE__ */ new Map();
+	for (const [id, bytes] of Object.entries(resources)) {
+		if (!(bytes instanceof Uint8Array)) invalidBundle("form", `resource ${id} is not bytes`);
+		sizes.set(id, bytes.length);
+	}
+	assertFormBundleManifest(bundle, sizes, limits);
+	await assertResourceIds("form", resources);
+}
+/**
+* The checks that need no resource bytes, only their sizes by id: format
+* and version, counts, sizes, the shape of pages, fields and widgets, and
+* that widgets and resources name each other exactly. That a widget's field
+* is among the bundle's is the import's to decide: one that isn't is left
+* out.
+*/
+function assertFormBundleManifest(manifest, resourceSizes, limits) {
+	if (!isRecord(manifest)) invalidBundle("form", "not a form bundle");
+	assertKnownFields("form", "the bundle", manifest, BUNDLE_FIELDS);
+	if (manifest.format !== "embedpdf/form") invalidBundle("form", `unknown format ${JSON.stringify(manifest.format)}`);
+	if (manifest.version !== 1) invalidBundle("form", `unknown version ${JSON.stringify(manifest.version)}`);
+	const { pages, fields, widgets, calculationOrder } = manifest;
+	if (!Array.isArray(pages)) invalidBundle("form", "pages is not a list");
+	if (!Array.isArray(fields)) invalidBundle("form", "fields is not a list");
+	if (!Array.isArray(widgets)) invalidBundle("form", "widgets is not a list");
+	if (!Array.isArray(calculationOrder)) invalidBundle("form", "calculationOrder is not a list");
+	assertWithinLimit("form", limits, "items", fields.length + widgets.length);
+	assertWithinLimit("form", limits, "pages", pages.length);
+	assertWithinLimit("form", limits, "resources", resourceSizes.size);
+	let bundleBytes = manifestBytesOf({
+		pages,
+		fields,
+		widgets,
+		calculationOrder
+	});
+	assertWithinLimit("form", limits, "manifestBytes", bundleBytes);
+	for (const size of resourceSizes.values()) {
+		assertWithinLimit("form", limits, "resourceBytes", size);
+		bundleBytes += size;
+	}
+	assertWithinLimit("form", limits, "bundleBytes", bundleBytes);
+	const pageKeys = assertBundlePages("form", pages);
+	fields.forEach((row, index) => {
+		if (!isRecord(row) || !isRecord(row.data) || typeof row.data.family !== "string" || typeof row.data.name !== "string" || !isRecord(row.data.ref)) invalidBundle("form", `field ${index} has no field data`);
+		assertKnownFields("form", `field ${index}`, row, FIELD_ROW_FIELDS);
+	});
+	const named = /* @__PURE__ */ new Set();
+	widgets.forEach((row, index) => {
+		if (!isRecord(row) || !isRecord(row.data) || row.data.subtype !== "widget") invalidBundle("form", `widget ${index} has no widget data`);
+		assertKnownFields("form", `widget ${index}`, row, WIDGET_ROW_FIELDS);
+		const ref = row.data.ref;
+		const page = isRecord(ref) ? ref.page : void 0;
+		if (!isBundlePageRef(page) || !pageKeys.has(encodePageKey(page))) invalidBundle("form", `widget ${index} is on a page the bundle doesn't list`);
+		assertRowResources("form", `widget ${index}`, row.resources, WIDGET_RESOURCE_ROLES, resourceSizes, named);
+	});
+	calculationOrder.forEach((ref, index) => {
+		if (!isRecord(ref)) invalidBundle("form", `calculation order entry ${index} is not a field ref`);
+	});
+	assertResourcesNamed("form", "widget", resourceSizes, named);
+}
+//#endregion
+//#region src/transfer/FormTransfer.ts
+/**
+* A form bundle as one JSON file, each resource in base64: a bundle whole,
+* to store or download. HTTP carries bundles as multipart instead, without
+* the third base64 adds.
+*/
+const FormTransfer = bundleCodec({
+	kind: "form",
+	keys: FORM_BUNDLE_KEYS,
+	assertManifest: assertFormBundleManifest
+});
+//#endregion
+//#region src/search/literal.ts
+/**
+* The fold flavor a literal query needs. Haystack and needle must be
+* folded with the same options; corpus caches key their pre-folded text
+* on this (the default `{}` fold is the persistable one — non-default
+* queries fold the original page text at query time).
+*/
+function foldOptionsFor(query) {
+	return {
+		keepCase: !!query.matchCase,
+		keepMarks: !!query.matchDiacritics,
+		dropWhitespace: !!query.ignoreWhitespace
+	};
+}
+const WORD_UNIT = /[\p{L}\p{N}_]/u;
+const MARK = /\p{M}/u;
+/** Whether the code point ending at `index` (exclusive) is a word char. */
+function wordBefore(text, index) {
+	if (index <= 0) return false;
+	const unit = text.charCodeAt(index - 1);
+	const start = unit >= 56320 && unit <= 57343 && index >= 2 ? index - 2 : index - 1;
+	return WORD_UNIT.test(String.fromCodePoint(text.codePointAt(start)));
+}
+/** Whether the code point starting at `index` is a word char. */
+function wordAt(text, index) {
+	if (index >= text.length) return false;
+	return WORD_UNIT.test(String.fromCodePoint(text.codePointAt(index)));
+}
+/**
+* Whether the folded hit at `at` sits on word boundaries. Checked on the
+* folded plane, except under `ignoreWhitespace`: dropping whitespace glues
+* neighbouring words together ("i n v o i c e 42" folds to "invoice42"), so there the
+* boundaries are read off the original text around the mapped range.
+*/
+function isWholeWordHit(haystack, at, needleLength, query) {
+	if (!query.ignoreWhitespace) return !wordBefore(haystack.folded, at) && !wordAt(haystack.folded, at + needleLength);
+	const { start, count } = toOriginalRange(haystack, at, needleLength);
+	return !wordBefore(haystack.original, start) && !wordAt(haystack.original, start + count);
+}
+/**
+* All non-overlapping literal matches, in original code-unit space.
+* `haystack` must have been folded with `foldOptionsFor(query)`.
+*/
+function matchLiteral(haystack, query) {
+	const needle = foldText(query.text, foldOptionsFor(query)).folded;
+	if (needle.trim().length === 0) return [];
+	const out = [];
+	let from = 0;
+	while (from <= haystack.folded.length - needle.length) {
+		const at = haystack.folded.indexOf(needle, from);
+		if (at < 0) break;
+		if (query.wholeWord && !isWholeWordHit(haystack, at, needle.length, query)) {
+			from = at + 1;
+			continue;
+		}
+		if (query.matchDiacritics && at + needle.length < haystack.folded.length) {
+			const after = haystack.folded.codePointAt(at + needle.length);
+			if (MARK.test(String.fromCodePoint(after))) {
+				from = at + 1;
+				continue;
+			}
+		}
+		out.push(toOriginalRange(haystack, at, needle.length));
+		from = at + needle.length;
+	}
+	return out;
+}
+//#endregion
+//#region src/search/regex.ts
+/**
+* The portable search-regex dialect: JavaScript `u`-mode syntax minus the
+* features RE2 refuses (backreferences, lookaround). The local engine
+* executes patterns with JS `RegExp`; the server executes the same
+* pattern with RE2, whose linear-time guarantee is the ReDoS defense.
+* Restricting both sides to the common subset keeps one query string
+* valid — and equally powerful — everywhere.
+*/
+const SEARCH_REGEX_MAX_LENGTH = 512;
+/**
+* Validate a pattern against the dialect. Cheap and dependency-free —
+* viewers call it on keystroke for early feedback; engines re-validate
+* and reject bad patterns with `InvalidArg`.
+*/
+function validateSearchRegex(pattern) {
+	if (pattern.length === 0) return {
+		ok: false,
+		issue: "empty",
+		message: "Pattern is empty."
+	};
+	if (pattern.length > 512) return {
+		ok: false,
+		issue: "too-long",
+		message: `Pattern exceeds 512 characters.`
+	};
+	let inClass = false;
+	for (let i = 0; i < pattern.length; i++) {
+		const ch = pattern[i];
+		if (ch === "\\") {
+			const next = pattern[i + 1] ?? "";
+			if (!inClass && next >= "1" && next <= "9") return {
+				ok: false,
+				issue: "backreference",
+				message: `Backreference \\${next} is not supported.`
+			};
+			if (!inClass && next === "k" && pattern[i + 2] === "<") return {
+				ok: false,
+				issue: "backreference",
+				message: "Named backreferences (\\k<…>) are not supported."
+			};
+			i++;
+			continue;
+		}
+		if (inClass) {
+			if (ch === "]") inClass = false;
+			continue;
+		}
+		if (ch === "[") {
+			inClass = true;
+			continue;
+		}
+		if (ch === "(" && pattern[i + 1] === "?") {
+			const tag = pattern[i + 2] ?? "";
+			if (tag === "=" || tag === "!") return {
+				ok: false,
+				issue: "lookaround",
+				message: "Lookahead ((?=…), (?!…)) is not supported."
+			};
+			if (tag === "<" && (pattern[i + 3] === "=" || pattern[i + 3] === "!")) return {
+				ok: false,
+				issue: "lookaround",
+				message: "Lookbehind ((?<=…), (?<!…)) is not supported."
+			};
+		}
+	}
+	try {
+		new RegExp(pattern, "mu");
+	} catch (error) {
+		return {
+			ok: false,
+			issue: "syntax",
+			message: error.message
+		};
+	}
+	return { ok: true };
+}
+function validateSearchQuery(query) {
+	if (!query.regex) return { ok: true };
+	if (query.matchDiacritics) return {
+		ok: false,
+		issue: "diacritics-with-regex",
+		message: "Diacritic-sensitive matching is not available for regex patterns (regex runs on the raw text plane)."
+	};
+	if (query.ignoreWhitespace) return {
+		ok: false,
+		issue: "ignore-whitespace-with-regex",
+		message: "Whitespace-insensitive matching is not available for regex patterns (regex runs on the raw text plane; use \\s* in the pattern)."
+	};
+	return validateSearchRegex(query.text);
+}
+/**
+* All matches of a dialect-valid pattern over the raw page text (regex
+* does not run against folded text — case handling is the `i` flag, and
+* diacritic folding never applies). `wholeWord` is a boundary POST-filter
+* using the same Unicode word test as the literal path — never `\b`,
+* whose ASCII word set would give the toggle different semantics in regex
+* mode ("caf" whole-word matching inside "café"). Filtering after the
+* match also survives the move to RE2 server-side. Zero-length matches
+* are skipped: search UI cannot highlight nothing, and skipping them is
+* also the infinite-loop guard for patterns like `a*`.
+*/
+function matchRegex(text, query) {
+	const valid = validateSearchQuery({
+		...query,
+		regex: true
+	});
+	if (!valid.ok) throw new Error(`Invalid search query (${valid.issue}): ${valid.message}`);
+	const re = new RegExp(query.text, query.matchCase ? "gmu" : "gimu");
+	const out = [];
+	let m;
+	while ((m = re.exec(text)) !== null) {
+		if (m[0].length === 0) {
+			const unit = text.charCodeAt(re.lastIndex);
+			re.lastIndex += unit >= 55296 && unit <= 56319 ? 2 : 1;
+			continue;
+		}
+		if (query.wholeWord && (wordBefore(text, m.index) || wordAt(text, m.index + m[0].length))) continue;
+		out.push({
+			start: m.index,
+			count: m[0].length
+		});
+	}
+	return out;
+}
+//#endregion
+//#region src/mutation/ListPosition.ts
+/** The neighbour a position names, or `null` for `'start'` and `'end'`. */
+function anchorOf(position) {
+	if (position === "start" || position === "end") return null;
+	return "before" in position ? position.before : position.after;
+}
+/**
+* Where `position` falls in `order`: the index the first row placed there
+* gets. The neighbour must be in `order` (`NotFound` otherwise).
+*/
+function positionIndex(order, position, keyOf) {
+	if (position === "start") return 0;
+	if (position === "end") return order.length;
+	const anchor = anchorOf(position);
+	const at = order.findIndex((ref) => keyOf(ref) === keyOf(anchor));
+	if (at < 0) throw new EngineError(EngineErrorCode.NotFound, `no neighbour ${keyOf(anchor)} in the list`, { details: { field: "position" } });
+	return "before" in position ? at : at + 1;
+}
+/**
+* A list's order once `moved` go to `position`, together and in the order
+* given: what a reorder answers, worked out as the engine does. Every moved
+* row must be in `order`, once (`InvalidArg` otherwise), and the neighbour
+* can't be one of them (`InvalidArg`).
+*/
+function reorderedList(order, moved, position, keyOf) {
+	const movedKeys = new Set(moved.map(keyOf));
+	if (movedKeys.size !== moved.length) throw new EngineError(EngineErrorCode.InvalidArg, "a row is named twice", { details: { field: "refs" } });
+	const present = new Set(order.map(keyOf));
+	const missing = moved.find((ref) => !present.has(keyOf(ref)));
+	if (missing !== void 0) throw new EngineError(EngineErrorCode.NotFound, `no row ${keyOf(missing)} in the list`, { details: { field: "refs" } });
+	const anchor = anchorOf(position);
+	if (anchor !== null && movedKeys.has(keyOf(anchor))) throw new EngineError(EngineErrorCode.InvalidArg, `the neighbour ${keyOf(anchor)} is one of the rows that move`, { details: { field: "position" } });
+	const staying = order.filter((ref) => !movedKeys.has(keyOf(ref)));
+	const at = positionIndex(staying, position, keyOf);
+	return [
+		...staying.slice(0, at),
+		...moved,
+		...staying.slice(at)
+	];
+}
+/**
+* `list` with the items `inPart` picks put in the order `order` gives them,
+* by key, in the slots those items have: every other item keeps its place.
+* How a list holding several pages takes one page's new order. Items of the
+* part `order` doesn't name follow the named ones, in their order.
+*/
+function reorderPart(list, inPart, order, keyOf) {
+	const part = list.filter(inPart);
+	const byKey = new Map(part.map((item) => [keyOf(item), item]));
+	const named = order.flatMap((key) => byKey.has(key) ? [byKey.get(key)] : []);
+	const placed = new Set(named);
+	const next = [...named, ...part.filter((item) => !placed.has(item))];
+	let slot = 0;
+	return list.map((item) => inPart(item) ? next[slot++] : item);
+}
+//#endregion
+//#region src/measure/viewport.ts
+/**
+* The last viewport whose box holds `point` (the one drawn on top), or
+* `undefined`. A foreign measure still wins; never guess a fallback.
+*/
+function viewportForPoint(viewports, point) {
+	return [...viewports].reverse().find(({ bbox: b }) => point.x >= b.x && point.x <= b.x + b.width && point.y >= b.y && point.y <= b.y + b.height);
+}
+//#endregion
+export { AbortablePromise as S, OBJECT_NUMBER_CEILING as _, reorderedList as a, objectNumbersIn as b, validateSearchQuery as c, matchLiteral as d, wordAt as f, assertFormBundleManifest as g, assertFormBundle as h, reorderPart as i, validateSearchRegex as l, FormTransfer as m, anchorOf as n, SEARCH_REGEX_MAX_LENGTH as o, wordBefore as p, positionIndex as r, matchRegex as s, viewportForPoint as t, foldOptionsFor as u, OBJECT_NUMBER_ISSUE_LIMIT as v, parseObjectNumberRanges as x, formatObjectNumberRanges as y };
+
+//# sourceMappingURL=viewport-BJW13EGZ.js.map

package/dist/viewport-BJW13EGZ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"viewport-BJW13EGZ.js","names":[],"sources":["../src/promise/AbortablePromise.ts","../src/identity/ObjectNumbers.ts","../src/transfer/FormBundle.ts","../src/transfer/FormTransfer.ts","../src/search/literal.ts","../src/search/regex.ts","../src/mutation/ListPosition.ts","../src/measure/viewport.ts"],"sourcesContent":["import { AbortError } from './AbortError';\n\nexport type AbortableExecutor<T, P> = (\n  resolve: (value: T | PromiseLike<T>) => void,\n  reject: (reason: unknown) => void,\n  progress: (p: P) => void,\n  signal: AbortSignal,\n) => void;\n\n/**\n * Awaitable Promise subclass with abort and progress.\n *\n * Symbol.species returns plain Promise so chained .then/.catch/.finally\n * return regular promises and never try to synthesize a new\n * AbortablePromise (which would have no executor).\n *\n * Settlement contract:\n *   - The first settlement wins. resolve/reject handed to the executor\n *     are wrapped so that any subsequent call (whether by the executor,\n *     by abort(), or by both racing) becomes a silent no-op.\n *   - abort() rejects the public promise with AbortError immediately,\n *     even if the executor never observes the AbortSignal. The executor\n *     still receives the AbortSignal so it can stop real work\n *     cooperatively (release a queue slot, abort fetch, post a worker\n *     abort, etc.). Anything the executor does after that — including\n *     a late resolve(value), a late reject(error), or a rejected inner\n *     Promise inside AbortablePromise.run — is dropped silently.\n *   - abort() after settlement is a no-op.\n */\nexport class AbortablePromise<T, P = never> extends Promise<T> {\n  static override get [Symbol.species](): PromiseConstructor {\n    return Promise;\n  }\n\n  readonly signal: AbortSignal;\n\n  private readonly _ctrl: AbortController;\n  private readonly _progressCbs: Set<(p: P) => void>;\n  private readonly _state: { settled: boolean };\n  private readonly _internalReject: (reason: unknown) => void;\n\n  constructor(executor: AbortableExecutor<T, P>) {\n    const ctrl = new AbortController();\n    const progressCbs = new Set<(p: P) => void>();\n    const state = { settled: false };\n    let capturedReject!: (reason: unknown) => void;\n\n    super((resolve, reject) => {\n      capturedReject = reject;\n\n      const wrappedResolve = (value: T | PromiseLike<T>) => {\n        if (state.settled) return;\n        state.settled = true;\n        resolve(value);\n      };\n      const wrappedReject = (reason: unknown) => {\n        if (state.settled) return;\n        state.settled = true;\n        reject(reason);\n      };\n      const progress = (p: P) => {\n        if (state.settled) return;\n        for (const cb of progressCbs) {\n          try {\n            cb(p);\n          } catch {\n            // ignore subscriber errors\n          }\n        }\n      };\n\n      executor(wrappedResolve, wrappedReject, progress, ctrl.signal);\n    });\n\n    this._ctrl = ctrl;\n    this.signal = ctrl.signal;\n    this._progressCbs = progressCbs;\n    this._state = state;\n    this._internalReject = capturedReject;\n  }\n\n  /**\n   * Abort the underlying operation.\n   *\n   * - If the promise has already settled, this is a no-op.\n   * - Otherwise the public promise rejects synchronously with an\n   *   AbortError (wrapping the supplied reason if it is not already an\n   *   AbortError) and the AbortSignal fires for any cooperative\n   *   cancellation the executor wired up.\n   */\n  abort(reason?: unknown): void {\n    if (this._state.settled) return;\n    if (this._ctrl.signal.aborted) return;\n\n    const err = reason instanceof AbortError ? reason : new AbortError(reason);\n\n    // Mark settled before signalling so any abort listener the executor\n    // attached cannot race a late resolve/reject through the wrapped\n    // settlers (they all consult state.settled).\n    this._state.settled = true;\n    this._ctrl.abort(err);\n    this._internalReject(err);\n  }\n\n  /**\n   * Abort this call when `signal` aborts, at once if it already has: the\n   * bridge to code that cancels with an `AbortController` (a framework's\n   * cleanup, a `fetch`). The listener is removed when the call settles.\n   * Returns this promise, so `await call().abortWith(signal)` reads as one.\n   */\n  abortWith(signal: AbortSignal): this {\n    if (signal.aborted) {\n      this.abort(signal.reason);\n      return this;\n    }\n    const onAbort = () => this.abort(signal.reason);\n    signal.addEventListener('abort', onAbort, { once: true });\n    const detach = () => signal.removeEventListener('abort', onAbort);\n    Promise.prototype.then.call(this, detach, detach);\n    return this;\n  }\n\n  /**\n   * Subscribe to progress events. Returns an unsubscribe function.\n   *\n   * @internal No engine method reports progress today; this is plumbing for\n   * one that will, typed then per method. Not part of the public contract.\n   */\n  onProgress(cb: (p: P) => void): () => void {\n    this._progressCbs.add(cb);\n    return () => {\n      this._progressCbs.delete(cb);\n    };\n  }\n\n  /**\n   * Wrap a value in an already-resolved AbortablePromise. Mirrors Promise.resolve.\n   */\n  static resolveValue<T>(value: T | PromiseLike<T>): AbortablePromise<T> {\n    return new AbortablePromise<T>((resolve) => resolve(value));\n  }\n\n  /**\n   * Wrap a thrown reason in an already-rejected AbortablePromise.\n   */\n  static rejectReason<T = never>(reason: unknown): AbortablePromise<T> {\n    return new AbortablePromise<T>((_resolve, reject) => reject(reason));\n  }\n\n  /**\n   * Run an async function as an AbortablePromise so callers get .abort() and .signal.\n   * The async function receives the AbortSignal (and a progress emitter) so it can\n   * cooperate with the abort.\n   *\n   * If abort() fires while the inner async function is still running, the\n   * public promise rejects with AbortError immediately. The inner async\n   * function's eventual settlement (resolve or reject) is funneled through\n   * the wrapped settlers and silently dropped — including a late rejection\n   * from the underlying work, which prevents an UnhandledRejection because\n   * the .then(resolve, reject) below \"handles\" it via the no-op.\n   */\n  static run<T, P = never>(\n    fn: (signal: AbortSignal, progress: (p: P) => void) => Promise<T>,\n  ): AbortablePromise<T, P> {\n    return new AbortablePromise<T, P>((resolve, reject, progress, signal) => {\n      fn(signal, progress).then(resolve, reject);\n    });\n  }\n}\n","import type { AbortablePromise } from '../promise/AbortablePromise';\n\n/**\n * The highest object number a document should reach: Acrobat documents\n * 8,388,607 objects per file, and the interoperable rule keeps every object\n * number at or below it. A write that would pass it is refused with\n * `LayerFull`.\n */\nexport const OBJECT_NUMBER_CEILING = 8_388_607;\n\n/**\n * The last object number handed out to sessions: issuing stops here, which\n * leaves the numbers above it to the objects the engine makes for itself\n * (appearance streams, fonts) until the ceiling.\n */\nexport const OBJECT_NUMBER_ISSUE_LIMIT = 8_000_000;\n\n/** `count` consecutive object numbers starting at `first`. */\nexport interface ObjectNumberRange {\n  readonly first: number;\n  readonly count: number;\n}\n\n/**\n * Runs of numbers as an HTTP header value, inclusive like an HTTP `Range`:\n * `1003-1035, 2040-2042` (`EmbedPDF-Object-Numbers`).\n */\nexport function formatObjectNumberRanges(ranges: readonly ObjectNumberRange[]): string {\n  return ranges.map(({ first, count }) => `${first}-${first + count - 1}`).join(', ');\n}\n\n/** The runs a {@link formatObjectNumberRanges} header value names; `[]` for one that names none. */\nexport function parseObjectNumberRanges(value: string | null | undefined): ObjectNumberRange[] {\n  const ranges: ObjectNumberRange[] = [];\n  for (const part of (value ?? '').split(',')) {\n    const match = /^\\s*(\\d+)-(\\d+)\\s*$/.exec(part);\n    if (!match) continue;\n    const first = Number(match[1]);\n    const last = Number(match[2]);\n    if (last >= first) ranges.push({ first, count: last - first + 1 });\n  }\n  return ranges;\n}\n\n/** Every number in `ranges`, in order. */\nexport function objectNumbersIn(ranges: readonly ObjectNumberRange[]): number[] {\n  const numbers: number[] = [];\n  for (const { first, count } of ranges) {\n    for (let i = 0; i < count; i++) numbers.push(first + i);\n  }\n  return numbers;\n}\n\n/**\n * A cloud editing session, as `/access` tells a client that may create:\n * `'new'`, `'revived'` (it had expired, and its numbers came back with it\n * unless another session took them) or `'live'`; the seconds until it\n * expires without a sign of life; and the numbers handed out now.\n */\nexport interface EditSessionAccess {\n  readonly session: 'new' | 'revived' | 'live';\n  readonly expiresIn: number;\n  readonly objectNumbers: readonly ObjectNumberRange[];\n}\n\n/**\n * The event stream's `session` event: every number the editing session\n * holds now, and the seconds until it expires without a sign of life.\n */\nexport interface EditSessionStatus {\n  readonly held: readonly ObjectNumberRange[];\n  readonly expiresIn: number;\n}\n\n/** Numbers a session can no longer use, and why. */\nexport interface ObjectNumbersLost {\n  readonly numbers: readonly number[];\n  /**\n   * `'reclaimed'`: the session expired and its numbers went to another one.\n   * `'versioned'`: a new version was published, which numbers objects anew.\n   */\n  readonly reason: 'reclaimed' | 'versioned';\n}\n\n/**\n * This session's reserved object numbers: final names for objects it is\n * about to create. A create that names one of them (`objectNumber`) makes\n * its object at exactly that number, so its ref is known before the engine\n * answers. Numbers are this session's alone; another session never gets\n * them.\n */\nexport interface ObjectNumberPool {\n  /** One held number, removed from the pool; `null` when none is held (then `reserve`). */\n  take(): number | null;\n  /** How many are held now. */\n  readonly held: number;\n  /** Resolves once at least `count` are held: one request, only when the pool is short. */\n  reserve(count: number): AbortablePromise<void>;\n  /**\n   * Called with numbers this session took or held that it can no longer\n   * use. Creates naming them are refused; a view showing objects at them\n   * should drop those. Returns the unsubscriber.\n   */\n  onLost(listener: (lost: ObjectNumbersLost) => void): () => void;\n}\n","import {\n  assertBundlePages,\n  assertKnownFields,\n  assertResourceIds,\n  assertResourcesNamed,\n  assertRowResources,\n  invalidBundle,\n  isBundlePageRef,\n  isRecord,\n  type BundlePage,\n  type ResourceId,\n} from './bundle';\nimport {\n  assertWithinLimit,\n  DEFAULT_BUNDLE_LIMITS,\n  manifestBytesOf,\n  type BundleLimits,\n} from './bundleLimits';\nimport type { WidgetAnnotation } from '../annotation/kinds/widget';\nimport type { FormFieldDTO } from '../forms/field';\nimport type { FormFieldRef } from '../identity/FormFieldRef';\nimport { encodePageKey } from '../identity/PageRef';\nimport type { Coordinates, PageCoordinates } from '../pageSpace/coordinates';\n\n/**\n * Form fields and their widgets, taken out of a document to go into this one\n * or another: the design (`doc.forms.import`) or only the values\n * (`doc.forms.importValues`). Each row is what a read returns: a field\n * whole, with its value and who made and filled it, and each of its\n * widgets as the form's rows read them. Any set of whole fields, their\n * widgets and the resources these name is a bundle.\n */\nexport interface FormBundle<C extends Coordinates = PageCoordinates> {\n  readonly format: 'embedpdf/form';\n  readonly version: 1;\n  /** Every page a widget is on or points at, in document order. */\n  readonly pages: readonly BundlePage[];\n  /** Whole fields, in the form's order. */\n  readonly fields: readonly FormBundleField<C>[];\n  /** The fields' widgets, in their fields' order. */\n  readonly widgets: readonly FormBundleWidget<C>[];\n  /** The calculation order among these fields. */\n  readonly calculationOrder: readonly FormFieldRef[];\n  readonly resources: Readonly<Record<ResourceId, Uint8Array>>;\n}\n\nexport interface FormBundleField<C extends Coordinates = PageCoordinates> {\n  /**\n   * The field as a read returns it. A field the form doesn't export\n   * (`noExport`) comes without its value or who filled it, and a signed\n   * signature field without its signature: a signature never travels.\n   */\n  readonly data: FormFieldDTO<C>;\n}\n\nexport interface FormBundleWidget<C extends Coordinates = PageCoordinates> {\n  readonly data: WidgetAnnotation<C>;\n  /** None yet: a widget is drawn from its data. A push button's icon will be one. */\n  readonly resources: Readonly<Record<string, ResourceId>>;\n}\n\n/** A bundle as a worker returns it: each resource an `ArrayBuffer` on the transfer list. */\nexport interface WireFormBundle<C extends Coordinates = PageCoordinates> extends Omit<\n  FormBundle<C>,\n  'resources'\n> {\n  readonly resources: Readonly<Record<ResourceId, ArrayBuffer>>;\n}\n\nexport const FORM_BUNDLE_FORMAT = 'embedpdf/form';\nexport const FORM_BUNDLE_VERSION = 1;\n\n/** The manifest's keys, in the order a file writes them. */\nexport const FORM_BUNDLE_KEYS = [\n  'format',\n  'version',\n  'pages',\n  'fields',\n  'widgets',\n  'calculationOrder',\n] as const;\n\n/** The resource roles a widget names: none yet. */\nconst WIDGET_RESOURCE_ROLES: readonly string[] = [];\n\nconst BUNDLE_FIELDS = [...FORM_BUNDLE_KEYS, 'resources'] as const;\nconst FIELD_ROW_FIELDS = ['data'] as const;\nconst WIDGET_ROW_FIELDS = ['data', 'resources'] as const;\n\n/**\n * Check a bundle before anything uses it, the checks cheapest first: its\n * format, its counts and sizes against `limits` (`PayloadTooLarge`), its\n * shape and references (`InvalidArg`), then every resource against its id.\n */\nexport async function assertFormBundle(\n  bundle: FormBundle,\n  limits: BundleLimits = DEFAULT_BUNDLE_LIMITS,\n): Promise<void> {\n  const resources = isRecord(bundle?.resources)\n    ? bundle.resources\n    : invalidBundle('form', 'no resources');\n  const sizes = new Map<string, number>();\n  for (const [id, bytes] of Object.entries(resources)) {\n    if (!(bytes instanceof Uint8Array)) invalidBundle('form', `resource ${id} is not bytes`);\n    sizes.set(id, bytes.length);\n  }\n  assertFormBundleManifest(bundle, sizes, limits);\n  await assertResourceIds('form', resources);\n}\n\n/**\n * The checks that need no resource bytes, only their sizes by id: format\n * and version, counts, sizes, the shape of pages, fields and widgets, and\n * that widgets and resources name each other exactly. That a widget's field\n * is among the bundle's is the import's to decide: one that isn't is left\n * out.\n */\nexport function assertFormBundleManifest(\n  manifest: unknown,\n  resourceSizes: ReadonlyMap<string, number>,\n  limits: BundleLimits,\n): asserts manifest is Omit<FormBundle, 'resources'> {\n  if (!isRecord(manifest)) invalidBundle('form', 'not a form bundle');\n  assertKnownFields('form', 'the bundle', manifest, BUNDLE_FIELDS);\n  if (manifest.format !== FORM_BUNDLE_FORMAT) {\n    invalidBundle('form', `unknown format ${JSON.stringify(manifest.format)}`);\n  }\n  if (manifest.version !== FORM_BUNDLE_VERSION) {\n    invalidBundle('form', `unknown version ${JSON.stringify(manifest.version)}`);\n  }\n  const { pages, fields, widgets, calculationOrder } = manifest;\n  if (!Array.isArray(pages)) invalidBundle('form', 'pages is not a list');\n  if (!Array.isArray(fields)) invalidBundle('form', 'fields is not a list');\n  if (!Array.isArray(widgets)) invalidBundle('form', 'widgets is not a list');\n  if (!Array.isArray(calculationOrder)) invalidBundle('form', 'calculationOrder is not a list');\n\n  assertWithinLimit('form', limits, 'items', fields.length + widgets.length);\n  assertWithinLimit('form', limits, 'pages', pages.length);\n  assertWithinLimit('form', limits, 'resources', resourceSizes.size);\n  let bundleBytes = manifestBytesOf({ pages, fields, widgets, calculationOrder });\n  assertWithinLimit('form', limits, 'manifestBytes', bundleBytes);\n  for (const size of resourceSizes.values()) {\n    assertWithinLimit('form', limits, 'resourceBytes', size);\n    bundleBytes += size;\n  }\n  assertWithinLimit('form', limits, 'bundleBytes', bundleBytes);\n\n  const pageKeys = assertBundlePages('form', pages);\n  fields.forEach((row, index) => {\n    if (\n      !isRecord(row) ||\n      !isRecord(row.data) ||\n      typeof row.data.family !== 'string' ||\n      typeof row.data.name !== 'string' ||\n      !isRecord(row.data.ref)\n    ) {\n      invalidBundle('form', `field ${index} has no field data`);\n    }\n    assertKnownFields('form', `field ${index}`, row, FIELD_ROW_FIELDS);\n  });\n  const named = new Set<string>();\n  widgets.forEach((row, index) => {\n    if (!isRecord(row) || !isRecord(row.data) || row.data.subtype !== 'widget') {\n      invalidBundle('form', `widget ${index} has no widget data`);\n    }\n    assertKnownFields('form', `widget ${index}`, row, WIDGET_ROW_FIELDS);\n    const ref = row.data.ref;\n    const page = isRecord(ref) ? ref.page : undefined;\n    if (!isBundlePageRef(page) || !pageKeys.has(encodePageKey(page))) {\n      invalidBundle('form', `widget ${index} is on a page the bundle doesn't list`);\n    }\n    assertRowResources(\n      'form',\n      `widget ${index}`,\n      row.resources,\n      WIDGET_RESOURCE_ROLES,\n      resourceSizes,\n      named,\n    );\n  });\n  calculationOrder.forEach((ref, index) => {\n    if (!isRecord(ref))\n      invalidBundle('form', `calculation order entry ${index} is not a field ref`);\n  });\n  assertResourcesNamed('form', 'widget', resourceSizes, named);\n}\n","import { bundleCodec } from './codec';\nimport { assertFormBundleManifest, FORM_BUNDLE_KEYS, type FormBundle } from './FormBundle';\n\n/**\n * A form bundle as one JSON file, each resource in base64: a bundle whole,\n * to store or download. HTTP carries bundles as multipart instead, without\n * the third base64 adds.\n */\nexport const FormTransfer = bundleCodec<FormBundle>({\n  kind: 'form',\n  keys: FORM_BUNDLE_KEYS,\n  assertManifest: assertFormBundleManifest,\n});\n","import { foldText, toOriginalRange } from './fold';\nimport type { FoldedText, FoldOptions } from './fold';\nimport type { TextRange } from '../text/TextRange';\nimport type { SearchQuery } from './types';\n\n/**\n * The fold flavor a literal query needs. Haystack and needle must be\n * folded with the same options; corpus caches key their pre-folded text\n * on this (the default `{}` fold is the persistable one — non-default\n * queries fold the original page text at query time).\n */\nexport function foldOptionsFor(query: SearchQuery): FoldOptions {\n  return {\n    keepCase: !!query.matchCase,\n    keepMarks: !!query.matchDiacritics,\n    dropWhitespace: !!query.ignoreWhitespace,\n  };\n}\n\n// One definition of \"word character\" for the whole search subsystem —\n// Unicode letters/digits, not JS \\b's ASCII set — shared by the literal\n// boundary check and the regex wholeWord post-filter, so the wholeWord\n// toggle means the same thing in both modes (\"caf\" never whole-word\n// matches inside \"café\", regex or not).\nconst WORD_UNIT = /[\\p{L}\\p{N}_]/u;\nconst MARK = /\\p{M}/u;\n\n/** Whether the code point ending at `index` (exclusive) is a word char. */\nexport function wordBefore(text: string, index: number): boolean {\n  if (index <= 0) return false;\n  // Step back over a low surrogate to test the full code point.\n  const unit = text.charCodeAt(index - 1);\n  const start = unit >= 0xdc00 && unit <= 0xdfff && index >= 2 ? index - 2 : index - 1;\n  return WORD_UNIT.test(String.fromCodePoint(text.codePointAt(start)!));\n}\n\n/** Whether the code point starting at `index` is a word char. */\nexport function wordAt(text: string, index: number): boolean {\n  if (index >= text.length) return false;\n  return WORD_UNIT.test(String.fromCodePoint(text.codePointAt(index)!));\n}\n\n/**\n * Whether the folded hit at `at` sits on word boundaries. Checked on the\n * folded plane, except under `ignoreWhitespace`: dropping whitespace glues\n * neighbouring words together (\"i n v o i c e 42\" folds to \"invoice42\"), so there the\n * boundaries are read off the original text around the mapped range.\n */\nfunction isWholeWordHit(\n  haystack: FoldedText,\n  at: number,\n  needleLength: number,\n  query: SearchQuery,\n): boolean {\n  if (!query.ignoreWhitespace) {\n    return !wordBefore(haystack.folded, at) && !wordAt(haystack.folded, at + needleLength);\n  }\n  const { start, count } = toOriginalRange(haystack, at, needleLength);\n  return !wordBefore(haystack.original, start) && !wordAt(haystack.original, start + count);\n}\n\n/**\n * All non-overlapping literal matches, in original code-unit space.\n * `haystack` must have been folded with `foldOptionsFor(query)`.\n */\nexport function matchLiteral(haystack: FoldedText, query: SearchQuery): TextRange[] {\n  const needle = foldText(query.text, foldOptionsFor(query)).folded;\n  // Nothing searchable: empty or whitespace-only needles would \"match\"\n  // every collapsed space.\n  if (needle.trim().length === 0) return [];\n\n  const out: TextRange[] = [];\n  let from = 0;\n  while (from <= haystack.folded.length - needle.length) {\n    const at = haystack.folded.indexOf(needle, from);\n    if (at < 0) break;\n    if (query.wholeWord && !isWholeWordHit(haystack, at, needle.length, query)) {\n      from = at + 1;\n      continue;\n    }\n    // Diacritic-sensitive folds are decomposed (base + marks), so a bare\n    // needle would otherwise match just the base letters of an accented\n    // char — \"cafe\" ending right before the U+0301 of \"café\". A match may\n    // not end mid-character.\n    if (query.matchDiacritics && at + needle.length < haystack.folded.length) {\n      const after = haystack.folded.codePointAt(at + needle.length)!;\n      if (MARK.test(String.fromCodePoint(after))) {\n        from = at + 1;\n        continue;\n      }\n    }\n    out.push(toOriginalRange(haystack, at, needle.length));\n    from = at + needle.length;\n  }\n  return out;\n}\n","import type { TextRange } from '../text/TextRange';\nimport { wordAt, wordBefore } from './literal';\nimport type { SearchQuery } from './types';\n\n/**\n * The portable search-regex dialect: JavaScript `u`-mode syntax minus the\n * features RE2 refuses (backreferences, lookaround). The local engine\n * executes patterns with JS `RegExp`; the server executes the same\n * pattern with RE2, whose linear-time guarantee is the ReDoS defense.\n * Restricting both sides to the common subset keeps one query string\n * valid — and equally powerful — everywhere.\n */\nexport const SEARCH_REGEX_MAX_LENGTH = 512;\n\nexport type SearchRegexIssue = 'empty' | 'too-long' | 'backreference' | 'lookaround' | 'syntax';\n\nexport type SearchRegexValidation =\n  | { ok: true }\n  | { ok: false; issue: SearchRegexIssue; message: string };\n\n/**\n * Validate a pattern against the dialect. Cheap and dependency-free —\n * viewers call it on keystroke for early feedback; engines re-validate\n * and reject bad patterns with `InvalidArg`.\n */\nexport function validateSearchRegex(pattern: string): SearchRegexValidation {\n  if (pattern.length === 0) {\n    return { ok: false, issue: 'empty', message: 'Pattern is empty.' };\n  }\n  if (pattern.length > SEARCH_REGEX_MAX_LENGTH) {\n    return {\n      ok: false,\n      issue: 'too-long',\n      message: `Pattern exceeds ${SEARCH_REGEX_MAX_LENGTH} characters.`,\n    };\n  }\n\n  // One pass tracking escape/char-class state: backreferences and\n  // lookaround only mean what they mean outside a character class.\n  let inClass = false;\n  for (let i = 0; i < pattern.length; i++) {\n    const ch = pattern[i];\n    if (ch === '\\\\') {\n      const next = pattern[i + 1] ?? '';\n      if (!inClass && next >= '1' && next <= '9') {\n        return {\n          ok: false,\n          issue: 'backreference',\n          message: `Backreference \\\\${next} is not supported.`,\n        };\n      }\n      if (!inClass && next === 'k' && pattern[i + 2] === '<') {\n        return {\n          ok: false,\n          issue: 'backreference',\n          message: 'Named backreferences (\\\\k<…>) are not supported.',\n        };\n      }\n      i++; // consume the escaped char\n      continue;\n    }\n    if (inClass) {\n      if (ch === ']') inClass = false;\n      continue;\n    }\n    if (ch === '[') {\n      inClass = true;\n      continue;\n    }\n    if (ch === '(' && pattern[i + 1] === '?') {\n      const tag = pattern[i + 2] ?? '';\n      if (tag === '=' || tag === '!') {\n        return {\n          ok: false,\n          issue: 'lookaround',\n          message: 'Lookahead ((?=…), (?!…)) is not supported.',\n        };\n      }\n      // \"(?<\" is lookbehind when followed by = or !, a named group otherwise.\n      if (tag === '<' && (pattern[i + 3] === '=' || pattern[i + 3] === '!')) {\n        return {\n          ok: false,\n          issue: 'lookaround',\n          message: 'Lookbehind ((?<=…), (?<!…)) is not supported.',\n        };\n      }\n    }\n  }\n\n  try {\n    // `u` is the strict common ground with RE2's syntax; `m` because ^/$\n    // meaning line boundaries is what page-text search wants.\n    new RegExp(pattern, 'mu');\n  } catch (error) {\n    return { ok: false, issue: 'syntax', message: (error as Error).message };\n  }\n  return { ok: true };\n}\n\n/**\n * Every flag combination has defined semantics — most by behavior, one by\n * loud rejection (see the {@link SearchQuery} table). The single validator\n * a UI needs: call it on keystroke to grey out the diacritics toggle in\n * regex mode and flag bad patterns early; engines run the same check and\n * reject with `InvalidArg`. Literal queries are always valid (an empty\n * literal simply finds nothing).\n */\nexport type SearchQueryIssue =\n  | SearchRegexIssue\n  | 'diacritics-with-regex'\n  | 'ignore-whitespace-with-regex';\n\nexport type SearchQueryValidation =\n  | { ok: true }\n  | { ok: false; issue: SearchQueryIssue; message: string };\n\nexport function validateSearchQuery(query: SearchQuery): SearchQueryValidation {\n  if (!query.regex) return { ok: true };\n  if (query.matchDiacritics) {\n    return {\n      ok: false,\n      issue: 'diacritics-with-regex',\n      message:\n        'Diacritic-sensitive matching is not available for regex patterns (regex runs on the raw text plane).',\n    };\n  }\n  if (query.ignoreWhitespace) {\n    return {\n      ok: false,\n      issue: 'ignore-whitespace-with-regex',\n      message:\n        'Whitespace-insensitive matching is not available for regex patterns (regex runs on the raw text plane; use \\\\s* in the pattern).',\n    };\n  }\n  return validateSearchRegex(query.text);\n}\n\n/**\n * All matches of a dialect-valid pattern over the raw page text (regex\n * does not run against folded text — case handling is the `i` flag, and\n * diacritic folding never applies). `wholeWord` is a boundary POST-filter\n * using the same Unicode word test as the literal path — never `\\b`,\n * whose ASCII word set would give the toggle different semantics in regex\n * mode (\"caf\" whole-word matching inside \"café\"). Filtering after the\n * match also survives the move to RE2 server-side. Zero-length matches\n * are skipped: search UI cannot highlight nothing, and skipping them is\n * also the infinite-loop guard for patterns like `a*`.\n */\nexport function matchRegex(text: string, query: SearchQuery): TextRange[] {\n  const valid = validateSearchQuery({ ...query, regex: true });\n  if (!valid.ok) throw new Error(`Invalid search query (${valid.issue}): ${valid.message}`);\n\n  const re = new RegExp(query.text, query.matchCase ? 'gmu' : 'gimu');\n  const out: TextRange[] = [];\n  let m: RegExpExecArray | null;\n  while ((m = re.exec(text)) !== null) {\n    if (m[0].length === 0) {\n      // Advance one full code point past the empty match.\n      const unit = text.charCodeAt(re.lastIndex);\n      re.lastIndex += unit >= 0xd800 && unit <= 0xdbff ? 2 : 1;\n      continue;\n    }\n    if (query.wholeWord && (wordBefore(text, m.index) || wordAt(text, m.index + m[0].length))) {\n      continue;\n    }\n    out.push({ start: m.index, count: m[0].length });\n  }\n  return out;\n}\n","import { EngineError } from '../errors/EngineError';\nimport { EngineErrorCode } from '../errors/EngineErrorCode';\nimport type { AnnotationRef } from '../identity/AnnotationRef';\nimport type { FormFieldRef } from '../identity/FormFieldRef';\nimport type { PageRef } from '../identity/PageRef';\n\n/**\n * Where rows go in their list: right before or after a neighbour, or at the\n * start or the end. A position names a neighbour, never a number, so a change\n * keeps its meaning when other rows come and go before it applies, and a\n * caller only names rows it can see.\n *\n * Each list is in its own order: a document's pages in display order; a\n * page's annotations, and its widgets, each in paint order, later over\n * earlier. Widgets always paint above annotations, so the two are separate\n * lists and a position names a neighbour of the same kind.\n */\nexport type ListPosition<Ref> =\n  | { readonly before: Ref }\n  | { readonly after: Ref }\n  | 'start'\n  | 'end';\n\n/** Where pages go among the document's pages. */\nexport type PagePosition = ListPosition<PageRef>;\n\n/** Where annotations go among their page's annotations, or widgets among its widgets. */\nexport type AnnotationPosition = ListPosition<AnnotationRef>;\n\n/** Where fields go in the form's calculation order. */\nexport type FieldPosition = ListPosition<FormFieldRef>;\n\n/** The neighbour a position names, or `null` for `'start'` and `'end'`. */\nexport function anchorOf<Ref>(position: ListPosition<Ref>): Ref | null {\n  if (position === 'start' || position === 'end') return null;\n  return 'before' in position ? position.before : position.after;\n}\n\n/**\n * Where `position` falls in `order`: the index the first row placed there\n * gets. The neighbour must be in `order` (`NotFound` otherwise).\n */\nexport function positionIndex<Ref>(\n  order: readonly Ref[],\n  position: ListPosition<Ref>,\n  keyOf: (ref: Ref) => string,\n): number {\n  if (position === 'start') return 0;\n  if (position === 'end') return order.length;\n  const anchor = anchorOf(position)!;\n  const at = order.findIndex((ref) => keyOf(ref) === keyOf(anchor));\n  if (at < 0) {\n    throw new EngineError(EngineErrorCode.NotFound, `no neighbour ${keyOf(anchor)} in the list`, {\n      details: { field: 'position' },\n    });\n  }\n  return 'before' in position ? at : at + 1;\n}\n\n/**\n * A list's order once `moved` go to `position`, together and in the order\n * given: what a reorder answers, worked out as the engine does. Every moved\n * row must be in `order`, once (`InvalidArg` otherwise), and the neighbour\n * can't be one of them (`InvalidArg`).\n */\nexport function reorderedList<Ref>(\n  order: readonly Ref[],\n  moved: readonly Ref[],\n  position: ListPosition<Ref>,\n  keyOf: (ref: Ref) => string,\n): Ref[] {\n  const movedKeys = new Set(moved.map(keyOf));\n  if (movedKeys.size !== moved.length) {\n    throw new EngineError(EngineErrorCode.InvalidArg, 'a row is named twice', {\n      details: { field: 'refs' },\n    });\n  }\n  const present = new Set(order.map(keyOf));\n  const missing = moved.find((ref) => !present.has(keyOf(ref)));\n  if (missing !== undefined) {\n    throw new EngineError(EngineErrorCode.NotFound, `no row ${keyOf(missing)} in the list`, {\n      details: { field: 'refs' },\n    });\n  }\n  const anchor = anchorOf(position);\n  if (anchor !== null && movedKeys.has(keyOf(anchor))) {\n    throw new EngineError(\n      EngineErrorCode.InvalidArg,\n      `the neighbour ${keyOf(anchor)} is one of the rows that move`,\n      { details: { field: 'position' } },\n    );\n  }\n  const staying = order.filter((ref) => !movedKeys.has(keyOf(ref)));\n  const at = positionIndex(staying, position, keyOf);\n  return [...staying.slice(0, at), ...moved, ...staying.slice(at)];\n}\n\n/**\n * `list` with the items `inPart` picks put in the order `order` gives them,\n * by key, in the slots those items have: every other item keeps its place.\n * How a list holding several pages takes one page's new order. Items of the\n * part `order` doesn't name follow the named ones, in their order.\n */\nexport function reorderPart<Item, Key>(\n  list: readonly Item[],\n  inPart: (item: Item) => boolean,\n  order: readonly Key[],\n  keyOf: (item: Item) => Key,\n): Item[] {\n  const part = list.filter(inPart);\n  const byKey = new Map(part.map((item) => [keyOf(item), item]));\n  const named: Item[] = order.flatMap((key) => (byKey.has(key) ? [byKey.get(key)!] : []));\n  const placed = new Set<Item>(named);\n  const next = [...named, ...part.filter((item) => !placed.has(item))];\n  let slot = 0;\n  return list.map((item) => (inPart(item) ? next[slot++]! : item));\n}\n","import type { PdfViewport } from '../dto/Measure';\nimport type { PagePoint } from '../geometry/pageSpace';\n\n/**\n * The last viewport whose box holds `point` (the one drawn on top), or\n * `undefined`. A foreign measure still wins; never guess a fallback.\n */\nexport function viewportForPoint<T extends PdfViewport>(\n  viewports: readonly T[],\n  point: PagePoint,\n): T | undefined {\n  return [...viewports]\n    .reverse()\n    .find(\n      ({ bbox: b }) =>\n        point.x >= b.x && point.x <= b.x + b.width && point.y >= b.y && point.y <= b.y + b.height,\n    );\n}\n"],"mappings":"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"}