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

package/dist/{authority-DLMNR7ff.cjs → authority-BFp6XM04.cjs}

@@ -1,9 +1,9 @@
+const require_calibrate = require("./calibrate-DJbi1wuK.cjs");
 const require_value = require("./value-BFS1R8ek.cjs");
 const require_resolveAnnotationDraft = require("./resolveAnnotationDraft-7Ke4nV7F.cjs");
 const require_format = require("./format-Bp3QFSH1.cjs");
-const require_calibrate = require("./calibrate-DJBXnhLE.cjs");
-const require_resolver = require("./resolver-D2OCtE8F.cjs");
-const require_viewport = require("./viewport-DlL5Bxbg.cjs");
+const require_resolver = require("./resolver-BWSWSF6R.cjs");
+const require_viewport = require("./viewport-CHG9qQUb.cjs");
 //#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 require_resolver.PermissionDenied("doc.print", "usage");
+	if (viewport.dpi === 300 && !may.printHigh) throw new require_resolver.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 require_format.EngineError(require_format.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 require_format.EngineError(require_format.EngineErrorCode.InvalidArg, `${field} takes flatten`, { details: { field } });
+		if (!may.download) throw new require_resolver.PermissionDenied("doc.download");
+		return null;
+	}
+	const usage = flatten.usage ?? "display";
+	if (usage !== "display" && usage !== "print") throw new require_format.EngineError(require_format.EngineErrorCode.InvalidArg, "usage must be \"display\" or \"print\"", { details: { field: "flatten.usage" } });
+	if (!may.download && !may.downloadFlattened) throw new require_resolver.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 && require_calibrate.mapLinkTarget(item.target, convert),
+		action: item.action && require_calibrate.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) => require_calibrate.pageDestinationOf(destination, boxOf));
+}
+/** A draft in the file's coordinates, as the engine writes it. */
+function pdfOutlineDraftOf(draft, boxOf) {
+	return mapOutlineWrite(draft, (destination) => require_calibrate.pdfDestinationOf(destination, boxOf));
+}
+/** A patch in the file's coordinates, as the engine writes it. */
+function pdfOutlinePatchOf(patch, boxOf) {
+	return mapOutlineWrite(patch, (destination) => require_calibrate.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;
-		require_format._defineProperty(this, "memo", /* @__PURE__ */ new Map());
+		require_format._defineProperty(this, "referrers", /* @__PURE__ */ new Map());
+		require_format._defineProperty(this, "resolved", /* @__PURE__ */ new Map());
 		require_format._defineProperty(this, "reads", 0);
 		require_format._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
@@ -2396,6 +2663,12 @@ Object.defineProperty(exports, "checkImageQuality", {
 		return checkImageQuality;
 	}
 });
+Object.defineProperty(exports, "checkRenderUsage", {
+	enumerable: true,
+	get: function() {
+		return checkRenderUsage;
+	}
+});
 Object.defineProperty(exports, "closeExportSelection", {
 	enumerable: true,
 	get: function() {
@@ -2438,6 +2711,12 @@ Object.defineProperty(exports, "deletedAnnotationsOf", {
 		return deletedAnnotationsOf;
 	}
 });
+Object.defineProperty(exports, "deletedOutlineItemsOf", {
+	enumerable: true,
+	get: function() {
+		return deletedOutlineItemsOf;
+	}
+});
 Object.defineProperty(exports, "dictEntries", {
 	enumerable: true,
 	get: function() {
@@ -2486,6 +2765,12 @@ Object.defineProperty(exports, "isKeptRefusal", {
 		return isKeptRefusal;
 	}
 });
+Object.defineProperty(exports, "mapOutlineItem", {
+	enumerable: true,
+	get: function() {
+		return mapOutlineItem;
+	}
+});
 Object.defineProperty(exports, "matchPageText", {
 	enumerable: true,
 	get: function() {
@@ -2552,6 +2837,18 @@ Object.defineProperty(exports, "pageListOf", {
 		return pageListOf;
 	}
 });
+Object.defineProperty(exports, "pageOutlineItemOf", {
+	enumerable: true,
+	get: function() {
+		return pageOutlineItemOf;
+	}
+});
+Object.defineProperty(exports, "pageOutlineOf", {
+	enumerable: true,
+	get: function() {
+		return pageOutlineOf;
+	}
+});
 Object.defineProperty(exports, "pageRotationOf", {
 	enumerable: true,
 	get: function() {
@@ -2582,6 +2879,18 @@ Object.defineProperty(exports, "pdfFormFieldDraftOf", {
 		return pdfFormFieldDraftOf;
 	}
 });
+Object.defineProperty(exports, "pdfOutlineDraftOf", {
+	enumerable: true,
+	get: function() {
+		return pdfOutlineDraftOf;
+	}
+});
+Object.defineProperty(exports, "pdfOutlinePatchOf", {
+	enumerable: true,
+	get: function() {
+		return pdfOutlinePatchOf;
+	}
+});
 Object.defineProperty(exports, "pdfRenderTargetOf", {
 	enumerable: true,
 	get: function() {
@@ -2612,12 +2921,24 @@ Object.defineProperty(exports, "primaryFinding", {
 		return primaryFinding;
 	}
 });
+Object.defineProperty(exports, "printDpiOf", {
+	enumerable: true,
+	get: function() {
+		return printDpiOf;
+	}
+});
 Object.defineProperty(exports, "refsOf", {
 	enumerable: true,
 	get: function() {
 		return refsOf;
 	}
 });
+Object.defineProperty(exports, "resolvePageExtract", {
+	enumerable: true,
+	get: function() {
+		return resolvePageExtract;
+	}
+});
 Object.defineProperty(exports, "resolvePageLayers", {
 	enumerable: true,
 	get: function() {
@@ -2673,4 +2994,4 @@ Object.defineProperty(exports, "worstVerdict", {
 	}
 });
 
-//# sourceMappingURL=authority-DLMNR7ff.cjs.map
+//# sourceMappingURL=authority-BFp6XM04.cjs.map