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

package/dist/{authority-B3BklsB4.js → authority-PuxpGFhJ.js}

@@ -1,9 +1,9 @@
+import { G as mapLinkTarget, J as pageDestinationOf, K as mapPageActions, M as pageAnnotationOf, Q as applyResolvedPatch, V as mapActionTree, W as mapFieldActions, Y as pdfDestinationOf, c as foldText, gt as resolveBinarySource, kt as pdfRectOf, q as mapTriggerActions, wt as pageBoxOf } from "./calibrate-nQFgCuki.js";
 import { g as writesScripts } from "./value-Dhc8eYcx.js";
 import { gt as normalizePdfRect, nt as kindFactsOf, wt as pdfRectTurnedBounds, xt as pdfRectIntersection } from "./resolveAnnotationDraft-CUpf0SMh.js";
 import { h as EngineError, m as annotationKey, u as encodePageKey, v as _defineProperty, y as EngineErrorCode } from "./format-Dgg428Kb.js";
-import { Et as pdfRectOf, J as pageDestinationOf, K as mapPageActions, M as pageAnnotationOf, Q as applyResolvedPatch, W as mapFieldActions, Y as pdfDestinationOf, c as foldText, ht as resolveBinarySource, q as mapTriggerActions, xt as pageBoxOf } from "./calibrate-7T3fnP8-.js";
-import { C as lockCovers, E as protectedCapabilities, S as levelFromPermission, T as minLevel, _ as deriveProtection, a as checkFieldAction, i as checkCollab, j as PermissionDenied, n as checkAnyFieldAction, o as checkSetGroup, r as checkCapability, s as collabTargetOf, v as describeProtection, x as levelAllows } from "./resolver-CzxmD9Ck.js";
-import { S as AbortablePromise, d as matchLiteral, s as matchRegex, u as foldOptionsFor } from "./viewport-BJW13EGZ.js";
+import { C as lockCovers, E as protectedCapabilities, S as levelFromPermission, T as minLevel, _ as deriveProtection, a as checkFieldAction, i as checkCollab, j as PermissionDenied, n as checkAnyFieldAction, o as checkSetGroup, r as checkCapability, s as collabTargetOf, v as describeProtection, x as levelAllows } from "./resolver-BBggAxQc.js";
+import { S as AbortablePromise, d as matchLiteral, s as matchRegex, u as foldOptionsFor } from "./viewport-DQR5LyX3.js";
 //#region src/geometry/pageBoxes.ts
 /** The media box of a page that has none, which the file needs: US Letter. */
 const DEFAULT_MEDIA_BOX = {
@@ -69,6 +69,40 @@ function resolvePageLayers(options, may) {
 		includeFormFields: includeFormFields ?? (includeAnnotations === false ? false : may.formFields)
 	};
 }
+/**
+* Check what a render is for. A print picture (`usage: 'print'`) takes a
+* `{ kind: 'dpi', dpi }` viewport with a DPI of 150 or 300, and no `target`,
+* `rotation` or `background`: it is the whole page, upright, on white. A
+* `dpi` viewport is for print pictures only. Anything else is `InvalidArg`,
+* naming the option. With the caller's rights, a print they may not make is
+* refused (`PermissionDenied`): any print without `doc.print`, 300 DPI
+* without `doc.print.high`. Without them (a cloud caller whose rights the
+* client can't know), the server decides.
+*/
+function checkRenderUsage(options, may) {
+	const { usage, viewport } = options ?? {};
+	if (usage === void 0 || usage === "display") {
+		if (viewport?.kind === "dpi") invalid("viewport", "a dpi viewport is only for a print picture (usage: \"print\")");
+		return;
+	}
+	if (usage !== "print") invalid("usage", "usage must be \"display\" or \"print\"");
+	if (viewport?.kind !== "dpi" || viewport.dpi !== 150 && viewport.dpi !== 300) invalid("viewport", "a print picture needs viewport: { kind: 'dpi', dpi: 150 or 300 }");
+	for (const field of [
+		"target",
+		"rotation",
+		"background"
+	]) if (options?.[field] !== void 0) invalid(field, `a print picture takes no ${field}: it is the whole page, upright, on white`);
+	if (may === null) return;
+	if (!may.print) throw new PermissionDenied("doc.print", "usage");
+	if (viewport.dpi === 300 && !may.printHigh) throw new PermissionDenied("doc.print.high", "viewport");
+}
+/** A print picture's DPI: its viewport's, when it is one; otherwise `undefined`. */
+function printDpiOf(options) {
+	return options?.usage === "print" && options.viewport?.kind === "dpi" ? options.viewport.dpi : void 0;
+}
+function invalid(field, message) {
+	throw new EngineError(EngineErrorCode.InvalidArg, message, { details: { field } });
+}
 /** `InvalidArg` unless `quality` is absent or between 0 and 1. */
 function checkImageQuality(quality) {
 	if (quality === void 0 || quality >= 0 && quality <= 1) return;
@@ -116,6 +150,30 @@ function imageSourceOf(blobSource) {
 	};
 }
 //#endregion
