@embedpdf/core-geometry 3.0.0-next.0

package/LICENSE

@@ -0,0 +1,192 @@
+Copyright 2026 CloudPDF LTD
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use files in this distribution except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+-----------------------------------------------------------------------
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS

package/dist/index.cjs

@@ -0,0 +1,423 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/index.ts
+/**
+* The bounding box of a set of rects (null for the empty set). Space-
+* agnostic: works on any y-down `{x,y,width,height}` rects — search hit
+* bounds, selection line-merge unions, multi-quad annotation extents.
+*/
+function boundsOfRects(rects) {
+	if (rects.length === 0) return null;
+	let x1 = Infinity;
+	let y1 = Infinity;
+	let x2 = -Infinity;
+	let y2 = -Infinity;
+	for (const r of rects) {
+		x1 = Math.min(x1, r.x);
+		y1 = Math.min(y1, r.y);
+		x2 = Math.max(x2, r.x + r.width);
+		y2 = Math.max(y2, r.y + r.height);
+	}
+	return {
+		x: x1,
+		y: y1,
+		width: x2 - x1,
+		height: y2 - y1
+	};
+}
+/**
+* Intersection of two y-down rects — zero-sized (width/height 0, origin at
+* the would-be corner) when disjoint, so callers can test `width > 0`
+* without a null branch. Space-agnostic like {@link boundsOfRects}: view-px
+* viewport ∩ footprint, page-point visibility ∩ tile footprints, ….
+*/
+function intersectRects(a, b) {
+	const x = Math.max(a.x, b.x);
+	const y = Math.max(a.y, b.y);
+	return {
+		x,
+		y,
+		width: Math.max(0, Math.min(a.x + a.width, b.x + b.width) - x),
+		height: Math.max(0, Math.min(a.y + a.height, b.y + b.height) - y)
+	};
+}
+const NO_FRAME = {
+	top: 0,
+	right: 0,
+	bottom: 0,
+	left: 0
+};
+/** True for the quarter-turns that swap a page's width and height. */
+function isQuarterTurn(rotation) {
+	return rotation === 90 || rotation === 270;
+}
+/**
+* Compose two quarter-turn rotations (mod 360). THE way the shell resolves a
+* page's TOTAL display rotation — `addRotations(page /Rotate, view rotation)`
+* — so the wrap arithmetic is never hand-written (and drift) per call site.
+*/
+function addRotations(a, b) {
+	return (a + b) % 360;
+}
+/**
+* Snap a view-px value to the device pixel grid: round to a whole device pixel,
+* back to view px. Used for a page's screen POSITION so a CSS-rotated page lands
+* on the grid (no sub-pixel anti-aliased fringe). The shell never hand-rounds.
+*/
+function snapToDevice(value, dpr) {
+	return Math.round(value * dpr) / dpr;
+}
+/** A page's on-screen footprint: width and height swapped for quarter-turns. */
+function displaySize(content, rotation) {
+	return isQuarterTurn(rotation) ? {
+		width: content.height,
+		height: content.width
+	} : {
+		width: content.width,
+		height: content.height
+	};
+}
+/**
+* The engine's `kind:'width'` height rule, replicated EXACTLY so the viewer can
+* predict the rendered bitmap's height up front — the page box is sized to it,
+* so the box matches the bitmap with no reflow and no 1px seam.
+*
+* Mirrors `PageRenderReader.resolveDeviceSize` (engine-services): we render the
+* page UN-rotated (CSS applies the rotation), so there is no width/height swap
+* here — `pageSize` is the page's own points. MUST stay in lockstep with that
+* function; the round-trip test in the render plugin asserts they agree.
+*/
+function deviceHeightForWidth(pageSize, deviceWidth) {
+	return Math.max(1, Math.round(deviceWidth * pageSize.height / pageSize.width));
+}
+/**
+* Build a page's transform from its intrinsic size + the platform/view scale.
+* `scale` is VIEW px per PDF point (the shell composes it: `viewUnitsPerPoint ×
+* contentScale × zoom`); `dpr` is device px per view px. Device dimensions snap
+* to the grid (crisp, no rotation fringe) and follow the engine's width rule
+* (box == bitmap, no reflow).
+*/
+function pageTransform(input) {
+	const { pageSize, rotation, scale, dpr } = input;
+	const deviceWidth = Math.max(1, Math.round(pageSize.width * scale * dpr));
+	const deviceHeight = deviceHeightForWidth(pageSize, deviceWidth);
+	const renderScale = deviceWidth / pageSize.width;
+	const content = {
+		width: deviceWidth / dpr,
+		height: deviceHeight / dpr
+	};
+	const viewScale = content.width / pageSize.width;
+	const baseScale = input.baseScale ?? scale;
+	const zoom = baseScale > 0 ? viewScale / baseScale : 1;
+	const footprint = displaySize(content, rotation);
+	const contentMat = [
+		viewScale,
+		0,
+		0,
+		viewScale,
+		0,
+		0
+	];
+	const viewMat = rotateScaleMatrix(viewScale, content.width, content.height, rotation);
+	const invMat = invert(viewMat);
+	const pageToContent = (p) => applyPoint(contentMat, p);
+	const pageToView = (p) => applyPoint(viewMat, p);
+	const viewToPage = (p) => applyPoint(invMat, p);
+	const pageToViewRect = (r) => applyRect(viewMat, r);
+	const viewToPageRect = (r) => applyRect(invMat, r);
+	const cssMatrix = matrixToCss(viewMat);
+	return {
+		rotation,
+		viewWidth: footprint.width,
+		viewHeight: footprint.height,
+		contentWidth: content.width,
+		contentHeight: content.height,
+		deviceWidth,
+		deviceHeight,
+		renderScale,
+		viewScale,
+		baseScale,
+		zoom,
+		pageToContent,
+		pageToView,
+		pageToViewRect,
+		viewToPage,
+		viewToPageRect,
+		cssMatrix
+	};
+}
+/** The identity transform within a single space. */
+function identity() {
+	return [
+		1,
+		0,
+		0,
+		1,
+		0,
+		0
+	];
+}
+/**
+* Compose two matrices: `compose(m, n)` applies `n` first, then `m` (matrix
+* product `m · n`). The shared middle space `B` must line up, so the type system
+* rejects composing mismatched hops.
+*/
+function compose(m, n) {
+	const [a, b, c, d, e, f] = m;
+	const [a2, b2, c2, d2, e2, f2] = n;
+	return [
+		a * a2 + c * b2,
+		b * a2 + d * b2,
+		a * c2 + c * d2,
+		b * c2 + d * d2,
+		a * e2 + c * f2 + e,
+		b * e2 + d * f2 + f
+	];
+}
+/** Invert a transform — `invert(pdfToView)` is `viewToPdf`, i.e. hit-testing for free. */
+function invert(m) {
+	const [a, b, c, d, e, f] = m;
+	const det = a * d - b * c;
+	if (det === 0) throw new Error("Mat2D.invert: non-invertible matrix (det = 0)");
+	const ia = d / det;
+	const ib = -b / det;
+	const ic = -c / det;
+	const id = a / det;
+	return [
+		ia,
+		ib,
+		ic,
+		id,
+		-(ia * e + ic * f),
+		-(ib * e + id * f)
+	];
+}
+/** Apply a transform to a point. */
+function applyPoint(m, p) {
+	const [a, b, c, d, e, f] = m;
+	return {
+		x: a * p.x + c * p.y + e,
+		y: b * p.x + d * p.y + f
+	};
+}
+/**
+* Apply a transform to a rect, returning the axis-aligned bounding box of the
+* four transformed corners. EXACT for translate/scale/quarter-turn (every page
+* transform `pageGeometry` produces); lossy under skew — use {@link applyQuad}
+* for content that can be rotated off-axis.
+*/
+function applyRect(m, r) {
+	const c0 = applyPoint(m, {
+		x: r.x,
+		y: r.y
+	});
+	const c1 = applyPoint(m, {
+		x: r.x + r.width,
+		y: r.y
+	});
+	const c2 = applyPoint(m, {
+		x: r.x,
+		y: r.y + r.height
+	});
+	const c3 = applyPoint(m, {
+		x: r.x + r.width,
+		y: r.y + r.height
+	});
+	const xs = [
+		c0.x,
+		c1.x,
+		c2.x,
+		c3.x
+	];
+	const ys = [
+		c0.y,
+		c1.y,
+		c2.y,
+		c3.y
+	];
+	const minX = Math.min(...xs);
+	const minY = Math.min(...ys);
+	return {
+		x: minX,
+		y: minY,
+		width: Math.max(...xs) - minX,
+		height: Math.max(...ys) - minY
+	};
+}
+/** Apply a transform to a quad, preserving orientation (maps the four points). */
+function applyQuad(m, q) {
+	return {
+		p1: applyPoint(m, q.p1),
+		p2: applyPoint(m, q.p2),
+		p3: applyPoint(m, q.p3),
+		p4: applyPoint(m, q.p4)
+	};
+}
+/**
+* A `Mat2D` IS a CSS `matrix()` — the six numbers are identical. Drop the result
+* on a footprint-space layer (`transform`, `transform-origin: 0 0`) and place
+* children in the source space; the rotation + scale are handled for free.
+*/
+function matrixToCss(m) {
+	const [a, b, c, d, e, f] = m;
+	return `matrix(${a}, ${b}, ${c}, ${d}, ${e}, ${f})`;
+}
+/** Translate within a space. */
+function translate(tx, ty) {
+	return [
+		1,
+		0,
+		0,
+		1,
+		tx,
+		ty
+	];
+}
+/** Scale about the space origin. */
+function scale(sx, sy) {
+	return [
+		sx,
+		0,
+		0,
+		sy,
+		0,
+		0
+	];
+}
+/** Rotate about the space origin (radians; clockwise in y-down content space). */
+function rotate(rad) {
+	const c = Math.cos(rad);
+	const s = Math.sin(rad);
+	return [
+		c,
+		s,
+		-s,
+		c,
+		0,
+		0
+	];
+}
+/** Rotate about an arbitrary pivot: `T(c) · R(rad) · T(-c)`. */
+function rotateAbout(c, rad) {
+	return compose(translate(c.x, c.y), compose(rotate(rad), translate(-c.x, -c.y)));
+}
+/** Scale about an arbitrary anchor: `T(a) · S(sx, sy) · T(-a)`. */
+function scaleAbout(a, sx, sy) {
+	return compose(translate(a.x, a.y), compose(scale(sx, sy), translate(-a.x, -a.y)));
+}
+/** The rotation angle (radians) encoded in a matrix — `atan2(b, a)`. Positive is
+*  clockwise in y-down content space (the inverse of {@link rotate}). */
+function angleOf(m) {
+	return Math.atan2(m[1], m[0]);
+}
+/**
+* The page's scale + integer quarter-turn as a `Mat2D`: a content point maps to
+* its place in the rotated DISPLAY box. `scale` is output units per content
+* point; `boxW`/`boxH` are the UN-rotated content's extents in those same output
+* units, and the offsets keep the footprint in the box's positive quadrant
+* (origin at the box top-left).
+*
+* THE single encoding of the quarter-turn — `pageTransform` (view px),
+* `pageGeometry` (the `content→view` hop), and `pageToWorld` (world units) all
+* build on this one function, so the rotation can never drift between them.
+*/
+function rotateScaleMatrix(scale, boxW, boxH, rotation) {
+	switch (rotation) {
+		case 90: return [
+			0,
+			scale,
+			-scale,
+			0,
+			boxH,
+			0
+		];
+		case 180: return [
+			-scale,
+			0,
+			0,
+			-scale,
+			boxW,
+			boxH
+		];
+		case 270: return [
+			0,
+			-scale,
+			scale,
+			0,
+			0,
+			boxW
+		];
+		default: return [
+			scale,
+			0,
+			0,
+			scale,
+			0,
+			0
+		];
+	}
+}
+/**
+* PDF user space (y-up, origin = crop bottom-left) → content space (y-down,
+* origin = crop top-left, unscaled points). THE single encoding of the engine→
+* content y-flip + crop offset: `pageGeometry` composes its `pdfToContent` from
+* this, and pure annotation geometry (content-space editing) reuses it too, so
+* the rule can never be hand-written twice and drift.
+*/
+function pdfToContentMatrix(crop) {
+	return [
+		1,
+		0,
+		0,
+		-1,
+		-crop.left,
+		crop.top
+	];
+}
+/**
+* Build a page's space matrices from its crop box, rotation, and `userUnit` plus
+* the viewer `zoom`. This is the ONE function that knows the y-flip, crop origin,
+* `userUnit`, and rotation; everything else composes from its output. The engine
+* never emits these — they bake in viewer state (zoom, later scroll/dpr) — so the
+* boundary stays clean: engine owns `Pdf*` truth, the viewer composes the rest.
+*/
+function pageGeometry(input, zoom) {
+	const { crop, rotation, userUnit } = input;
+	const s = zoom * userUnit;
+	const pdfToContent = pdfToContentMatrix(crop);
+	const contentToView = rotateScaleMatrix(s, (crop.right - crop.left) * s, (crop.top - crop.bottom) * s, rotation);
+	const pdfToView = compose(contentToView, pdfToContent);
+	return {
+		pdfToContent,
+		contentToView,
+		pdfToView,
+		viewToPdf: invert(pdfToView)
+	};
+}
+//#endregion
+exports.NO_FRAME = NO_FRAME;
+exports.addRotations = addRotations;
+exports.angleOf = angleOf;
+exports.applyPoint = applyPoint;
+exports.applyQuad = applyQuad;
+exports.applyRect = applyRect;
+exports.boundsOfRects = boundsOfRects;
+exports.compose = compose;
+exports.deviceHeightForWidth = deviceHeightForWidth;
+exports.displaySize = displaySize;
+exports.identity = identity;
+exports.intersectRects = intersectRects;
+exports.invert = invert;
+exports.isQuarterTurn = isQuarterTurn;
+exports.matrixToCss = matrixToCss;
+exports.pageGeometry = pageGeometry;
+exports.pageTransform = pageTransform;
+exports.pdfToContentMatrix = pdfToContentMatrix;
+exports.rotate = rotate;
+exports.rotateAbout = rotateAbout;
+exports.rotateScaleMatrix = rotateScaleMatrix;
+exports.scale = scale;
+exports.scaleAbout = scaleAbout;
+exports.snapToDevice = snapToDevice;
+exports.translate = translate;
+
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["/**\n * @embedpdf/core-geometry — the viewer's pure 2D coordinate primitives.\n *\n * The bottom of the pyramid: stage-core (layout), plugin-stage (`pageToWorld`),\n * and every framework adapter (`toPagePoint` hit-testing) all sit on these.\n * Zero dependencies, DOM-free, serializable — Rust-portable.\n *\n * The page-rotation transforms are the reason this package exists: the same\n * quarter-turn maps content↔box in BOTH directions, and that one rule must not\n * be hand-written (and drift, or be bug-fixed in only one of four adapters).\n */\n\nexport interface Point {\n  x: number;\n  y: number;\n}\nexport interface Size {\n  width: number;\n  height: number;\n}\n/** Viewer-side rect: top-left origin, y-down (view/page-point convention — NOT the\n *  engine's bottom-left PDF rect). */\nexport interface Rect {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/**\n * The bounding box of a set of rects (null for the empty set). Space-\n * agnostic: works on any y-down `{x,y,width,height}` rects — search hit\n * bounds, selection line-merge unions, multi-quad annotation extents.\n */\nexport function boundsOfRects(rects: readonly Rect[]): Rect | null {\n  if (rects.length === 0) return null;\n  let x1 = Infinity;\n  let y1 = Infinity;\n  let x2 = -Infinity;\n  let y2 = -Infinity;\n  for (const r of rects) {\n    x1 = Math.min(x1, r.x);\n    y1 = Math.min(y1, r.y);\n    x2 = Math.max(x2, r.x + r.width);\n    y2 = Math.max(y2, r.y + r.height);\n  }\n  return { x: x1, y: y1, width: x2 - x1, height: y2 - y1 };\n}\n\n/**\n * Intersection of two y-down rects — zero-sized (width/height 0, origin at\n * the would-be corner) when disjoint, so callers can test `width > 0`\n * without a null branch. Space-agnostic like {@link boundsOfRects}: view-px\n * viewport ∩ footprint, page-point visibility ∩ tile footprints, ….\n */\nexport function intersectRects(a: Rect, b: Rect): Rect {\n  const x = Math.max(a.x, b.x);\n  const y = Math.max(a.y, b.y);\n  return {\n    x,\n    y,\n    width: Math.max(0, Math.min(a.x + a.width, b.x + b.width) - x),\n    height: Math.max(0, Math.min(a.y + a.height, b.y + b.height) - y),\n  };\n}\n\n/**\n * Quarter-turn display rotation, degrees clockwise. The viewer-side notion of a\n * page's on-screen rotation — the TOTAL = (document /Rotate + any view\n * rotation), resolved by the shell. Structurally identical to the engine's\n * `PageRotation`, so the two interoperate without this package depending on the\n * engine.\n */\nexport type PageRotation = 0 | 90 | 180 | 270;\n\n/**\n * Reserved chrome real estate around a page, one thickness per side (screen px\n * in the shell; world units in the pure layout). The page content sits inset\n * by these; the bands hold box-space chrome (labels, buttons, rails) that does\n * not rotate. The layout reserves the matching space so nothing overlaps.\n */\nexport interface PageFrame {\n  top: number;\n  right: number;\n  bottom: number;\n  left: number;\n}\nexport const NO_FRAME: PageFrame = { top: 0, right: 0, bottom: 0, left: 0 };\n\n/** True for the quarter-turns that swap a page's width and height. */\nexport function isQuarterTurn(rotation: PageRotation): boolean {\n  return rotation === 90 || rotation === 270;\n}\n\n/**\n * Compose two quarter-turn rotations (mod 360). THE way the shell resolves a\n * page's TOTAL display rotation — `addRotations(page /Rotate, view rotation)`\n * — so the wrap arithmetic is never hand-written (and drift) per call site.\n */\nexport function addRotations(a: PageRotation, b: PageRotation): PageRotation {\n  return ((a + b) % 360) as PageRotation;\n}\n\n/**\n * Snap a view-px value to the device pixel grid: round to a whole device pixel,\n * back to view px. Used for a page's screen POSITION so a CSS-rotated page lands\n * on the grid (no sub-pixel anti-aliased fringe). The shell never hand-rounds.\n */\nexport function snapToDevice(value: number, dpr: number): number {\n  return Math.round(value * dpr) / dpr;\n}\n\n/** A page's on-screen footprint: width and height swapped for quarter-turns. */\nexport function displaySize(content: Size, rotation: PageRotation): Size {\n  return isQuarterTurn(rotation)\n    ? { width: content.height, height: content.width }\n    : { width: content.width, height: content.height };\n}\n\n/**\n * The engine's `kind:'width'` height rule, replicated EXACTLY so the viewer can\n * predict the rendered bitmap's height up front — the page box is sized to it,\n * so the box matches the bitmap with no reflow and no 1px seam.\n *\n * Mirrors `PageRenderReader.resolveDeviceSize` (engine-services): we render the\n * page UN-rotated (CSS applies the rotation), so there is no width/height swap\n * here — `pageSize` is the page's own points. MUST stay in lockstep with that\n * function; the round-trip test in the render plugin asserts they agree.\n */\nexport function deviceHeightForWidth(pageSize: Size, deviceWidth: number): number {\n  return Math.max(1, Math.round((deviceWidth * pageSize.height) / pageSize.width));\n}\n\n/**\n * The single per-page bridge between the viewer's three coordinate spaces. NB:\n * these are all VIEWER spaces — top-left origin, y-down. They are NOT the\n * engine's PDF user space (`Pdf*`, bottom-left origin, y-up); the engine→content\n * hop (the y-flip + crop offset) is a separate matrix (`pageGeometry`).\n *\n *   content space  page-local points, top-left, y-down — un-rotated page frame\n *   view space     platform logical px (web: CSS px) — layout, DOM, pointer events\n *   device space   physical pixels — the rendered bitmap\n *\n * PAGE-LOCAL by design: it knows this page's own box, NOT where the page sits in\n * the scene. Placement (camera/layout) stays on `VisiblePage.{x,y}` and positions\n * the page container; the transform converts everything INSIDE that container. So\n * it is camera/pan-invariant — it only changes on zoom / rotation / contentScale\n * / dpr, which makes it cheap to memoize.\n *\n * Every plugin and framework adapter consumes THIS — never `x * scale`, never\n * `pageToWorld()∘toScreen()`, never `* dpr`. New plugins (annotations, search,\n * forms) do no coordinate math; new platforms (iOS/Android) inject a different\n * `scale` and reuse all of it.\n */\nexport interface PageTransform {\n  /**\n   * The page's TOTAL display rotation (document /Rotate + any view rotation) —\n   * the same value the transform's matrices were built from, exposed so\n   * consumers that need the quarter-turn itself (an upright-placement rule, a\n   * pointer sample) read it HERE instead of re-deriving it from the matrix.\n   */\n  readonly rotation: PageRotation;\n  /** Display footprint in VIEW px (device-snapped) — the page container's size.\n   *  Width↔height already swapped for quarter-turns. */\n  readonly viewWidth: number;\n  readonly viewHeight: number;\n  /** The UN-rotated content box in VIEW px — the size of the wrapper the bitmap\n   *  and content-space overlays live in (before the wrapper's CSS rotation). */\n  readonly contentWidth: number;\n  readonly contentHeight: number;\n  /** Render the (un-rotated) bitmap at EXACTLY this — `viewport: {kind:'width', width: deviceWidth}`.\n   *  Integer device px; `deviceHeight` is the engine's exact derived height. */\n  readonly deviceWidth: number;\n  readonly deviceHeight: number;\n  /** Device px per PDF point (uniform). */\n  readonly renderScale: number;\n  /** VIEW px per PDF point (uniform, device-snapped) — the one factor for\n   *  screen-constant chrome: content units = CSS px ÷ `viewScale`. */\n  readonly viewScale: number;\n  /**\n   * View px per PDF point at 100% ZOOM — the page's physical baseline:\n   * `viewUnitsPerPoint × userUnit` (web: 96/72 × `/UserUnit`, so 100% maps to\n   * inches on screen, Acrobat-style). What \"100%\" MEANS for this page.\n   */\n  readonly baseScale: number;\n  /**\n   * The page's zoom RELATIVE to its 100% baseline (`viewScale / baseScale`,\n   * dimensionless; exactly 1 at 100% for any `userUnit`). THE number\n   * zoom-relative policies consume — e.g. the `/F` NoZoom exemption clamps\n   * its body to `zoom ≤ 1`. Distinct from `viewScale` (a units conversion).\n   */\n  readonly zoom: number;\n  /** Content point → UN-rotated content view px. For overlays INSIDE the rotated\n   *  content wrapper (markers, annotations) — they ride the wrapper's rotation,\n   *  so they place in content space and only scale here. */\n  pageToContent(p: Point): Point;\n  /** Content point → page-local view px in the DISPLAY box (rotation applied). For\n   *  footprint-space layers (outside the wrapper). */\n  pageToView(p: Point): Point;\n  /** Content rect → its axis-aligned view-px rect (exact for quarter-turns). */\n  pageToViewRect(r: Rect): Rect;\n  /** Inverse — display-box view px (box-local) → content point. Hit-testing. */\n  viewToPage(p: Point): Point;\n  /** Inverse of {@link pageToViewRect}: display-box view-px rect → its content\n   *  AABB (exact for quarter-turns). The visibility primitive — projecting a\n   *  viewport rect into page points is THIS, never per-adapter corner math. */\n  viewToPageRect(r: Rect): Rect;\n  /** CSS `matrix()` mapping content space → this page's display box. Drop it on\n   *  a footprint-space layer (`transform`, `transform-origin: 0 0`) and place\n   *  children in content points — rotation + scale handled for free. */\n  readonly cssMatrix: string;\n}\n\n/**\n * Build a page's transform from its intrinsic size + the platform/view scale.\n * `scale` is VIEW px per PDF point (the shell composes it: `viewUnitsPerPoint ×\n * contentScale × zoom`); `dpr` is device px per view px. Device dimensions snap\n * to the grid (crisp, no rotation fringe) and follow the engine's width rule\n * (box == bitmap, no reflow).\n */\nexport function pageTransform(input: {\n  /** Un-rotated page size in PDF points. */\n  pageSize: Size;\n  rotation: PageRotation;\n  /** View px per PDF point = viewUnitsPerPoint × contentScale × zoom. */\n  scale: number;\n  /**\n   * View px per PDF point at 100% zoom (`viewUnitsPerPoint × userUnit`) — the\n   * page's physical baseline, so `zoom = viewScale / baseScale` reads as\n   * \"percent of Acrobat's 100%\". Default = `scale`, i.e. zoom ≈ 1: headless /\n   * standalone callers stay neutral unless they declare a baseline.\n   */\n  baseScale?: number;\n  /** Device px per view px (web: devicePixelRatio). */\n  dpr: number;\n}): PageTransform {\n  const { pageSize, rotation, scale, dpr } = input;\n\n  // Raster: pin the width (snapped to the device grid), derive the height with\n  // the engine's exact rule → uniform scale, integer device px, box == bitmap.\n  const deviceWidth = Math.max(1, Math.round(pageSize.width * scale * dpr));\n  const deviceHeight = deviceHeightForWidth(pageSize, deviceWidth);\n  const renderScale = deviceWidth / pageSize.width;\n\n  // The un-rotated content box in VIEW px, taken from the snapped device dims so\n  // every edge lands on a whole device pixel. The effective view scale is derived\n  // from it (not the raw `scale`) so `pageToView(pageWidth) === content edge`.\n  const content: Size = { width: deviceWidth / dpr, height: deviceHeight / dpr };\n  const viewScale = content.width / pageSize.width;\n  const baseScale = input.baseScale ?? scale;\n  const zoom = baseScale > 0 ? viewScale / baseScale : 1;\n\n  const footprint = displaySize(content, rotation);\n\n  // The two affines this page needs, as Mat2D — the matrix is the source of\n  // truth; the methods and `cssMatrix` below are sugar over it (so they can\n  // never drift).\n  // content point (top-left, y-down) → content view px: pure isotropic scale.\n  const contentMat = [viewScale, 0, 0, viewScale, 0, 0] as Mat2D;\n  // content point → display-box view px: scale + the page's quarter-turn, from\n  // the shared builder (the one quarter-turn encoding).\n  const viewMat = rotateScaleMatrix(viewScale, content.width, content.height, rotation);\n  const invMat = invert(viewMat);\n\n  const pageToContent = (p: Point): Point => applyPoint(contentMat, p);\n  const pageToView = (p: Point): Point => applyPoint(viewMat, p);\n  const viewToPage = (p: Point): Point => applyPoint(invMat, p);\n  const pageToViewRect = (r: Rect): Rect => applyRect(viewMat, r);\n  const viewToPageRect = (r: Rect): Rect => applyRect(invMat, r);\n  const cssMatrix = matrixToCss(viewMat);\n\n  return {\n    rotation,\n    viewWidth: footprint.width,\n    viewHeight: footprint.height,\n    contentWidth: content.width,\n    contentHeight: content.height,\n    deviceWidth,\n    deviceHeight,\n    renderScale,\n    viewScale,\n    baseScale,\n    zoom,\n    pageToContent,\n    pageToView,\n    pageToViewRect,\n    viewToPage,\n    viewToPageRect,\n    cssMatrix,\n  };\n}\n\n/* ────────────────────────────────────────────────────────────────────────────\n * Matrix-native geometry — the composable primitive under every space hop.\n *\n * A coordinate-space conversion is a 2D affine `Mat2D = [a,b,c,d,e,f]` (the same\n * six numbers as CSS `matrix()`, `CGAffineTransform`, and Android `Matrix`):\n *\n *     x' = a·x + c·y + e\n *     y' = b·x + d·y + f\n *\n * Three generic appliers + `compose` + `invert` are the ENTIRE runtime — they\n * never grow as spaces/shapes/directions multiply, and they port 1:1 to Rust /\n * Swift / Kotlin (every target has a native affine). Inverses (hit-testing) and\n * screen composition fall out for free; there is no per-space hand-rolled y-flip\n * to drift between adapters.\n * ──────────────────────────────────────────────────────────────────────────── */\n\n/**\n * The coordinate spaces a viewer touches. `pdf` is the engine's PDF user space\n * (y-up, origin at the crop box bottom-left); the rest are viewer-local, y-down.\n */\nexport type Space = 'pdf' | 'content' | 'view' | 'screen';\n\n/**\n * Phantom space brand. It is OPTIONAL so plain `{ x, y }` / `{ x, y, w, h }`\n * literals stay assignable day-to-day (terse), but a value EXPLICITLY tagged\n * with the wrong space is rejected — and `Mat2D<From, To>` enforces the hop at\n * the matrix, so you cannot `applyRect` a `pdf` rect with a `content→view`\n * matrix. The brand is type-only; it carries no runtime field.\n */\ninterface SpaceBrand<S extends Space> {\n  readonly __space?: S;\n}\n\n/** A point tagged with its coordinate space. */\nexport type PointIn<S extends Space> = Point & SpaceBrand<S>;\n/**\n * An axis-aligned rect tagged with its space, as min-corner + positive extent:\n * `(x, y)` is the corner with the smallest coordinates and `(x+width, y+height)`\n * the largest. In `pdf` space (y-up) that corner is bottom-left (`x=left`,\n * `y=bottom`); in the y-down viewer spaces it is top-left.\n */\nexport type RectIn<S extends Space> = Rect & SpaceBrand<S>;\n\n/**\n * Four POSITIONAL points (no corner semantics) — the viewer twin of the engine's\n * `PdfQuad`. Use this (via {@link applyQuad}) for rotatable/skewed content where\n * an axis-aligned rect would lie.\n */\nexport interface Quad {\n  p1: Point;\n  p2: Point;\n  p3: Point;\n  p4: Point;\n}\n/** A quad tagged with its coordinate space. */\nexport type QuadIn<S extends Space> = Quad & SpaceBrand<S>;\n\n/**\n * A 2D affine transform from space `From` to space `To`, stored as the six\n * numbers `[a, b, c, d, e, f]`. The phantom `From`/`To` make the compiler track\n * which spaces a matrix bridges, so composition and application can only be\n * wired up in the one correct order.\n */\nexport type Mat2D<From extends Space = Space, To extends Space = Space> = readonly [\n  number,\n  number,\n  number,\n  number,\n  number,\n  number,\n] & {\n  readonly __from?: From;\n  readonly __to?: To;\n};\n\n/** The identity transform within a single space. */\nexport function identity<S extends Space>(): Mat2D<S, S> {\n  return [1, 0, 0, 1, 0, 0] as Mat2D<S, S>;\n}\n\n/**\n * Compose two matrices: `compose(m, n)` applies `n` first, then `m` (matrix\n * product `m · n`). The shared middle space `B` must line up, so the type system\n * rejects composing mismatched hops.\n */\nexport function compose<A extends Space, B extends Space, C extends Space>(\n  m: Mat2D<B, C>,\n  n: Mat2D<A, B>,\n): Mat2D<A, C> {\n  const [a, b, c, d, e, f] = m;\n  const [a2, b2, c2, d2, e2, f2] = n;\n  return [\n    a * a2 + c * b2,\n    b * a2 + d * b2,\n    a * c2 + c * d2,\n    b * c2 + d * d2,\n    a * e2 + c * f2 + e,\n    b * e2 + d * f2 + f,\n  ] as Mat2D<A, C>;\n}\n\n/** Invert a transform — `invert(pdfToView)` is `viewToPdf`, i.e. hit-testing for free. */\nexport function invert<F extends Space, T extends Space>(m: Mat2D<F, T>): Mat2D<T, F> {\n  const [a, b, c, d, e, f] = m;\n  const det = a * d - b * c;\n  if (det === 0) throw new Error('Mat2D.invert: non-invertible matrix (det = 0)');\n  const ia = d / det;\n  const ib = -b / det;\n  const ic = -c / det;\n  const id = a / det;\n  return [ia, ib, ic, id, -(ia * e + ic * f), -(ib * e + id * f)] as Mat2D<T, F>;\n}\n\n/** Apply a transform to a point. */\nexport function applyPoint<F extends Space, T extends Space>(\n  m: Mat2D<F, T>,\n  p: PointIn<F>,\n): PointIn<T> {\n  const [a, b, c, d, e, f] = m;\n  return { x: a * p.x + c * p.y + e, y: b * p.x + d * p.y + f } as PointIn<T>;\n}\n\n/**\n * Apply a transform to a rect, returning the axis-aligned bounding box of the\n * four transformed corners. EXACT for translate/scale/quarter-turn (every page\n * transform `pageGeometry` produces); lossy under skew — use {@link applyQuad}\n * for content that can be rotated off-axis.\n */\nexport function applyRect<F extends Space, T extends Space>(\n  m: Mat2D<F, T>,\n  r: RectIn<F>,\n): RectIn<T> {\n  const c0 = applyPoint(m, { x: r.x, y: r.y } as PointIn<F>);\n  const c1 = applyPoint(m, { x: r.x + r.width, y: r.y } as PointIn<F>);\n  const c2 = applyPoint(m, { x: r.x, y: r.y + r.height } as PointIn<F>);\n  const c3 = applyPoint(m, { x: r.x + r.width, y: r.y + r.height } as PointIn<F>);\n  const xs = [c0.x, c1.x, c2.x, c3.x];\n  const ys = [c0.y, c1.y, c2.y, c3.y];\n  const minX = Math.min(...xs);\n  const minY = Math.min(...ys);\n  return {\n    x: minX,\n    y: minY,\n    width: Math.max(...xs) - minX,\n    height: Math.max(...ys) - minY,\n  } as RectIn<T>;\n}\n\n/** Apply a transform to a quad, preserving orientation (maps the four points). */\nexport function applyQuad<F extends Space, T extends Space>(\n  m: Mat2D<F, T>,\n  q: QuadIn<F>,\n): QuadIn<T> {\n  return {\n    p1: applyPoint(m, q.p1 as PointIn<F>),\n    p2: applyPoint(m, q.p2 as PointIn<F>),\n    p3: applyPoint(m, q.p3 as PointIn<F>),\n    p4: applyPoint(m, q.p4 as PointIn<F>),\n  } as QuadIn<T>;\n}\n\n/**\n * A `Mat2D` IS a CSS `matrix()` — the six numbers are identical. Drop the result\n * on a footprint-space layer (`transform`, `transform-origin: 0 0`) and place\n * children in the source space; the rotation + scale are handled for free.\n */\nexport function matrixToCss(m: Mat2D): string {\n  const [a, b, c, d, e, f] = m;\n  return `matrix(${a}, ${b}, ${c}, ${d}, ${e}, ${f})`;\n}\n\n/* ────────────────────────────────────────────────────────────────────────────\n * Same-space affine builders — generic, free-angle transforms WITHIN one space\n * (`Mat2D<S, S>`). The `rotateScaleMatrix` above is a quarter-turn, cross-space\n * builder for page layout; these are the arbitrary-angle primitives content\n * editing (annotation rotation/scale, future stamps/skew) composes from. They\n * never know about annotations — they are the bottom-of-the-pyramid matrix math,\n * so it isn't hand-rolled (and drift) in every plugin.\n *\n * Convention: a viewer content space is y-DOWN, so `rotate(rad)` —\n * `[cos, sin, -sin, cos, 0, 0]` — turns CLOCKWISE on screen (matching the\n * viewer's page-rotation direction). The PDF (y-up) flip, when one is needed,\n * is a separate hop applied once at the engine boundary.\n * ──────────────────────────────────────────────────────────────────────────── */\n\n/** Translate within a space. */\nexport function translate<S extends Space>(tx: number, ty: number): Mat2D<S, S> {\n  return [1, 0, 0, 1, tx, ty] as Mat2D<S, S>;\n}\n\n/** Scale about the space origin. */\nexport function scale<S extends Space>(sx: number, sy: number): Mat2D<S, S> {\n  return [sx, 0, 0, sy, 0, 0] as Mat2D<S, S>;\n}\n\n/** Rotate about the space origin (radians; clockwise in y-down content space). */\nexport function rotate<S extends Space>(rad: number): Mat2D<S, S> {\n  const c = Math.cos(rad);\n  const s = Math.sin(rad);\n  return [c, s, -s, c, 0, 0] as Mat2D<S, S>;\n}\n\n/** Rotate about an arbitrary pivot: `T(c) · R(rad) · T(-c)`. */\nexport function rotateAbout<S extends Space>(c: PointIn<S>, rad: number): Mat2D<S, S> {\n  return compose(translate<S>(c.x, c.y), compose(rotate<S>(rad), translate<S>(-c.x, -c.y)));\n}\n\n/** Scale about an arbitrary anchor: `T(a) · S(sx, sy) · T(-a)`. */\nexport function scaleAbout<S extends Space>(a: PointIn<S>, sx: number, sy: number): Mat2D<S, S> {\n  return compose(translate<S>(a.x, a.y), compose(scale<S>(sx, sy), translate<S>(-a.x, -a.y)));\n}\n\n/** The rotation angle (radians) encoded in a matrix — `atan2(b, a)`. Positive is\n *  clockwise in y-down content space (the inverse of {@link rotate}). */\nexport function angleOf(m: Mat2D): number {\n  return Math.atan2(m[1], m[0]);\n}\n\n/**\n * The page's scale + integer quarter-turn as a `Mat2D`: a content point maps to\n * its place in the rotated DISPLAY box. `scale` is output units per content\n * point; `boxW`/`boxH` are the UN-rotated content's extents in those same output\n * units, and the offsets keep the footprint in the box's positive quadrant\n * (origin at the box top-left).\n *\n * THE single encoding of the quarter-turn — `pageTransform` (view px),\n * `pageGeometry` (the `content→view` hop), and `pageToWorld` (world units) all\n * build on this one function, so the rotation can never drift between them.\n */\nexport function rotateScaleMatrix(\n  scale: number,\n  boxW: number,\n  boxH: number,\n  rotation: PageRotation,\n): Mat2D {\n  switch (rotation) {\n    case 90:\n      return [0, scale, -scale, 0, boxH, 0] as Mat2D;\n    case 180:\n      return [-scale, 0, 0, -scale, boxW, boxH] as Mat2D;\n    case 270:\n      return [0, -scale, scale, 0, 0, boxW] as Mat2D;\n    default:\n      return [scale, 0, 0, scale, 0, 0] as Mat2D;\n  }\n}\n\n/**\n * The per-page geometry input. Structurally a subset of the engine's\n * `PageLayout` (so a layout can be passed straight in), but defined here to keep\n * this package dependency-free — the same reason {@link PageRotation} is a\n * structural twin of the engine's rotation.\n */\nexport interface PageGeometryInput {\n  /** Effective crop box in PDF user space (y-up edges); origin preserved, so\n   *  `left`/`bottom` may be non-zero or negative. */\n  crop: { left: number; bottom: number; right: number; top: number };\n  /** Persistent page rotation (the document's `/Rotate`). */\n  rotation: PageRotation;\n  /** PDF `userUnit` (§14.11.6): scales PDF points into the layout. 1 for most docs. */\n  userUnit: number;\n}\n\n/** The matrices bridging one page's spaces — every other matrix composes from these. */\nexport interface PageGeometry {\n  /** PDF user space (y-up, crop-relative) → content space (y-down, crop top-left, unscaled points). */\n  readonly pdfToContent: Mat2D<'pdf', 'content'>;\n  /** Content → view: scale (zoom × userUnit) + the page's quarter-turn rotation. */\n  readonly contentToView: Mat2D<'content', 'view'>;\n  /** PDF → view, precomposed. */\n  readonly pdfToView: Mat2D<'pdf', 'view'>;\n  /** View → PDF, the inverse — hit-testing for free. */\n  readonly viewToPdf: Mat2D<'view', 'pdf'>;\n}\n\n/**\n * PDF user space (y-up, origin = crop bottom-left) → content space (y-down,\n * origin = crop top-left, unscaled points). THE single encoding of the engine→\n * content y-flip + crop offset: `pageGeometry` composes its `pdfToContent` from\n * this, and pure annotation geometry (content-space editing) reuses it too, so\n * the rule can never be hand-written twice and drift.\n */\nexport function pdfToContentMatrix(crop: { left: number; top: number }): Mat2D<'pdf', 'content'> {\n  return [1, 0, 0, -1, -crop.left, crop.top] as Mat2D<'pdf', 'content'>;\n}\n\n/**\n * Build a page's space matrices from its crop box, rotation, and `userUnit` plus\n * the viewer `zoom`. This is the ONE function that knows the y-flip, crop origin,\n * `userUnit`, and rotation; everything else composes from its output. The engine\n * never emits these — they bake in viewer state (zoom, later scroll/dpr) — so the\n * boundary stays clean: engine owns `Pdf*` truth, the viewer composes the rest.\n */\nexport function pageGeometry(input: PageGeometryInput, zoom: number): PageGeometry {\n  const { crop, rotation, userUnit } = input;\n  const s = zoom * userUnit; // view px per PDF point — userUnit folded in HERE, once\n\n  // PDF user space (y-up, origin = crop bottom-left) → content (y-down, origin = crop top-left).\n  const pdfToContent = pdfToContentMatrix(crop);\n\n  // Content → view: scale + integer quarter-turn, from the shared builder (the\n  // one quarter-turn encoding). `Wc`/`Hc` are the unrotated content's view-px\n  // extents (the builder places the footprint in the box's positive quadrant).\n  const Wc = (crop.right - crop.left) * s;\n  const Hc = (crop.top - crop.bottom) * s;\n  const contentToView = rotateScaleMatrix(s, Wc, Hc, rotation) as Mat2D<'content', 'view'>;\n\n  const pdfToView = compose(contentToView, pdfToContent);\n  return { pdfToContent, contentToView, pdfToView, viewToPdf: invert(pdfToView) };\n}\n"],"mappings":"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"}