pdf-codec 1.4.2 → 1.6.0

package/dist/interpret.cjs

@@ -76,26 +76,176 @@ function matrixFromOperands(operands) {
 		numAt(operands, 5)
 	];
 }
-function isAxisAligned(m) {
-	return m[1] === 0 && m[2] === 0;
+const SHAPE_ABS_TOLERANCE_PT = .001;
+const SHAPE_REL_TOLERANCE = 1e-4;
+function shapeTolerance(extentPt) {
+	return Math.max(SHAPE_ABS_TOLERANCE_PT, Math.abs(extentPt) * SHAPE_REL_TOLERANCE);
 }
-function rectFromOperands(operands, ctm) {
-	const x = numAt(operands, 0);
-	const y = numAt(operands, 1);
-	const w = numAt(operands, 2);
-	const h = numAt(operands, 3);
-	if (!isAxisAligned(ctm)) return;
-	const scaledX = x * ctm[0] + ctm[4];
-	const scaledY = y * ctm[3] + ctm[5];
-	const scaledW = w * ctm[0];
-	const scaledH = h * ctm[3];
+function nearlyEqual(a, b, tolerance) {
+	return Math.abs(a - b) <= tolerance;
+}
+function nearlyEqualPoints(a, b, tolerance) {
+	return nearlyEqual(a.x, b.x, tolerance) && nearlyEqual(a.y, b.y, tolerance);
+}
+function boundsOf(points) {
+	const xs = points.map((p) => p.x);
+	const ys = points.map((p) => p.y);
+	return {
+		minX: Math.min(...xs),
+		minY: Math.min(...ys),
+		maxX: Math.max(...xs),
+		maxY: Math.max(...ys)
+	};
+}
+function closedPolygonCorners(subpath) {
+	if (!subpath.closed) return;
+	const corners = [{
+		x: subpath.startXPt,
+		y: subpath.startYPt
+	}];
+	for (const segment of subpath.segments) {
+		if (segment.kind !== "line") return;
+		corners.push({
+			x: segment.xPt,
+			y: segment.yPt
+		});
+	}
+	const first = corners[0];
+	const last = corners[corners.length - 1];
+	if (first === void 0 || last === void 0 || corners.length < 2) return;
+	const bounds = boundsOf(corners);
+	if (nearlyEqualPoints(first, last, shapeTolerance(Math.max(bounds.maxX - bounds.minX, bounds.maxY - bounds.minY)))) corners.pop();
+	return corners;
+}
+function detectRect(subpath, paint) {
+	const corners = closedPolygonCorners(subpath);
+	if (corners?.length !== 4) return;
+	const { minX, minY, maxX, maxY } = boundsOf(corners);
+	const widthPt = maxX - minX;
+	const heightPt = maxY - minY;
+	const tolX = shapeTolerance(widthPt);
+	const tolY = shapeTolerance(heightPt);
+	if (widthPt <= tolX || heightPt <= tolY) return;
+	for (const corner of corners) {
+		if (!nearlyEqual(corner.x, minX, tolX) && !nearlyEqual(corner.x, maxX, tolX)) return;
+		if (!nearlyEqual(corner.y, minY, tolY) && !nearlyEqual(corner.y, maxY, tolY)) return;
+	}
+	for (let i = 0; i < corners.length; i += 1) {
+		const from = corners[i];
+		const to = corners[(i + 1) % corners.length];
+		if (from === void 0 || to === void 0) return;
+		if (nearlyEqual(from.x, to.x, tolX) === nearlyEqual(from.y, to.y, tolY)) return;
+	}
+	return {
+		kind: "rect",
+		xPt: minX,
+		yPt: minY,
+		widthPt,
+		heightPt,
+		fill: paint.fill,
+		stroke: paint.stroke
+	};
+}
+function cardinalExtremeOf(point, center, rx, ry, tolX, tolY) {
+	if (nearlyEqual(point.y, center.y, tolY)) {
+		if (nearlyEqual(point.x, center.x + rx, tolX)) return "right";
+		if (nearlyEqual(point.x, center.x - rx, tolX)) return "left";
+		return;
+	}
+	if (nearlyEqual(point.x, center.x, tolX)) {
+		if (nearlyEqual(point.y, center.y + ry, tolY)) return "top";
+		if (nearlyEqual(point.y, center.y - ry, tolY)) return "bottom";
+	}
+}
+function expectedEllipseControl(atExtreme, atExtremeKind, otherEnd, center, kx, ky) {
+	if (atExtremeKind === "right" || atExtremeKind === "left") return {
+		x: atExtreme.x,
+		y: center.y + Math.sign(otherEnd.y - center.y) * ky
+	};
+	return {
+		x: center.x + Math.sign(otherEnd.x - center.x) * kx,
+		y: atExtreme.y
+	};
+}
+function detectEllipse(subpath, paint) {
+	const segments = subpath.segments;
+	if (!subpath.closed || segments.length !== 4 || segments.some((segment) => segment.kind !== "cubic")) return;
+	const start = {
+		x: subpath.startXPt,
+		y: subpath.startYPt
+	};
+	const onCurve = [start];
+	for (const segment of segments.slice(0, 3)) onCurve.push({
+		x: segment.xPt,
+		y: segment.yPt
+	});
+	const { minX, minY, maxX, maxY } = boundsOf(onCurve);
+	const rx = (maxX - minX) / 2;
+	const ry = (maxY - minY) / 2;
+	const center = {
+		x: (minX + maxX) / 2,
+		y: (minY + maxY) / 2
+	};
+	const tolX = shapeTolerance(rx);
+	const tolY = shapeTolerance(ry);
+	if (rx <= tolX || ry <= tolY) return;
+	const finalSegment = segments[3];
+	if (finalSegment === void 0 || !nearlyEqualPoints({
+		x: finalSegment.xPt,
+		y: finalSegment.yPt
+	}, start, Math.max(tolX, tolY))) return;
+	const extremes = onCurve.map((point) => cardinalExtremeOf(point, center, rx, ry, tolX, tolY));
+	if (extremes.some((extreme) => extreme === void 0) || new Set(extremes).size !== 4) return;
+	const kx = rx * require_matrix.BEZIER_KAPPA;
+	const ky = ry * require_matrix.BEZIER_KAPPA;
+	const controlTolerance = Math.max(tolX, tolY);
+	for (let i = 0; i < 4; i += 1) {
+		const segment = segments[i];
+		const from = onCurve[i];
+		const fromKind = extremes[i];
+		const to = onCurve[(i + 1) % 4];
+		const toKind = extremes[(i + 1) % 4];
+		if (segment?.kind !== "cubic" || from === void 0 || to === void 0 || fromKind === void 0 || toKind === void 0) return;
+		const expectedC1 = expectedEllipseControl(from, fromKind, to, center, kx, ky);
+		const expectedC2 = expectedEllipseControl(to, toKind, from, center, kx, ky);
+		if (!nearlyEqualPoints({
+			x: segment.c1xPt,
+			y: segment.c1yPt
+		}, expectedC1, controlTolerance)) return;
+		if (!nearlyEqualPoints({
+			x: segment.c2xPt,
+			y: segment.c2yPt
+		}, expectedC2, controlTolerance)) return;
+	}
 	return {
-		xPt: scaledW >= 0 ? scaledX : scaledX + scaledW,
-		yPt: scaledH >= 0 ? scaledY : scaledY + scaledH,
-		widthPt: Math.abs(scaledW),
-		heightPt: Math.abs(scaledH)
+		kind: "ellipse",
+		xPt: minX,
+		yPt: minY,
+		widthPt: maxX - minX,
+		heightPt: maxY - minY,
+		fill: paint.fill,
+		stroke: paint.stroke
 	};
 }
+function detectLine(subpath, paint) {
+	const segment = subpath.segments[0];
+	if (subpath.closed || subpath.segments.length !== 1 || segment?.kind !== "line") return;
+	if (paint.fill !== void 0 || paint.stroke === void 0) return;
+	return {
+		kind: "line",
+		x1Pt: subpath.startXPt,
+		y1Pt: subpath.startYPt,
+		x2Pt: segment.xPt,
+		y2Pt: segment.yPt,
+		color: paint.stroke.color,
+		widthPt: paint.stroke.widthPt
+	};
+}
+function classifyShape(subpaths, paint) {
+	const subpath = subpaths[0];
+	if (subpaths.length !== 1 || subpath === void 0) return;
+	return detectRect(subpath, paint) ?? detectEllipse(subpath, paint) ?? detectLine(subpath, paint);
+}
 function interpretContentStream(bytes, resources, context) {
 	const items = [];
 	runContentStream(bytes, resources, {
@@ -121,7 +271,6 @@ function runContentStream(bytes, resources, initialState, context, items, depth)
 	const gsStack = [];
 	let gs = initialState;
 	let ts = defaultTextState();
-	let pendingRect;
 	let pathSubpaths = [];
 	let currentSubpath;
 	const finalizeCurrentSubpath = () => {
@@ -131,7 +280,6 @@ function runContentStream(bytes, resources, initialState, context, items, depth)
 		}
 	};
 	const resetPath = () => {
-		pendingRect = void 0;
 		pathSubpaths = [];
 		currentSubpath = void 0;
 	};
@@ -187,28 +335,22 @@ function runContentStream(bytes, resources, initialState, context, items, depth)
 			return;
 		}
 		if ((operator === "s" || operator === "b" || operator === "b*") && currentSubpath !== void 0) currentSubpath.closed = true;
-		if ((operator === "f" || operator === "F" || operator === "f*") && currentSubpath === void 0 && pathSubpaths.length === 1 && pendingRect !== void 0) {
-			items.push({
-				kind: "rect",
-				...pendingRect,
-				color: gs.fillColor
-			});
-			resetPath();
-			return;
-		}
 		finalizeCurrentSubpath();
 		if (pathSubpaths.length > 0) {
 			const isFillOp = operator === "f" || operator === "F" || operator === "f*" || operator === "B" || operator === "B*" || operator === "b" || operator === "b*";
 			const isStrokeOp = operator === "S" || operator === "s" || operator === "B" || operator === "B*" || operator === "b" || operator === "b*";
-			items.push({
-				kind: "path",
-				subpaths: pathSubpaths,
-				fillRule: paintFillRuleFor(operator),
+			const paint = {
 				fill: isFillOp ? gs.fillColor : void 0,
 				stroke: isStrokeOp ? {
 					color: gs.strokeColor,
 					widthPt: gs.lineWidth
 				} : void 0
+			};
+			items.push(classifyShape(pathSubpaths, paint) ?? {
+				kind: "path",
+				subpaths: pathSubpaths,
+				fillRule: paintFillRuleFor(operator),
+				...paint
 			});
 		}
 		resetPath();
@@ -395,7 +537,6 @@ function runContentStream(bytes, resources, initialState, context, items, depth)
 				break;
 			}
 			case "re":
-				pendingRect = rectFromOperands(operands, gs.ctm);
 				appendRectSubpath(operands, gs.ctm);
 				break;
 			case "m": {
@@ -410,7 +551,6 @@ function runContentStream(bytes, resources, initialState, context, items, depth)
 					segments: [],
 					closed: false
 				};
-				pendingRect = void 0;
 				break;
 			}
 			case "l": {
@@ -423,7 +563,6 @@ function runContentStream(bytes, resources, initialState, context, items, depth)
 					xPt: p.x,
 					yPt: p.y
 				});
-				pendingRect = void 0;
 				break;
 			}
 			case "c": {
@@ -448,7 +587,6 @@ function runContentStream(bytes, resources, initialState, context, items, depth)
 					xPt: p.x,
 					yPt: p.y
 				});
