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

package/dist/viewport-DlL5Bxbg.cjs

@@ -0,0 +1,671 @@
+const require_resolveAnnotationDraft = require("./resolveAnnotationDraft-7Ke4nV7F.cjs");
+const require_format = require("./format-Bp3QFSH1.cjs");
+const require_calibrate = require("./calibrate-DJBXnhLE.cjs");
+//#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);
+		});
+		require_format._defineProperty(this, "signal", void 0);
+		require_format._defineProperty(this, "_ctrl", void 0);
+		require_format._defineProperty(this, "_progressCbs", void 0);
+		require_format._defineProperty(this, "_state", void 0);
+		require_format._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 require_calibrate.AbortError ? reason : new require_calibrate.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 = require_calibrate.DEFAULT_BUNDLE_LIMITS) {
+	const resources = require_resolveAnnotationDraft.isRecord(bundle?.resources) ? bundle.resources : require_resolveAnnotationDraft.invalidBundle("form", "no resources");
+	const sizes = /* @__PURE__ */ new Map();
+	for (const [id, bytes] of Object.entries(resources)) {
+		if (!(bytes instanceof Uint8Array)) require_resolveAnnotationDraft.invalidBundle("form", `resource ${id} is not bytes`);
+		sizes.set(id, bytes.length);
+	}
+	assertFormBundleManifest(bundle, sizes, limits);
+	await require_resolveAnnotationDraft.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 (!require_resolveAnnotationDraft.isRecord(manifest)) require_resolveAnnotationDraft.invalidBundle("form", "not a form bundle");
+	require_resolveAnnotationDraft.assertKnownFields("form", "the bundle", manifest, BUNDLE_FIELDS);
+	if (manifest.format !== "embedpdf/form") require_resolveAnnotationDraft.invalidBundle("form", `unknown format ${JSON.stringify(manifest.format)}`);
+	if (manifest.version !== 1) require_resolveAnnotationDraft.invalidBundle("form", `unknown version ${JSON.stringify(manifest.version)}`);
+	const { pages, fields, widgets, calculationOrder } = manifest;
+	if (!Array.isArray(pages)) require_resolveAnnotationDraft.invalidBundle("form", "pages is not a list");
+	if (!Array.isArray(fields)) require_resolveAnnotationDraft.invalidBundle("form", "fields is not a list");
+	if (!Array.isArray(widgets)) require_resolveAnnotationDraft.invalidBundle("form", "widgets is not a list");
+	if (!Array.isArray(calculationOrder)) require_resolveAnnotationDraft.invalidBundle("form", "calculationOrder is not a list");
+	require_calibrate.assertWithinLimit("form", limits, "items", fields.length + widgets.length);
+	require_calibrate.assertWithinLimit("form", limits, "pages", pages.length);
+	require_calibrate.assertWithinLimit("form", limits, "resources", resourceSizes.size);
+	let bundleBytes = require_calibrate.manifestBytesOf({
+		pages,
+		fields,
+		widgets,
+		calculationOrder
+	});
+	require_calibrate.assertWithinLimit("form", limits, "manifestBytes", bundleBytes);
+	for (const size of resourceSizes.values()) {
+		require_calibrate.assertWithinLimit("form", limits, "resourceBytes", size);
+		bundleBytes += size;
+	}
+	require_calibrate.assertWithinLimit("form", limits, "bundleBytes", bundleBytes);
+	const pageKeys = require_resolveAnnotationDraft.assertBundlePages("form", pages);
+	fields.forEach((row, index) => {
+		if (!require_resolveAnnotationDraft.isRecord(row) || !require_resolveAnnotationDraft.isRecord(row.data) || typeof row.data.family !== "string" || typeof row.data.name !== "string" || !require_resolveAnnotationDraft.isRecord(row.data.ref)) require_resolveAnnotationDraft.invalidBundle("form", `field ${index} has no field data`);
+		require_resolveAnnotationDraft.assertKnownFields("form", `field ${index}`, row, FIELD_ROW_FIELDS);
+	});
+	const named = /* @__PURE__ */ new Set();
+	widgets.forEach((row, index) => {
+		if (!require_resolveAnnotationDraft.isRecord(row) || !require_resolveAnnotationDraft.isRecord(row.data) || row.data.subtype !== "widget") require_resolveAnnotationDraft.invalidBundle("form", `widget ${index} has no widget data`);
+		require_resolveAnnotationDraft.assertKnownFields("form", `widget ${index}`, row, WIDGET_ROW_FIELDS);
+		const ref = row.data.ref;
+		const page = require_resolveAnnotationDraft.isRecord(ref) ? ref.page : void 0;
+		if (!require_resolveAnnotationDraft.isBundlePageRef(page) || !pageKeys.has(require_format.encodePageKey(page))) require_resolveAnnotationDraft.invalidBundle("form", `widget ${index} is on a page the bundle doesn't list`);
+		require_resolveAnnotationDraft.assertRowResources("form", `widget ${index}`, row.resources, WIDGET_RESOURCE_ROLES, resourceSizes, named);
+	});
+	calculationOrder.forEach((ref, index) => {
+		if (!require_resolveAnnotationDraft.isRecord(ref)) require_resolveAnnotationDraft.invalidBundle("form", `calculation order entry ${index} is not a field ref`);
+	});
+	require_resolveAnnotationDraft.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 = require_calibrate.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 } = require_calibrate.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 = require_calibrate.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(require_calibrate.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 require_format.EngineError(require_format.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 require_format.EngineError(require_format.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 require_format.EngineError(require_format.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 require_format.EngineError(require_format.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
+Object.defineProperty(exports, "AbortablePromise", {
+	enumerable: true,
+	get: function() {
+		return AbortablePromise;
+	}
+});
+Object.defineProperty(exports, "FormTransfer", {
+	enumerable: true,
+	get: function() {
+		return FormTransfer;
+	}
+});
+Object.defineProperty(exports, "OBJECT_NUMBER_CEILING", {
+	enumerable: true,
+	get: function() {
+		return OBJECT_NUMBER_CEILING;
+	}
+});
+Object.defineProperty(exports, "OBJECT_NUMBER_ISSUE_LIMIT", {
+	enumerable: true,
+	get: function() {
+		return OBJECT_NUMBER_ISSUE_LIMIT;
+	}
+});
+Object.defineProperty(exports, "SEARCH_REGEX_MAX_LENGTH", {
+	enumerable: true,
+	get: function() {
+		return SEARCH_REGEX_MAX_LENGTH;
+	}
+});
+Object.defineProperty(exports, "anchorOf", {
+	enumerable: true,
+	get: function() {
+		return anchorOf;
+	}
+});
+Object.defineProperty(exports, "assertFormBundle", {
+	enumerable: true,
+	get: function() {
+		return assertFormBundle;
+	}
+});
+Object.defineProperty(exports, "assertFormBundleManifest", {
+	enumerable: true,
+	get: function() {
+		return assertFormBundleManifest;
+	}
+});
+Object.defineProperty(exports, "foldOptionsFor", {
+	enumerable: true,
+	get: function() {
+		return foldOptionsFor;
+	}
+});
+Object.defineProperty(exports, "formatObjectNumberRanges", {
+	enumerable: true,
+	get: function() {
+		return formatObjectNumberRanges;
+	}
+});
+Object.defineProperty(exports, "matchLiteral", {
+	enumerable: true,
+	get: function() {
+		return matchLiteral;
+	}
+});
+Object.defineProperty(exports, "matchRegex", {
+	enumerable: true,
+	get: function() {
+		return matchRegex;
+	}
+});
+Object.defineProperty(exports, "objectNumbersIn", {
+	enumerable: true,
+	get: function() {
+		return objectNumbersIn;
+	}
+});
+Object.defineProperty(exports, "parseObjectNumberRanges", {
+	enumerable: true,
+	get: function() {
+		return parseObjectNumberRanges;
+	}
+});
+Object.defineProperty(exports, "positionIndex", {
+	enumerable: true,
+	get: function() {
+		return positionIndex;
+	}
+});
+Object.defineProperty(exports, "reorderPart", {
+	enumerable: true,
+	get: function() {
+		return reorderPart;
+	}
+});
+Object.defineProperty(exports, "reorderedList", {
+	enumerable: true,
+	get: function() {
+		return reorderedList;
+	}
+});
+Object.defineProperty(exports, "validateSearchQuery", {
+	enumerable: true,
+	get: function() {
+		return validateSearchQuery;
+	}
+});
+Object.defineProperty(exports, "validateSearchRegex", {
+	enumerable: true,
+	get: function() {
+		return validateSearchRegex;
+	}
+});
+Object.defineProperty(exports, "viewportForPoint", {
+	enumerable: true,
+	get: function() {
+		return viewportForPoint;
+	}
+});
+Object.defineProperty(exports, "wordAt", {
+	enumerable: true,
+	get: function() {
+		return wordAt;
+	}
+});
+Object.defineProperty(exports, "wordBefore", {
+	enumerable: true,
+	get: function() {
+		return wordBefore;
+	}
+});
+
+//# sourceMappingURL=viewport-DlL5Bxbg.cjs.map