+//#region src/dto/PageExtract.ts
+/**
+* What `pages.extract()` makes: `null` for a plain copy, else what the
+* flattened copy paints. A plain copy needs `doc.download`; a flattened one
+* `doc.download` or `doc.download.flattened`, and paints only what the caller
+* may read, with the defaults of a page picture (`resolvePageLayers`). The
+* include options belong to `flatten`: given without it, they're refused.
+*/
+function resolvePageExtract(options, may) {
+	const flatten = options?.flatten;
+	if (flatten === void 0) {
+		for (const field of ["includeAnnotations", "includeFormFields"]) if (options?.[field] !== void 0) throw new EngineError(EngineErrorCode.InvalidArg, `${field} takes flatten`, { details: { field } });
+		if (!may.download) throw new PermissionDenied("doc.download");
+		return null;
+	}
+	const usage = flatten.usage ?? "display";
+	if (usage !== "display" && usage !== "print") throw new EngineError(EngineErrorCode.InvalidArg, "usage must be \"display\" or \"print\"", { details: { field: "flatten.usage" } });
+	if (!may.download && !may.downloadFlattened) throw new PermissionDenied("doc.download", "flatten", ["doc.download", "doc.download.flattened"]);
+	return {
+		usage,
+		...resolvePageLayers(options, may)
+	};
+}
+//#endregion
 //#region src/dto/PdfSaveMode.ts
 const DEFAULT_PDF_SAVE_MODE = "incremental";
 //#endregion
@@ -464,6 +522,50 @@ function pageFormSnapshotOf(snapshot, boxOf) {
 	};
 }
 //#endregion
