@embedpdf/core-geometry 3.0.0-next.13 → 3.0.0-next.15

package/dist/index.js

@@ -10,11 +10,11 @@ function boundsOfRects(rects) {
 	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);
+	for (const rect of rects) {
+		x1 = Math.min(x1, rect.x);
+		y1 = Math.min(y1, rect.y);
+		x2 = Math.max(x2, rect.x + rect.width);
+		y2 = Math.max(y2, rect.y + rect.height);
 	}
 	return {
 		x: x1,
@@ -29,14 +29,48 @@ function boundsOfRects(rects) {
 * 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);
+function intersectRects(left, right) {
+	const x = Math.max(left.x, right.x);
+	const y = Math.max(left.y, right.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)
+		width: Math.max(0, Math.min(left.x + left.width, right.x + right.width) - x),
+		height: Math.max(0, Math.min(left.y + left.height, right.y + right.height) - y)
+	};
+}
+/** The axis-aligned rect spanned by two corners, in any order — a drag box. */
+function rectFromCorners(from, to) {
+	return {
+		x: Math.min(from.x, to.x),
+		y: Math.min(from.y, to.y),
+		width: Math.abs(to.x - from.x),
+		height: Math.abs(to.y - from.y)
+	};
+}
+/** Whether a rect contains a point, edges inclusive. Space-agnostic. */
+function rectContains(rect, point) {
+	return point.x >= rect.x && point.x <= rect.x + rect.width && point.y >= rect.y && point.y <= rect.y + rect.height;
+}
+/** Positive-area overlap of two rects — touching edges do not count. */
+function rectsOverlap(left, right) {
+	const overlap = intersectRects(left, right);
+	return overlap.width > 0 && overlap.height > 0;
+}
+/**
+* The largest rect of `content`'s proportions inside `box`, centred in it:
+* CSS `object-fit: contain`. `box` itself when `content` has no area.
+*/
+function containedRect(content, box) {
+	if (content.width <= 0 || content.height <= 0) return box;
+	const scale = Math.min(box.width / content.width, box.height / content.height);
+	const width = content.width * scale;
+	const height = content.height * scale;
+	return {
+		x: box.x + (box.width - width) / 2,
+		y: box.y + (box.height - height) / 2,
+		width,
+		height
 	};
 }
 const NO_FRAME = {
@@ -50,16 +84,16 @@ 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)`
+* 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;
+function addRotations(left, right) {
+	return (left + right) % 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
+* 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) {
@@ -76,13 +110,13 @@ function displaySize(content, rotation) {
 	};
 }
 /**
-* The engine's `kind:'width'` height rule, replicated EXACTLY so the viewer can
+* 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
+* 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) {
@@ -90,7 +124,7 @@ function deviceHeightForWidth(pageSize, deviceWidth) {
 }
 /**
 * 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 ×
+* `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).
@@ -118,13 +152,13 @@ function pageTransform(input) {
 	];
 	const viewMat = rotateScaleMatrix(viewScale, content.width, content.height, rotation);
 	const invMat = invert(viewMat);
-	const toPixels = (p) => applyPoint(contentMat, p);
+	const toPixels = (point) => applyPoint(contentMat, point);
 	const contentInv = invert(contentMat);
-	const fromPixels = (p) => applyPoint(contentInv, p);
-	const contentToView = (p) => applyPoint(viewMat, p);
-	const viewToContent = (p) => applyPoint(invMat, p);
-	const contentToViewRect = (r) => applyRect(viewMat, r);
-	const viewToContentRect = (r) => applyRect(invMat, r);
+	const fromPixels = (point) => applyPoint(contentInv, point);
+	const pageToView = (point) => applyPoint(viewMat, point);
+	const viewToPage = (point) => applyPoint(invMat, point);
+	const pageToViewRect = (rect) => applyRect(viewMat, rect);
+	const viewToPageRect = (rect) => applyRect(invMat, rect);
 	const cssMatrix = matrixToCss(viewMat);
 	return {
 		rotation,
@@ -140,13 +174,22 @@ function pageTransform(input) {
 		zoom,
 		toPixels,
 		fromPixels,
-		contentToView,
-		contentToViewRect,
-		viewToContent,
-		viewToContentRect,
+		pageToView,
+		pageToViewRect,
+		viewToPage,
+		viewToPageRect,
 		cssMatrix
 	};
 }