-				pendingRect = void 0;
 				break;
 			}
 			case "v":
@@ -472,7 +610,6 @@ function runContentStream(bytes, resources, initialState, context, items, depth)
 						yPt: p.y
 					});
 				}
-				pendingRect = void 0;
 				break;
 			case "y": {
 				const c1 = require_matrix.applyMatrix(gs.ctm, {
@@ -492,12 +629,10 @@ function runContentStream(bytes, resources, initialState, context, items, depth)
 					xPt: p.x,
 					yPt: p.y
 				});
-				pendingRect = void 0;
 				break;
 			}
 			case "h":
 				if (currentSubpath !== void 0) currentSubpath.closed = true;
-				pendingRect = void 0;
 				break;
 			case "w":
 				gs = {

package/dist/interpret.d.cts

@@ -1,6 +1,6 @@
 import { PdfDiagnosticSink } from "./diagnostics.cjs";
 import { PdfDict, PdfObject } from "./objects.cjs";
-import { n as Matrix } from "./matrix-B3c2_a2f.cjs";
+import { r as Matrix } from "./matrix-BHzJESll.cjs";
 import { Color } from "document-schema.js";
 //#region src/interpret.d.ts
 interface ExtractedTextRun {
@@ -13,13 +13,35 @@ interface ExtractedTextRun {
   readonly sizePt: number;
   readonly color: Color;
 }
-interface ExtractedRect {
+interface ExtractedPaint {
+  readonly fill: Color | undefined;
+  readonly stroke: {
+    readonly color: Color;
+    readonly widthPt: number;
+  } | undefined;
+}
+interface ExtractedRect extends ExtractedPaint {
   readonly kind: 'rect';
   readonly xPt: number;
   readonly yPt: number;
   readonly widthPt: number;
   readonly heightPt: number;
+}
+interface ExtractedEllipse extends ExtractedPaint {
+  readonly kind: 'ellipse';
+  readonly xPt: number;
+  readonly yPt: number;
+  readonly widthPt: number;
+  readonly heightPt: number;
+}
+interface ExtractedLine {
+  readonly kind: 'line';
+  readonly x1Pt: number;
+  readonly y1Pt: number;
+  readonly x2Pt: number;
+  readonly y2Pt: number;
   readonly color: Color;
+  readonly widthPt: number;
 }
 type ExtractedPathSegment = {
   readonly kind: 'line';
@@ -40,15 +62,10 @@ interface ExtractedSubpath {
   readonly segments: readonly ExtractedPathSegment[];
   readonly closed: boolean;
 }
-interface ExtractedPath {
+interface ExtractedPath extends ExtractedPaint {
   readonly kind: 'path';
   readonly subpaths: readonly ExtractedSubpath[];
   readonly fillRule: 'nonzero' | 'evenodd';
-  readonly fill: Color | undefined;
-  readonly stroke: {
-    readonly color: Color;
-    readonly widthPt: number;
-  } | undefined;
 }
 interface ExtractedImage {
   readonly kind: 'image';
@@ -62,7 +79,7 @@ interface ExtractedInlineImage {
   readonly data: Uint8Array<ArrayBuffer>;
   readonly matrix: Matrix;
 }
-type ExtractedItem = ExtractedTextRun | ExtractedRect | ExtractedPath | ExtractedImage | ExtractedInlineImage;
+type ExtractedItem = ExtractedTextRun | ExtractedRect | ExtractedEllipse | ExtractedLine | ExtractedPath | ExtractedImage | ExtractedInlineImage;
 interface GlyphAdvance {
   readonly widthPer1000: number;
   readonly byteLengthConsumed: number;
@@ -81,4 +98,4 @@ interface InterpretContext {
 }
 declare function interpretContentStream(bytes: Uint8Array<ArrayBuffer>, resources: PdfDict, context: InterpretContext): ExtractedItem[];
 //#endregion
-export { ExtractedImage, ExtractedInlineImage, ExtractedItem, ExtractedPath, ExtractedPathSegment, ExtractedRect, ExtractedSubpath, ExtractedTextRun, FontMetricsPort, GlyphAdvance, InterpretContext, PdfObjectResolver, interpretContentStream };
+export { ExtractedEllipse, ExtractedImage, ExtractedInlineImage, ExtractedItem, ExtractedLine, ExtractedPaint, ExtractedPath, ExtractedPathSegment, ExtractedRect, ExtractedSubpath, ExtractedTextRun, FontMetricsPort, GlyphAdvance, InterpretContext, PdfObjectResolver, interpretContentStream };

package/dist/interpret.d.ts

@@ -1,6 +1,6 @@
 import { PdfDiagnosticSink } from "./diagnostics.js";
 import { PdfDict, PdfObject } from "./objects.js";
-import { n as Matrix } from "./matrix-B3c2_a2f.js";
+import { r as Matrix } from "./matrix-BHzJESll.js";
 import { Color } from "document-schema.js";
 //#region src/interpret.d.ts
 interface ExtractedTextRun {
@@ -13,13 +13,35 @@ interface ExtractedTextRun {
   readonly sizePt: number;
   readonly color: Color;
 }
-interface ExtractedRect {
+interface ExtractedPaint {
+  readonly fill: Color | undefined;
+  readonly stroke: {
+    readonly color: Color;
+    readonly widthPt: number;
+  } | undefined;
+}
+interface ExtractedRect extends ExtractedPaint {
   readonly kind: 'rect';
   readonly xPt: number;
   readonly yPt: number;
   readonly widthPt: number;
   readonly heightPt: number;
+}
+interface ExtractedEllipse extends ExtractedPaint {
+  readonly kind: 'ellipse';
+  readonly xPt: number;
+  readonly yPt: number;
+  readonly widthPt: number;
+  readonly heightPt: number;
+}
+interface ExtractedLine {
+  readonly kind: 'line';
+  readonly x1Pt: number;
+  readonly y1Pt: number;
+  readonly x2Pt: number;
+  readonly y2Pt: number;
   readonly color: Color;
+  readonly widthPt: number;
 }
 type ExtractedPathSegment = {
   readonly kind: 'line';
@@ -40,15 +62,10 @@ interface ExtractedSubpath {
   readonly segments: readonly ExtractedPathSegment[];
   readonly closed: boolean;
 }
-interface ExtractedPath {
+interface ExtractedPath extends ExtractedPaint {
   readonly kind: 'path';
   readonly subpaths: readonly ExtractedSubpath[];
   readonly fillRule: 'nonzero' | 'evenodd';
-  readonly fill: Color | undefined;
-  readonly stroke: {
-    readonly color: Color;
-    readonly widthPt: number;
-  } | undefined;
 }
 interface ExtractedImage {
   readonly kind: 'image';
@@ -62,7 +79,7 @@ interface ExtractedInlineImage {
   readonly data: Uint8Array<ArrayBuffer>;
   readonly matrix: Matrix;
 }
-type ExtractedItem = ExtractedTextRun | ExtractedRect | ExtractedPath | ExtractedImage | ExtractedInlineImage;
+type ExtractedItem = ExtractedTextRun | ExtractedRect | ExtractedEllipse | ExtractedLine | ExtractedPath | ExtractedImage | ExtractedInlineImage;
 interface GlyphAdvance {
   readonly widthPer1000: number;
   readonly byteLengthConsumed: number;
@@ -81,4 +98,4 @@ interface InterpretContext {
 }
 declare function interpretContentStream(bytes: Uint8Array<ArrayBuffer>, resources: PdfDict, context: InterpretContext): ExtractedItem[];
 //#endregion
-export { ExtractedImage, ExtractedInlineImage, ExtractedItem, ExtractedPath, ExtractedPathSegment, ExtractedRect, ExtractedSubpath, ExtractedTextRun, FontMetricsPort, GlyphAdvance, InterpretContext, PdfObjectResolver, interpretContentStream };
+export { ExtractedEllipse, ExtractedImage, ExtractedInlineImage, ExtractedItem, ExtractedLine, ExtractedPaint, ExtractedPath, ExtractedPathSegment, ExtractedRect, ExtractedSubpath, ExtractedTextRun, FontMetricsPort, GlyphAdvance, InterpretContext, PdfObjectResolver, interpretContentStream };