+//#region src/pageSpace/outline.ts
+/**
+* The outline between the file's coordinates and page space: only the
+* destinations an item goes to change, each measured on the page it goes to.
+*/
+/** An item, its target's and its action's destinations converted. */
+function mapOutlineItem(item, convert) {
+	return {
+		...item,
+		target: item.target && mapLinkTarget(item.target, convert),
+		action: item.action && mapActionTree(item.action, convert)
+	};
+}
+/** A draft or a patch, its target's destination converted. */
+function mapOutlineWrite(write, convert) {
+	const { target, ...rest } = write;
+	if (target === void 0) return rest;
+	return {
+		...rest,
+		target: target && target.kind === "goto" ? {
+			...target,
+			destination: convert(target.destination)
+		} : target
+	};
+}
+/** The outline as a read hands it out: every destination in page space. */
+function pageOutlineOf(outline, boxOf) {
+	return {
+		...outline,
+		items: outline.items.map((item) => pageOutlineItemOf(item, boxOf))
+	};
+}
+function pageOutlineItemOf(item, boxOf) {
+	return mapOutlineItem(item, (destination) => pageDestinationOf(destination, boxOf));
+}
+/** A draft in the file's coordinates, as the engine writes it. */
+function pdfOutlineDraftOf(draft, boxOf) {
+	return mapOutlineWrite(draft, (destination) => pdfDestinationOf(destination, boxOf));
+}
+/** A patch in the file's coordinates, as the engine writes it. */
+function pdfOutlinePatchOf(patch, boxOf) {
+	return mapOutlineWrite(patch, (destination) => pdfDestinationOf(destination, boxOf));
+}
+//#endregion
 //#region src/forms/draft.ts
 /**
 * Whether creating a field from `draft` takes `doc.forms.script`: a script
@@ -1090,7 +1192,7 @@ function indexRoles(s) {
 		sigFields
 	};
 }
-function edgeKey(e) {
+function edgeKey$1(e) {
 	return `${e.parent}:${e.label}`;
 }
 var StepContext = class {
@@ -1116,7 +1218,7 @@ var StepContext = class {
 	}
 	claimEdge(c, side, edge, rule, allow = true) {
 		if (this.locked.has(c.objectNumber)) return;
-		const key = `${c.objectNumber}:${side}:${edgeKey(edge)}`;
+		const key = `${c.objectNumber}:${side}:${edgeKey$1(edge)}`;
 		if (!this.claims.has(key)) this.claims.set(key, {
 			rule,
 			allow
@@ -1132,17 +1234,17 @@ var StepContext = class {
 	* anything hang off it.
 	*/
 	claimStable(c, rule, allow = true) {
-		const oldKeys = new Set(c.usage.old.map(edgeKey));
-		const newKeys = new Set(c.usage.new.map(edgeKey));
-		for (const e of c.usage.old) if (newKeys.has(edgeKey(e))) this.claimEdge(c, "old", e, rule, allow);
-		for (const e of c.usage.new) if (oldKeys.has(edgeKey(e))) this.claimEdge(c, "new", e, rule, allow);
+		const oldKeys = new Set(c.usage.old.map(edgeKey$1));
+		const newKeys = new Set(c.usage.new.map(edgeKey$1));
+		for (const e of c.usage.old) if (newKeys.has(edgeKey$1(e))) this.claimEdge(c, "old", e, rule, allow);
+		for (const e of c.usage.new) if (oldKeys.has(edgeKey$1(e))) this.claimEdge(c, "new", e, rule, allow);
 	}
 	isClaimed(c, side, edge) {
-		return this.claims.has(`${c.objectNumber}:${side}:${edgeKey(edge)}`);
+		return this.claims.has(`${c.objectNumber}:${side}:${edgeKey$1(edge)}`);
 	}
 	/** The use was inspected by a rule that allowed it. */
 	isAllowed(c, side, edge) {
-		return this.claims.get(`${c.objectNumber}:${side}:${edgeKey(edge)}`)?.allow === true;
+		return this.claims.get(`${c.objectNumber}:${side}:${edgeKey$1(edge)}`)?.allow === true;
 	}
 	permitted(c, rule, detail) {
 		if (this.locked.has(c.objectNumber)) return;
@@ -1163,7 +1265,7 @@ var StepContext = class {
 			rule,
 			verdict: c.value.truncated ? "incomplete" : "forbidden",
 			objectNumber: c.objectNumber,
-			edge: edge ? edgeKey(edge) : void 0,
+			edge: edge ? edgeKey$1(edge) : void 0,
 			detail: c.value.truncated ? `${detail} (judged on missing evidence: not proven)` : detail
 		});
 	}