+/**
+* Whether two transforms place things on the page the same: the same scale, zoom and turn, and
+* the same content box. A Stage builds a new transform on every frame, also for a plain scroll,
+* which moves the page but changes nothing inside it; a layer that compares with this redraws
+* only when what it draws in the page's pixels moved.
+*/
+function samePagePlacement(left, right) {
+	return left.viewScale === right.viewScale && left.zoom === right.zoom && left.rotation === right.rotation && left.contentWidth === right.contentWidth && left.contentHeight === right.contentHeight;
+}
 /** The identity transform within a single space. */
 function identity() {
 	return [
@@ -159,13 +202,13 @@ function identity() {
 	];
 }
 /**
-* 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.
+* Compose two matrices: `compose(matrix, inner)` applies `inner` first, then
+* `matrix` (matrix product `matrix · inner`). 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;
+function compose(matrix, inner) {
+	const [a, b, c, d, e, f] = matrix;
+	const [a2, b2, c2, d2, e2, f2] = inner;
 	return [
 		a * a2 + c * b2,
 		b * a2 + d * b2,
@@ -175,9 +218,9 @@ function compose(m, n) {
 		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;
+/** Invert a transform — `invert(pageToView)` is `viewToPage`, i.e. hit-testing for free. */
+function invert(matrix) {
+	const [a, b, c, d, e, f] = matrix;
 	const det = a * d - b * c;
 	if (det === 0) throw new Error("Mat2D.invert: non-invertible matrix (det = 0)");
 	const ia = d / det;
@@ -194,35 +237,35 @@ function invert(m) {
 	];
 }
 /** Apply a transform to a point. */
-function applyPoint(m, p) {
-	const [a, b, c, d, e, f] = m;
+function applyPoint(matrix, point) {
+	const [a, b, c, d, e, f] = matrix;
 	return {
-		x: a * p.x + c * p.y + e,
-		y: b * p.x + d * p.y + f
+		x: a * point.x + c * point.y + e,
+		y: b * point.x + d * point.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
+* 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
+function applyRect(matrix, rect) {
+	const c0 = applyPoint(matrix, {
+		x: rect.x,
+		y: rect.y
 	});
-	const c1 = applyPoint(m, {
-		x: r.x + r.width,
-		y: r.y
+	const c1 = applyPoint(matrix, {
+		x: rect.x + rect.width,
+		y: rect.y
 	});
-	const c2 = applyPoint(m, {
-		x: r.x,
-		y: r.y + r.height
+	const c2 = applyPoint(matrix, {
+		x: rect.x,
+		y: rect.y + rect.height
 	});
-	const c3 = applyPoint(m, {
-		x: r.x + r.width,
-		y: r.y + r.height
+	const c3 = applyPoint(matrix, {
+		x: rect.x + rect.width,
+		y: rect.y + rect.height
 	});
 	const xs = [
 		c0.x,
@@ -245,22 +288,22 @@ function applyRect(m, r) {
 		height: Math.max(...ys) - minY
 	};
 }
-/** Apply a transform to a quad, preserving orientation (maps the four points). */
-function applyQuad(m, q) {
+/** Apply a transform to a quad: each corner moves and keeps its name. */
+function applyQuad(matrix, quad) {
 	return {
-		p1: applyPoint(m, q.p1),
-		p2: applyPoint(m, q.p2),
-		p3: applyPoint(m, q.p3),
-		p4: applyPoint(m, q.p4)
+		upperLeft: applyPoint(matrix, quad.upperLeft),
+		upperRight: applyPoint(matrix, quad.upperRight),
+		lowerLeft: applyPoint(matrix, quad.lowerLeft),
+		lowerRight: applyPoint(matrix, quad.lowerRight)
 	};
 }
 /**
-* A `Mat2D` IS a CSS `matrix()` — the six numbers are identical. Drop the result
+* 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;
+function matrixToCss(matrix) {
+	const [a, b, c, d, e, f] = matrix;
 	return `matrix(${a}, ${b}, ${c}, ${d}, ${e}, ${f})`;
 }
 /** Translate within a space. */
@@ -285,40 +328,40 @@ function scale(sx, sy) {
 		0
 	];
 }
-/** Rotate about the space origin (radians; clockwise in y-down content space). */
+/** Rotate about the space origin (radians; clockwise in y-down page space). */
 function rotate(rad) {
-	const c = Math.cos(rad);
-	const s = Math.sin(rad);
+	const cosine = Math.cos(rad);
+	const sine = Math.sin(rad);
 	return [
-		c,
-		s,
-		-s,
-		c,
+		cosine,
+		sine,
+		-sine,
+		cosine,
 		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)));
+function rotateAbout(point, rad) {
+	return compose(translate(point.x, point.y), compose(rotate(rad), translate(-point.x, -point.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)));
+function scaleAbout(point, sx, sy) {
+	return compose(translate(point.x, point.y), compose(scale(sx, sy), translate(-point.x, -point.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]);
+*  clockwise in y-down page space (the inverse of {@link rotate}). */
+function angleOf(matrix) {
+	return Math.atan2(matrix[1], matrix[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
+* The page's scale + integer quarter-turn as a `Mat2D`: a page 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),
+* 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.
 */
@@ -358,112 +401,75 @@ function rotateScaleMatrix(scale, boxW, boxH, rotation) {
 		];
 	}
 }
-/**
-* 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);
+/** An upright quad over a rect (y-down: upper = smaller y). */
+function quadFromRect(rect) {
 	return {
-		pdfToContent,
-		contentToView,
-		pdfToView,
-		viewToPdf: invert(pdfToView)
-	};
-}
-/** Axis-aligned TextQuad over a rect (y-down: upper = smaller y). */
-function textQuadFromRect(r) {
-	return {
-		upperStart: {
-			x: r.x,
-			y: r.y
+		upperLeft: {
+			x: rect.x,
+			y: rect.y
 		},
-		upperEnd: {
-			x: r.x + r.width,
-			y: r.y
+		upperRight: {
+			x: rect.x + rect.width,
+			y: rect.y
 		},
-		lowerStart: {
-			x: r.x,
-			y: r.y + r.height
+		lowerLeft: {
+			x: rect.x,
+			y: rect.y + rect.height
 		},
-		lowerEnd: {
-			x: r.x + r.width,
-			y: r.y + r.height
+		lowerRight: {
+			x: rect.x + rect.width,
+			y: rect.y + rect.height
 		}
 	};
 }
-/** The four corners in slot order: upper-start, upper-end, lower-start, lower-end. */
-function textQuadPoints(t) {
+/** The four corners: upper-left, upper-right, lower-left, lower-right. */
+function quadCorners(quad) {
 	return [
-		t.upperStart,
-		t.upperEnd,
-		t.lowerStart,
-		t.lowerEnd
+		quad.upperLeft,
+		quad.upperRight,
+		quad.lowerLeft,
+		quad.lowerRight
 	];
 }
-/** The corners as a polygon RING (US → UE → LE → LS) — for `<polygon>`/fills. */
-function textQuadRing(t) {
+/** The corners as a polygon ring: upper-left, upper-right, lower-right, lower-left. */
+function quadRing(quad) {
 	return [
-		t.upperStart,
-		t.upperEnd,
-		t.lowerEnd,
-		t.lowerStart
+		quad.upperLeft,
+		quad.upperRight,
+		quad.lowerRight,
+		quad.lowerLeft
 	];
 }
 /**
-* One SIDE edge of the cell — the start (`US → LS`) or end (`UE → LE`) edge,
-* ASCENT CORNER FIRST. This is the segment a caret or a selection handle
+* One side edge of the cell, the left (`UL → LL`) or right (`UR → LR`) one,
+* ascent corner first. This is the segment a caret or a selection handle
 * occupies: its length is the glyph's ink height in the text's own frame (not
 * the AABB height, which grows with tilt), and its direction carries the
-* text's rotation. Which side is the selection's LEADING edge is a reading
+* text's rotation. Which side is the selection's leading edge is a reading
 * -order question — decide it with `advance`, not with geometry.
 */
-function textQuadEdge(t, side) {
-	return side === "start" ? [t.upperStart, t.lowerStart] : [t.upperEnd, t.lowerEnd];
+function quadEdge(quad, side) {
+	return side === "left" ? [quad.upperLeft, quad.lowerLeft] : [quad.upperRight, quad.lowerRight];
 }
-/** Corner-wise equality — an AABB comparison would call a quad that ROTATED
+/** Corner-wise equality — an AABB comparison would call a quad that rotated
 *  in place "unchanged"; corners cannot. (Change-detection for quad consumers.) */
-function textQuadEquals(a, b) {
-	const eq = (p, q) => p.x === q.x && p.y === q.y;
-	return eq(a.upperStart, b.upperStart) && eq(a.upperEnd, b.upperEnd) && eq(a.lowerStart, b.lowerStart) && eq(a.lowerEnd, b.lowerEnd);
+function quadEquals(left, right) {
+	const eq = (point, other) => point.x === other.x && point.y === other.y;
+	return eq(left.upperLeft, right.upperLeft) && eq(left.upperRight, right.upperRight) && eq(left.lowerLeft, right.lowerLeft) && eq(left.lowerRight, right.lowerRight);
 }
-/** Axis-aligned bounds of a TextQuad. */
-function textQuadBounds(t) {
+/** Axis-aligned bounds of a quad. */
+function quadBounds(quad) {
 	const xs = [
-		t.upperStart.x,
-		t.upperEnd.x,
-		t.lowerStart.x,
-		t.lowerEnd.x
+		quad.upperLeft.x,
+		quad.upperRight.x,
+		quad.lowerLeft.x,
+		quad.lowerRight.x
 	];
 	const ys = [
-		t.upperStart.y,
-		t.upperEnd.y,
-		t.lowerStart.y,
-		t.lowerEnd.y
+		quad.upperLeft.y,
+		quad.upperRight.y,
+		quad.lowerLeft.y,
+		quad.lowerRight.y
 	];
 	const minX = Math.min(...xs);
 	const minY = Math.min(...ys);
@@ -474,142 +480,7 @@ function textQuadBounds(t) {
 		height: Math.max(...ys) - minY
 	};
 }
-/** Map a TextQuad through an affine transform (corner semantics ride along). */
-function applyTextQuad(m, t) {
-	return {
-		upperStart: applyPoint(m, t.upperStart),
-		upperEnd: applyPoint(m, t.upperEnd),
-		lowerStart: applyPoint(m, t.lowerStart),
-		lowerEnd: applyPoint(m, t.lowerEnd)
-	};
-}
-/** Serialize to the positional zigzag convention (`p1..p4` = US, UE, LS, LE). */
-function positionalQuad(t) {
-	return {
-		p1: t.upperStart,
-		p2: t.upperEnd,
-		p3: t.lowerStart,
-		p4: t.lowerEnd
-	};
-}
-const QUAD_EPSILON = 1e-6;
-function finitePoint(p) {
-	return Number.isFinite(p.x) && Number.isFinite(p.y);
-}
-/** Is `[us, ue, ls, le]` a well-formed zigzag reading of a quad? */
-function zigzagWellFormed([us, ue, ls, le]) {
-	if (![
-		us,
-		ue,
-		ls,
-		le
-	].every(finitePoint)) return false;
-	const upper = {
-		x: ue.x - us.x,
-		y: ue.y - us.y
-	};
-	const lower = {
-		x: le.x - ls.x,
-		y: le.y - ls.y
-	};
-	const startSide = {
-		x: ls.x - us.x,
-		y: ls.y - us.y
-	};
-	const endSide = {
-		x: le.x - ue.x,
-		y: le.y - ue.y
-	};
-	const lenU = Math.hypot(upper.x, upper.y);
-	const lenL = Math.hypot(lower.x, lower.y);
-	const lenS = Math.hypot(startSide.x, startSide.y);
-	const lenE = Math.hypot(endSide.x, endSide.y);
-	if (lenU <= QUAD_EPSILON || lenL <= QUAD_EPSILON || lenS <= QUAD_EPSILON || lenE <= QUAD_EPSILON) return false;
-	if (upper.x * lower.x + upper.y * lower.y <= 0) return false;
-	if (startSide.x * endSide.x + startSide.y * endSide.y <= 0) return false;
-	const startArea = upper.x * startSide.y - upper.y * startSide.x;
-	const endArea = lower.x * endSide.y - lower.y * endSide.x;
-	if (Math.abs(startArea) <= QUAD_EPSILON * lenU * lenS) return false;
-	if (Math.abs(endArea) <= QUAD_EPSILON * lenL * lenE) return false;
-	return Math.sign(startArea) === Math.sign(endArea);
-}
-/**
-* Interpret an arbitrary positional quad (an imported `/QuadPoints` entry,
-* already in content space) as a TextQuad — a NORMALIZER, not a cast:
-*
-*   1. the de-facto zigzag order (US, UE, LS, LE) passes through untouched —
-*      this covers every well-formed writer, rotated quads included;
-*   2. the common ring order (US, UE, LE, LS) is recognized and repaired;
-*   3. anything else gets a deterministic geometric labeling: corners sorted
-*      into a ring around their centroid, "upper" = the edge whose midpoint
-*      sits highest on screen (smallest y). The 180° "which side is up"
-*      ambiguity is unresolvable from geometry alone — convention decides.
-*
-* Drawing code downstream (`markupScene`) reads corner SEMANTICS, so a
-* mislabeled import can shift an underline to the wrong edge but can never
-* crash or self-intersect.
-*/
-function normalizeQuad(q) {
-	if (zigzagWellFormed([
-		q.p1,
-		q.p2,
-		q.p3,
-		q.p4
-	])) return {
-		upperStart: q.p1,
-		upperEnd: q.p2,
-		lowerStart: q.p3,
-		lowerEnd: q.p4
-	};
-	if (zigzagWellFormed([
-		q.p1,
-		q.p2,
-		q.p4,
-		q.p3
-	])) return {
-		upperStart: q.p1,
-		upperEnd: q.p2,
-		lowerStart: q.p4,
-		lowerEnd: q.p3
-	};
-	const pts = [
-		q.p1,
-		q.p2,
-		q.p3,
-		q.p4
-	].map((p) => finitePoint(p) ? p : {
-		x: 0,
-		y: 0
-	});
-	const cx = (pts[0].x + pts[1].x + pts[2].x + pts[3].x) / 4;
-	const cy = (pts[0].y + pts[1].y + pts[2].y + pts[3].y) / 4;
-	const ringSorted = [...pts].sort((a, b) => Math.atan2(a.y - cy, a.x - cx) - Math.atan2(b.y - cy, b.x - cx));
-	let upperEdge = 0;
-	let bestY = Infinity;
-	for (let i = 0; i < 4; i++) {
-		const midY = (ringSorted[i].y + ringSorted[(i + 1) % 4].y) / 2;
-		if (midY < bestY) {
-			bestY = midY;
-			upperEdge = i;
-		}
-	}
-	const a = ringSorted[upperEdge];
-	const b = ringSorted[(upperEdge + 1) % 4];
-	const c = ringSorted[(upperEdge + 2) % 4];
-	const d = ringSorted[(upperEdge + 3) % 4];
-	return a.x <= b.x ? {
-		upperStart: a,
-		upperEnd: b,
-		lowerStart: d,
-		lowerEnd: c
-	} : {
-		upperStart: b,
-		upperEnd: a,
-		lowerStart: c,
-		lowerEnd: d
-	};
-}
 //#endregion
-export { NO_FRAME, addRotations, angleOf, applyPoint, applyQuad, applyRect, applyTextQuad, boundsOfRects, compose, deviceHeightForWidth, displaySize, identity, intersectRects, invert, isQuarterTurn, matrixToCss, normalizeQuad, pageGeometry, pageTransform, pdfToContentMatrix, positionalQuad, rotate, rotateAbout, rotateScaleMatrix, scale, scaleAbout, snapToDevice, textQuadBounds, textQuadEdge, textQuadEquals, textQuadFromRect, textQuadPoints, textQuadRing, translate };
+export { NO_FRAME, addRotations, angleOf, applyPoint, applyQuad, applyRect, boundsOfRects, compose, containedRect, deviceHeightForWidth, displaySize, identity, intersectRects, invert, isQuarterTurn, matrixToCss, pageTransform, quadBounds, quadCorners, quadEdge, quadEquals, quadFromRect, quadRing, rectContains, rectFromCorners, rectsOverlap, rotate, rotateAbout, rotateScaleMatrix, samePagePlacement, scale, scaleAbout, snapToDevice, translate };
 
 //# sourceMappingURL=index.js.map