pdf-parser.js 5.2.30 → 5.3.0

package/dist/interpret-marked.cjs

@@ -0,0 +1,25 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_objects = require("./objects.cjs");
+const require_pdf_text = require("./pdf-text.cjs");
+//#region src/interpret-marked.ts
+function markedContentProperties(operand, resources, resolver) {
+	if (operand?.kind === "dict") return operand;
+	if (operand?.kind === "name") {
+		const properties = resolver.resolveDict(require_objects.dictGet(resources, "Properties"));
+		return properties === void 0 ? void 0 : resolver.resolveDict(require_objects.dictGet(properties, operand.name));
+	}
+}
+function markedContentScopeProps(props) {
+	if (props === void 0) return {};
+	const actualTextObj = require_objects.dictGet(props, "ActualText");
+	const altObj = require_objects.dictGet(props, "Alt");
+	const mcid = require_objects.asNumber(require_objects.dictGet(props, "MCID"));
+	return {
+		...actualTextObj?.kind === "string" ? { actualText: require_pdf_text.decodePdfString(actualTextObj.bytes) } : {},
+		...altObj?.kind === "string" ? { alt: require_pdf_text.decodePdfString(altObj.bytes) } : {},
+		...mcid !== void 0 && mcid >= 0 ? { mcid } : {}
+	};
+}
+//#endregion
+exports.markedContentProperties = markedContentProperties;
+exports.markedContentScopeProps = markedContentScopeProps;

package/dist/interpret-marked.d.cts

@@ -0,0 +1,11 @@
+import { n as PdfDict, r as PdfObject } from "./objects-e2RS3-yT.cjs";
+import { PdfObjectResolver } from "./interpret-types.cjs";
+//#region src/interpret-marked.d.ts
+declare function markedContentProperties(operand: PdfObject | undefined, resources: PdfDict, resolver: Readonly<PdfObjectResolver>): PdfDict | undefined;
+declare function markedContentScopeProps(props: PdfDict | undefined): {
+  actualText?: string;
+  alt?: string;
+  mcid?: number;
+};
+//#endregion
+export { markedContentProperties, markedContentScopeProps };

package/dist/interpret-marked.d.ts

@@ -0,0 +1,11 @@
+import { n as PdfDict, r as PdfObject } from "./objects-e2RS3-yT.js";
+import { PdfObjectResolver } from "./interpret-types.js";
+//#region src/interpret-marked.d.ts
+declare function markedContentProperties(operand: PdfObject | undefined, resources: PdfDict, resolver: Readonly<PdfObjectResolver>): PdfDict | undefined;
+declare function markedContentScopeProps(props: PdfDict | undefined): {
+  actualText?: string;
+  alt?: string;
+  mcid?: number;
+};
+//#endregion
+export { markedContentProperties, markedContentScopeProps };

package/dist/interpret-marked.js

@@ -0,0 +1,23 @@
+import { asNumber, dictGet } from "./objects.js";
+import { decodePdfString } from "./pdf-text.js";
+//#region src/interpret-marked.ts
+function markedContentProperties(operand, resources, resolver) {
+	if (operand?.kind === "dict") return operand;
+	if (operand?.kind === "name") {
+		const properties = resolver.resolveDict(dictGet(resources, "Properties"));
+		return properties === void 0 ? void 0 : resolver.resolveDict(dictGet(properties, operand.name));
+	}
+}
+function markedContentScopeProps(props) {
+	if (props === void 0) return {};
+	const actualTextObj = dictGet(props, "ActualText");
+	const altObj = dictGet(props, "Alt");
+	const mcid = asNumber(dictGet(props, "MCID"));
+	return {
+		...actualTextObj?.kind === "string" ? { actualText: decodePdfString(actualTextObj.bytes) } : {},
+		...altObj?.kind === "string" ? { alt: decodePdfString(altObj.bytes) } : {},
+		...mcid !== void 0 && mcid >= 0 ? { mcid } : {}
+	};
+}
+//#endregion
+export { markedContentProperties, markedContentScopeProps };