@@ -1758,6 +1860,11 @@ const DEFAULT_EDGE_RESOLVER_BUDGET = {
 };
 const USAGE_INCOMPLETE = "incomplete";
 /**
+* The label segment that stands for a route between two members of a loop.
+* Fork labels are ASCII (keys are `#`-escaped), so it is never a key.
+*/
+const LOOP_ROUTE = "…";
+/**
 * Resolves the raw inbound edges of an object (from the fork's referrer
 * index, which covers every reachable object of a revision) into edges
 * from *anchors*: the changed objects and the structural objects of the
@@ -1767,68 +1874,222 @@ const USAGE_INCOMPLETE = "incomplete";
 * appearance stream under an unchanged indirect `/AP` dictionary reads
 * `widget:AP/N` rather than `apDict:N`.
 *
-* A graph traversal, not a path enumeration: results are memoised per
-* object, so a lattice of shared unchanged objects costs its size, not the
-* number of paths through it. Cycle edges contribute no anchors and are
-* skipped; a result computed while skipping one is not memoised.
+* A graph traversal, not a path enumeration. The unchanged objects above
+* an object are read once each and split into strongly connected
+* components (loops: a structure tree, whose elements point at their
+* parent with `/P` and at their children with `/K`; an outline, whose
+* items point at their neighbours; an annotation and its popup), resolved
+* ancestors first and memoised per object, so a lattice of shared objects
+* costs its size, not the number of paths through it.
+*
+* Every member of a loop reaches every other one, so an edge into a loop
+* reaches all its members: as it is at the member it enters, and as
+* `<label>/…` at every other one, the route between them collapsed. The
+* route consists of unchanged objects, the same in both revisions, so it
+* carries no evidence; the anchor, the way in and the way out (the labels
+* either side of `…`) do, and they are kept. Edges whose label collapses
+* a route are told apart by anchor and label alone.
 */
 var EdgeResolver = class {
 	constructor(read, anchors, budget = DEFAULT_EDGE_RESOLVER_BUDGET) {
 		this.read = read;
 		this.anchors = anchors;
 		this.budget = budget;
-		_defineProperty(this, "memo", /* @__PURE__ */ new Map());
+		_defineProperty(this, "referrers", /* @__PURE__ */ new Map());
+		_defineProperty(this, "resolved", /* @__PURE__ */ new Map());
 		_defineProperty(this, "reads", 0);
 		_defineProperty(this, "exhausted", false);
 	}
 	/** Anchored edges of `objectNumber`, or `incomplete` when a budget was exceeded. */
 	resolve(objectNumber) {
-		if (this.exhausted) return USAGE_INCOMPLETE;
-		const result = this.resolveInner(objectNumber, /* @__PURE__ */ new Set());
-		return result === null ? USAGE_INCOMPLETE : result.edges;
-	}
-	resolveInner(n, active) {
-		const hit = this.memo.get(n);
-		if (hit) return hit;
-		if (active.size >= this.budget.maxDepth) return null;
-		if (this.reads >= this.budget.maxReads) {
+		if (!this.resolved.has(objectNumber)) {
+			const components = this.componentsAbove(objectNumber);
+			for (const component of components ?? []) if (!this.resolveComponent(component)) break;
+		}
+		return this.resolved.get(objectNumber) ?? "incomplete";
+	}
+	readReferrers(n) {
+		const known = this.referrers.get(n);
+		if (known) return known;
+		if (this.exhausted || this.reads >= this.budget.maxReads) {
 			this.exhausted = true;
 			return null;
 		}
 		this.reads += 1;
 		const raw = this.read(n);
-		active.add(n);
+		this.referrers.set(n, raw);
+		return raw;
+	}
+	/** The parents of an object still to be resolved: unchanged, non-structural, not resolved yet. */
+	pendingParents(raw) {
+		const out = /* @__PURE__ */ new Set();
+		for (const e of raw) if (!this.anchors.has(e.parent) && !this.resolved.has(e.parent)) out.add(e.parent);
+		return [...out];
+	}
+	/**
+	* The strongly connected components of the unresolved objects above
+	* `start` (Tarjan's algorithm, iterative), ancestors first; null when the
+	* read budget ran out.
+	*/
+	componentsAbove(start) {
+		const index = /* @__PURE__ */ new Map();
+		const low = /* @__PURE__ */ new Map();
+		const stack = [];
+		const onStack = /* @__PURE__ */ new Set();
+		const frames = [];
+		const components = [];
+		const enter = (n) => {
+			const raw = this.readReferrers(n);
+			if (!raw) return false;
+			index.set(n, index.size);
+			low.set(n, index.get(n));
+			stack.push(n);
+			onStack.add(n);
+			frames.push({
+				node: n,
+				parents: this.pendingParents(raw),
+				next: 0
+			});
+			return true;
+		};
+		if (!enter(start)) return null;
+		while (frames.length > 0) {
+			const frame = frames[frames.length - 1];
+			if (frame.next < frame.parents.length) {
+				const p = frame.parents[frame.next++];
+				if (!index.has(p)) {
+					if (!enter(p)) return null;
+				} else if (onStack.has(p)) low.set(frame.node, Math.min(low.get(frame.node), index.get(p)));
+				continue;
+			}
+			frames.pop();
+			const n = frame.node;
+			if (frames.length > 0) {
+				const below = frames[frames.length - 1].node;
+				low.set(below, Math.min(low.get(below), low.get(n)));
+			}
+			if (low.get(n) === index.get(n)) {
+				const component = [];
+				let m;
+				do {
+					m = stack.pop();
+					onStack.delete(m);
+					component.push(m);
+				} while (m !== n);
+				components.push(component);
+			}
+		}
+		return components;
+	}
+	/** Resolve one component whose ancestors are all resolved; false when it exceeded the budget. */
+	resolveComponent(component) {
+		const members = new Set(component);
+		const result = component.length === 1 ? this.edgesOfSingle(component[0]) : this.edgesOfLoop(component, members);
+		if (!result) {
+			for (const n of component) this.resolved.set(n, null);
+			return false;
+		}
+		for (const n of component) this.resolved.set(n, result.get(n));
+		return true;
+	}
+	/** An object outside any loop: its raw edges, each resolved through its parent. */
+	edgesOfSingle(n) {
 		const edges = [];
-		let cyclic = false;
-		try {
-			for (const e of raw) {
-				if (this.anchors.has(e.parent)) edges.push(e);
-				else if (active.has(e.parent)) {
-					cyclic = true;
-					continue;
-				} else {
-					const up = this.resolveInner(e.parent, active);
-					if (up === null) return null;
-					cyclic || (cyclic = up.cyclic);
-					for (const u of up.edges) edges.push({
+		for (const e of this.referrers.get(n)) {
+			if (e.parent === n) continue;
+			const through = this.through(e);
+			if (!through) return null;
+			edges.push(...through);
+		}
+		const unique = withoutCollapsedDuplicates(edges);
+		return unique.length > this.budget.maxEdgesPerObject ? null : /* @__PURE__ */ new Map([[n, unique]]);
+	}
+	/**
+	* A loop: every anchored edge into it, as it is at the member it enters
+	* and with the route collapsed at every other member.
+	*/
+	edgesOfLoop(component, members) {
+		const entering = /* @__PURE__ */ new Map();
+		const routes = /* @__PURE__ */ new Map();
+		for (const s of component) {
+			const own = [];
+			for (const e of this.referrers.get(s)) {
+				if (members.has(e.parent)) continue;
+				const through = this.through(e);
+				if (!through) return null;
+				for (const u of through) {
+					own.push(u);
+					const via = [...u.via ?? [], s];
+					if (via.length >= this.budget.maxDepth) return null;
+					const route = {
 						parent: u.parent,
-						label: `${u.label}/${e.label}`,
-						via: [...u.via ?? [], e.parent]
-					});
+						label: `${u.label}/${LOOP_ROUTE}`,
+						via
+					};
+					const known = routes.get(edgeKey(route));
+					if (!known) routes.set(edgeKey(route), [route]);
+					else if (known.length === 1 && entryOf(known[0]) !== s) known.push(route);
 				}
-				if (edges.length > this.budget.maxEdgesPerObject) return null;
+				if (own.length > this.budget.maxEdgesPerObject) return null;
 			}
-		} finally {
-			active.delete(n);
+			if (own.length > 0) entering.set(s, withoutCollapsedDuplicates(own));
 		}
-		const resolution = {
-			edges,
-			cyclic
-		};
-		if (!cyclic) this.memo.set(n, resolution);
-		return resolution;
+		if (routes.size > this.budget.maxEdgesPerObject) return null;
+		const out = /* @__PURE__ */ new Map();
+		const toAny = [...routes.values()].map((entries) => entries[0]);
+		for (const n of component) {
+			const own = entering.get(n);
+			if (!own) {
+				out.set(n, toAny);
+				continue;
+			}
+			const toThis = [];
+			for (const entries of routes.values()) {
+				const route = entries.find((r) => entryOf(r) !== n);
+				if (route) toThis.push(route);
+			}
+			const edges = [...own, ...toThis];
+			if (edges.length > this.budget.maxEdgesPerObject) return null;
+			out.set(n, edges);
+		}
+		return out;
+	}
+	/** The anchored edges one raw edge stands for; null when its parent exceeded the budget. */
+	through(e) {
+		if (this.anchors.has(e.parent)) return [e];
+		const above = this.resolved.get(e.parent);
+		if (!above) return null;
+		const out = [];
+		for (const u of above) {
+			const via = [...u.via ?? [], e.parent];
+			if (via.length >= this.budget.maxDepth) return null;
+			out.push({
+				parent: u.parent,
+				label: `${u.label}/${e.label}`,
+				via
+			});
+		}
+		return out;
 	}
 };
+function edgeKey(e) {
+	return `${e.parent}:${e.label}`;
+}
+/** The member a collapsed route enters its loop at: the last object it was resolved through. */
+function entryOf(route) {
+	return route.via[route.via.length - 1];
+}
+/** Edges whose label collapses a route are told apart by anchor and label alone. */
+function withoutCollapsedDuplicates(edges) {
+	const seen = /* @__PURE__ */ new Set();
+	return edges.filter((e) => {
+		if (!e.label.includes(LOOP_ROUTE)) return true;
+		const key = edgeKey(e);
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
 //#endregion
 //#region src/search/types.ts
 /** The query part of a request (or of any object that carries one): its text and flags, set flags only. */
@@ -2030,6 +2291,12 @@ function finish(h1, h2) {
 	return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(36);
 }
 //#endregion
+//#region src/mutation/OutlineMutationResults.ts
+/** What a delete removed, as its `outline.deleted` event names it: the item first. */
+function deletedOutlineItemsOf(result) {
+	return result.meta.changed;
+}
+//#endregion
 //#region src/auth/scope/pdf-bits.ts
 /**
 * ISO 32000 user-access permission bit positions, expressed as integer
@@ -2234,6 +2501,6 @@ function fieldCapability(action) {
 	return action === "fill" ? "doc.forms.fill" : "doc.sign";
 }
 //#endregion
-export { pageListOf as $, sameEffectiveValue as A, refsOf as B, searchQueryOf as C, restrictionsFor as D, USAGE_INCOMPLETE as E, worstVerdict as F, pageFormFieldOf as G, placedWidgetOf as H, changedKeys as I, pdfFormFieldDraftOf as J, pageFormSnapshotOf as K, dictEntries as L, combine as M, conclude as N, evaluateStep as O, primaryFinding as P, pageLayoutOf as Q, parsePdfValue as R, matchPageText as S, EdgeResolver as T, draftWritesScripts as U, stableStringify as V, pageFieldActionsOf as W, pageAppearancesOf as X, pdfWidgetPlacementOf as Y, pdfRenderTargetOf as Z, opIdOf as _, DEFAULT_MEDIA_BOX as _t, annotationWriteCapability as a, concatAnnotationLists as at, SEARCH_SNIPPET_CONTEXT as b, authorizeAnnotationUpdate as c, normalizeAttachmentFileSource as ct, authorizeFieldWrite as d, generateUuidV7 as dt, pageSpaceBoxesOf as et, authorizeUnprotected as f, DEFAULT_PDF_SAVE_MODE as ft, isKeptRefusal as g, resolvePageLayers as gt, changeFingerprint as h, imageSourceOfBytes as ht, annotationWriteCapabilities as i, deletedAnnotationsOf as it, assessmentOf as j, restrictionsOf as k, authorizeCapability as l, familyOfSubtype as lt, decodePdfBits as m, createPageImageHandle as mt, allowsFieldWrite as n, annotationPatchBetween as nt, authorizeAnnotationCreate as o, closeExportSelection as ot, PDF_BITS as p, checkImageQuality as pt, pageWidgetOf as q, allowsSomeFieldWrite as r, mergeAnnotationPatch as rt, authorizeAnnotationDelete as s, annotationImportFacts as st, allowsCapability as t, visibleBoxesOf as tt, authorizeFieldGroup as u, generateUuid as ut, canonicalSearchQuery as v, pageBoxesOf as vt, DEFAULT_EDGE_RESOLVER_BUDGET as w, buildSnippet as x, searchContentEpoch as y, pageRotationOf as yt, pdfValueEquals as z };
+export { pageWidgetOf as $, restrictionsOf as A, pdfValueEquals as B, matchPageText as C, imageSourceOfBytes as Ct, USAGE_INCOMPLETE as D, pageBoxesOf as Dt, EdgeResolver as E, DEFAULT_MEDIA_BOX as Et, primaryFinding as F, mapOutlineItem as G, stableStringify as H, worstVerdict as I, pdfOutlineDraftOf as J, pageOutlineItemOf as K, changedKeys as L, assessmentOf as M, combine as N, restrictionsFor as O, pageRotationOf as Ot, conclude as P, pageFormSnapshotOf as Q, dictEntries as R, buildSnippet as S, createPageImageHandle as St, DEFAULT_EDGE_RESOLVER_BUDGET as T, resolvePageLayers as Tt, placedWidgetOf as U, refsOf as V, draftWritesScripts as W, pageFieldActionsOf as X, pdfOutlinePatchOf as Y, pageFormFieldOf as Z, isKeptRefusal as _, generateUuidV7 as _t, annotationWriteCapability as a, pageListOf as at, searchContentEpoch as b, checkImageQuality as bt, authorizeAnnotationUpdate as c, annotationPatchBetween as ct, authorizeFieldWrite as d, concatAnnotationLists as dt, pdfFormFieldDraftOf as et, authorizeUnprotected as f, closeExportSelection as ft, changeFingerprint as g, generateUuid as gt, deletedOutlineItemsOf as h, familyOfSubtype as ht, annotationWriteCapabilities as i, pageLayoutOf as it, sameEffectiveValue as j, evaluateStep as k, authorizeCapability as l, mergeAnnotationPatch as lt, decodePdfBits as m, normalizeAttachmentFileSource as mt, allowsFieldWrite as n, pageAppearancesOf as nt, authorizeAnnotationCreate as o, pageSpaceBoxesOf as ot, PDF_BITS as p, annotationImportFacts as pt, pageOutlineOf as q, allowsSomeFieldWrite as r, pdfRenderTargetOf as rt, authorizeAnnotationDelete as s, visibleBoxesOf as st, allowsCapability as t, pdfWidgetPlacementOf as tt, authorizeFieldGroup as u, deletedAnnotationsOf as ut, opIdOf as v, DEFAULT_PDF_SAVE_MODE as vt, searchQueryOf as w, printDpiOf as wt, SEARCH_SNIPPET_CONTEXT as x, checkRenderUsage as xt, canonicalSearchQuery as y, resolvePageExtract as yt, parsePdfValue as z };
 
-//# sourceMappingURL=authority-B3BklsB4.js.map
+//# sourceMappingURL=authority-PuxpGFhJ.js.map