package/dist/interpret-shapes.cjs

@@ -0,0 +1,212 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_matrix = require("./matrix.cjs");
+//#region src/interpret-shapes.ts
+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 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;
+}
+const RECTANGLE_CORNER_COUNT = 4;
+function detectRect(subpath, paint) {
+	const corners = closedPolygonCorners(subpath);
+	if (corners?.length !== RECTANGLE_CORNER_COUNT) 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
+	};
+}
+const ELLIPSE_SEGMENT_COUNT = 4;
+function detectEllipse(subpath, paint) {
+	const segments = subpath.segments;
+	if (!subpath.closed || segments.length !== ELLIPSE_SEGMENT_COUNT || 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 !== ELLIPSE_SEGMENT_COUNT) 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 < ELLIPSE_SEGMENT_COUNT; i += 1) {
+		const segment = segments[i];
+		const from = onCurve[i];
+		const fromKind = extremes[i];
+		const to = onCurve[(i + 1) % ELLIPSE_SEGMENT_COUNT];
+		const toKind = extremes[(i + 1) % ELLIPSE_SEGMENT_COUNT];
+		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 {
+		kind: "ellipse",
+		xPt: minX,
+		yPt: minY,
+		widthPt: maxX - minX,
+		heightPt: maxY - minY,
+		fill: paint.fill,
+		stroke: paint.stroke
+	};
+}
+function strokeStyleFromDashArray(dashArray) {
+	if (dashArray.length === 0) return;
+	return dashArray.length === 2 && dashArray[0] === 0 ? "dotted" : "dashed";
+}
+function detectLine(subpath, paint, style) {
+	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,
+		...style !== void 0 ? { style } : {}
+	};
+}
+function classifyShape(subpaths, paint, style) {
+	const subpath = subpaths[0];
+	if (subpaths.length !== 1 || subpath === void 0) return;
+	return detectRect(subpath, paint) ?? detectEllipse(subpath, paint) ?? detectLine(subpath, paint, style);
+}
+var MarkedContentStack = class {
+	#frames;
+	constructor(seed = []) {
+		this.#frames = [...seed];
+	}
+	open(frame) {
+		this.#frames.push(frame);
+	}
+	close() {
+		this.#frames.pop();
+	}
+	inScope(key) {
+		for (let i = this.#frames.length - 1; i >= 0; i--) {
+			const frame = this.#frames[i];
+			if (frame !== void 0 && key in frame) return frame[key];
+		}
+	}
+};
+//#endregion
+exports.MarkedContentStack = MarkedContentStack;
+exports.boundsOf = boundsOf;
+exports.cardinalExtremeOf = cardinalExtremeOf;
+exports.classifyShape = classifyShape;
+exports.closedPolygonCorners = closedPolygonCorners;
+exports.detectEllipse = detectEllipse;
+exports.detectLine = detectLine;
+exports.detectRect = detectRect;
+exports.expectedEllipseControl = expectedEllipseControl;
+exports.nearlyEqual = nearlyEqual;
+exports.nearlyEqualPoints = nearlyEqualPoints;
+exports.shapeTolerance = shapeTolerance;
+exports.strokeStyleFromDashArray = strokeStyleFromDashArray;

package/dist/interpret-shapes.d.cts

@@ -0,0 +1,32 @@
+import { ExtractedEllipse, ExtractedLine, ExtractedPaint, ExtractedRect, ExtractedSubpath } from "./interpret-types.cjs";
+import { MarkedContentProps } from "./interpret.cjs";
+import { ContentStrokeStyle, Point } from "document-schema.js";
+//#region src/interpret-shapes.d.ts
+declare function shapeTolerance(extentPt: number): number;
+declare function nearlyEqual(a: number, b: number, tolerance: number): boolean;
+declare function nearlyEqualPoints(a: Point, b: Point, tolerance: number): boolean;
+interface Bounds {
+  readonly minX: number;
+  readonly minY: number;
+  readonly maxX: number;
+  readonly maxY: number;
+}
+declare function boundsOf(points: readonly Point[]): Bounds;
+declare function closedPolygonCorners(subpath: ExtractedSubpath): Point[] | undefined;
+declare function detectRect(subpath: ExtractedSubpath, paint: ExtractedPaint): ExtractedRect | undefined;
+type CardinalExtreme = "right" | "top" | "left" | "bottom";
+declare function cardinalExtremeOf(point: Point, center: Point, rx: number, ry: number, tolX: number, tolY: number): CardinalExtreme | undefined;
+declare function expectedEllipseControl(atExtreme: Point, atExtremeKind: CardinalExtreme, otherEnd: Point, center: Point, kx: number, ky: number): Point;
+declare function detectEllipse(subpath: ExtractedSubpath, paint: ExtractedPaint): ExtractedEllipse | undefined;
+declare function strokeStyleFromDashArray(dashArray: readonly number[]): ContentStrokeStyle | undefined;
+declare function detectLine(subpath: ExtractedSubpath, paint: ExtractedPaint, style: ContentStrokeStyle | undefined): ExtractedLine | undefined;
+declare function classifyShape(subpaths: readonly ExtractedSubpath[], paint: ExtractedPaint, style: ContentStrokeStyle | undefined): ExtractedRect | ExtractedEllipse | ExtractedLine | undefined;
+declare class MarkedContentStack {
+  #private;
+  constructor(seed?: readonly MarkedContentProps[]);
+  open(frame: MarkedContentProps): void;
+  close(): void;
+  inScope<K extends keyof MarkedContentProps>(key: K): MarkedContentProps[K] | undefined;
+}
+//#endregion
+export { MarkedContentStack, boundsOf, cardinalExtremeOf, classifyShape, closedPolygonCorners, detectEllipse, detectLine, detectRect, expectedEllipseControl, nearlyEqual, nearlyEqualPoints, shapeTolerance, strokeStyleFromDashArray };

package/dist/interpret-shapes.d.ts

@@ -0,0 +1,32 @@
+import { ExtractedEllipse, ExtractedLine, ExtractedPaint, ExtractedRect, ExtractedSubpath } from "./interpret-types.js";
+import { MarkedContentProps } from "./interpret.js";
+import { ContentStrokeStyle, Point } from "document-schema.js";
+//#region src/interpret-shapes.d.ts
+declare function shapeTolerance(extentPt: number): number;
+declare function nearlyEqual(a: number, b: number, tolerance: number): boolean;
+declare function nearlyEqualPoints(a: Point, b: Point, tolerance: number): boolean;
+interface Bounds {
+  readonly minX: number;
+  readonly minY: number;
+  readonly maxX: number;
+  readonly maxY: number;
+}
+declare function boundsOf(points: readonly Point[]): Bounds;
+declare function closedPolygonCorners(subpath: ExtractedSubpath): Point[] | undefined;
+declare function detectRect(subpath: ExtractedSubpath, paint: ExtractedPaint): ExtractedRect | undefined;
+type CardinalExtreme = "right" | "top" | "left" | "bottom";
+declare function cardinalExtremeOf(point: Point, center: Point, rx: number, ry: number, tolX: number, tolY: number): CardinalExtreme | undefined;
+declare function expectedEllipseControl(atExtreme: Point, atExtremeKind: CardinalExtreme, otherEnd: Point, center: Point, kx: number, ky: number): Point;
+declare function detectEllipse(subpath: ExtractedSubpath, paint: ExtractedPaint): ExtractedEllipse | undefined;
+declare function strokeStyleFromDashArray(dashArray: readonly number[]): ContentStrokeStyle | undefined;
+declare function detectLine(subpath: ExtractedSubpath, paint: ExtractedPaint, style: ContentStrokeStyle | undefined): ExtractedLine | undefined;
+declare function classifyShape(subpaths: readonly ExtractedSubpath[], paint: ExtractedPaint, style: ContentStrokeStyle | undefined): ExtractedRect | ExtractedEllipse | ExtractedLine | undefined;
+declare class MarkedContentStack {
+  #private;
+  constructor(seed?: readonly MarkedContentProps[]);
+  open(frame: MarkedContentProps): void;
+  close(): void;
+  inScope<K extends keyof MarkedContentProps>(key: K): MarkedContentProps[K] | undefined;
+}
+//#endregion
+export { MarkedContentStack, boundsOf, cardinalExtremeOf, classifyShape, closedPolygonCorners, detectEllipse, detectLine, detectRect, expectedEllipseControl, nearlyEqual, nearlyEqualPoints, shapeTolerance, strokeStyleFromDashArray };

package/dist/interpret-shapes.js

@@ -0,0 +1,199 @@
+import { BEZIER_KAPPA } from "./matrix.js";
+//#region src/interpret-shapes.ts
+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 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;
+}
+const RECTANGLE_CORNER_COUNT = 4;
+function detectRect(subpath, paint) {
+	const corners = closedPolygonCorners(subpath);
+	if (corners?.length !== RECTANGLE_CORNER_COUNT) 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
+	};
+}
+const ELLIPSE_SEGMENT_COUNT = 4;
+function detectEllipse(subpath, paint) {
+	const segments = subpath.segments;
+	if (!subpath.closed || segments.length !== ELLIPSE_SEGMENT_COUNT || 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 !== ELLIPSE_SEGMENT_COUNT) return;
+	const kx = rx * BEZIER_KAPPA;
+	const ky = ry * BEZIER_KAPPA;
+	const controlTolerance = Math.max(tolX, tolY);
+	for (let i = 0; i < ELLIPSE_SEGMENT_COUNT; i += 1) {
+		const segment = segments[i];
+		const from = onCurve[i];
+		const fromKind = extremes[i];
+		const to = onCurve[(i + 1) % ELLIPSE_SEGMENT_COUNT];
+		const toKind = extremes[(i + 1) % ELLIPSE_SEGMENT_COUNT];
+		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 {
+		kind: "ellipse",
+		xPt: minX,
+		yPt: minY,
+		widthPt: maxX - minX,
+		heightPt: maxY - minY,
+		fill: paint.fill,
+		stroke: paint.stroke
+	};
+}
+function strokeStyleFromDashArray(dashArray) {
+	if (dashArray.length === 0) return;
+	return dashArray.length === 2 && dashArray[0] === 0 ? "dotted" : "dashed";
+}
+function detectLine(subpath, paint, style) {
+	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,
+		...style !== void 0 ? { style } : {}
+	};
+}
+function classifyShape(subpaths, paint, style) {
+	const subpath = subpaths[0];
+	if (subpaths.length !== 1 || subpath === void 0) return;
+	return detectRect(subpath, paint) ?? detectEllipse(subpath, paint) ?? detectLine(subpath, paint, style);
+}
+var MarkedContentStack = class {
+	#frames;
+	constructor(seed = []) {
+		this.#frames = [...seed];
+	}
+	open(frame) {
+		this.#frames.push(frame);
+	}
+	close() {
+		this.#frames.pop();
+	}
+	inScope(key) {
+		for (let i = this.#frames.length - 1; i >= 0; i--) {
+			const frame = this.#frames[i];
+			if (frame !== void 0 && key in frame) return frame[key];
+		}
+	}
+};
+//#endregion
+export { MarkedContentStack, boundsOf, cardinalExtremeOf, classifyShape, closedPolygonCorners, detectEllipse, detectLine, detectRect, expectedEllipseControl, nearlyEqual, nearlyEqualPoints, shapeTolerance, strokeStyleFromDashArray };

package/dist/interpret-types.d.cts

@@ -0,0 +1,123 @@
+import { i as PdfDiagnosticSink } from "./diagnostics-C9FxfZ6H.cjs";
+import { n as PdfDict, r as PdfObject } from "./objects-e2RS3-yT.cjs";
+import { r as Matrix } from "./matrix-B7_SBKQ5.cjs";
+import { Color, ContentStrokeStyle } from "document-schema.js";
+//#region src/interpret-types.d.ts
+interface ExtractedTextRun {
+  readonly kind: "text";
+  readonly codes: Uint8Array<ArrayBuffer>;
+  readonly fontResourceName: string;
+  readonly resources: PdfDict;
+  readonly startMatrix: Matrix;
+  readonly endMatrix: Matrix;
+  readonly sizePt: number;
+  readonly color: Color;
+  readonly layerName?: string;
+  readonly actualText?: string;
+  readonly alt?: string;
+  readonly mcid?: number;
+  readonly vertical?: boolean;
+}
+interface ExtractedPaint {
+  readonly fill: Color | undefined;
+  readonly stroke: {
+    readonly color: Color;
+    readonly widthPt: number;
+  } | undefined;
+  readonly layerName?: string;
+  readonly mcid?: number;
+}
+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;
+  readonly style?: ContentStrokeStyle;
+  readonly layerName?: string;
+  readonly mcid?: number;
+}
+type ExtractedPathSegment = {
+  readonly kind: "line";
+  readonly xPt: number;
+  readonly yPt: number;
+} | {
+  readonly kind: "cubic";
+  readonly c1xPt: number;
+  readonly c1yPt: number;
+  readonly c2xPt: number;
+  readonly c2yPt: number;
+  readonly xPt: number;
+  readonly yPt: number;
+};
+interface ExtractedSubpath {
+  readonly startXPt: number;
+  readonly startYPt: number;
+  readonly segments: readonly ExtractedPathSegment[];
+  readonly closed: boolean;
+}
+interface ExtractedPath extends ExtractedPaint {
+  readonly kind: "path";
+  readonly subpaths: readonly ExtractedSubpath[];
+  readonly fillRule: "nonzero" | "evenodd";
+  readonly style?: ContentStrokeStyle;
+}
+interface ExtractedImage {
+  readonly kind: "image";
+  readonly resourceName: string;
+  readonly resources: PdfDict;
+  readonly matrix: Matrix;
+  readonly layerName?: string;
+  readonly mcid?: number;
+}
+interface ExtractedInlineImage {
+  readonly kind: "inlineImage";
+  readonly dict: PdfDict;
+  readonly data: Uint8Array<ArrayBuffer>;
+  readonly matrix: Matrix;
+  readonly layerName?: string;
+  readonly mcid?: number;
+}
+type ExtractedItem = ExtractedTextRun | ExtractedRect | ExtractedEllipse | ExtractedLine | ExtractedPath | ExtractedImage | ExtractedInlineImage;
+interface VerticalGlyphAdvance {
+  readonly displacementPer1000: number;
+  readonly positionXPer1000: number;
+  readonly positionYPer1000: number;
+}
+interface GlyphAdvance {
+  readonly widthPer1000: number;
+  readonly byteLengthConsumed: number;
+  readonly vertical?: VerticalGlyphAdvance;
+}
+interface FontMetricsPort {
+  glyphAdvance: (fontResourceName: string, resources: PdfDict, codes: Uint8Array<ArrayBuffer>, byteOffset: number) => GlyphAdvance | undefined;
+  isVertical: (fontResourceName: string, resources: PdfDict) => boolean;
+}
+interface PdfObjectResolver {
+  resolve: (obj: PdfObject | undefined) => PdfObject | undefined;
+  resolveDict: (obj: PdfObject | undefined) => PdfDict | undefined;
+}
+interface InterpretContext {
+  readonly fontMetrics: FontMetricsPort;
+  readonly resolver: PdfObjectResolver;
+  readonly sink: PdfDiagnosticSink;
+  readonly layerNameOf?: (obj: PdfObject | undefined) => string | undefined;
+}
+//#endregion
+export { ExtractedEllipse, ExtractedImage, ExtractedInlineImage, ExtractedItem, ExtractedLine, ExtractedPaint, ExtractedPath, ExtractedPathSegment, ExtractedRect, ExtractedSubpath, ExtractedTextRun, FontMetricsPort, GlyphAdvance, InterpretContext, PdfObjectResolver, VerticalGlyphAdvance };