pdf-codec 1.3.0 → 1.4.0

package/dist/interpret.d.ts

@@ -0,0 +1,84 @@
+import { PdfDiagnosticSink } from "./diagnostics.js";
+import { PdfDict, PdfObject } from "./objects.js";
+import { n as Matrix } from "./matrix-B3c2_a2f.js";
+import { Color } from "document-schema.js";
+//#region src/interpret.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;
+}
+interface ExtractedRect {
+  readonly kind: 'rect';
+  readonly xPt: number;
+  readonly yPt: number;
+  readonly widthPt: number;
+  readonly heightPt: number;
+  readonly color: Color;
+}
+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 {
+  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';
+  readonly resourceName: string;
+  readonly resources: PdfDict;
+  readonly matrix: Matrix;
+}
+interface ExtractedInlineImage {
+  readonly kind: 'inlineImage';
+  readonly dict: PdfDict;
+  readonly data: Uint8Array<ArrayBuffer>;
+  readonly matrix: Matrix;
+}
+type ExtractedItem = ExtractedTextRun | ExtractedRect | ExtractedPath | ExtractedImage | ExtractedInlineImage;
+interface GlyphAdvance {
+  readonly widthPer1000: number;
+  readonly byteLengthConsumed: number;
+}
+interface FontMetricsPort {
+  glyphAdvance(fontResourceName: string, resources: PdfDict, codes: Uint8Array<ArrayBuffer>, byteOffset: number): GlyphAdvance | undefined;
+}
+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;
+}
+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 };

package/dist/interpret.js

@@ -0,0 +1,586 @@
+import { asArray, asName, asNumber, dictGet } from "./objects.js";
+import { decodeStream } from "./filters.js";
+import { IDENTITY_MATRIX, applyMatrix, multiplyMatrices, translationMatrix } from "./matrix.js";
+import { readContentStream } from "./content-read.js";
+import { COLOR_BLACK } from "document-schema.js";
+//#region src/interpret.ts
+const MAX_FORM_XOBJECT_DEPTH = 12;
+const FALLBACK_GLYPH_WIDTH_PER_1000 = 500;
+const DEFAULT_LINE_WIDTH_PT = 1;
+function defaultTextState() {
+	return {
+		tm: IDENTITY_MATRIX,
+		tlm: IDENTITY_MATRIX,
+		fontResourceName: void 0,
+		fontSizePt: 0,
+		charSpace: 0,
+		wordSpace: 0,
+		horizScale: 1,
+		leading: 0,
+		rise: 0
+	};
+}
+function computeTrm(ctm, ts) {
+	const fontMatrix = [
+		ts.fontSizePt * ts.horizScale,
+		0,
+		0,
+		ts.fontSizePt,
+		0,
+		ts.rise
+	];
+	return multiplyMatrices(multiplyMatrices(fontMatrix, ts.tm), ctm);
+}
+function numAt(operands, index) {
+	return asNumber(operands[index]) ?? 0;
+}
+function grayColor(value) {
+	return {
+		r: value,
+		g: value,
+		b: value
+	};
+}
+function rgbColor(operands) {
+	return {
+		r: numAt(operands, 0),
+		g: numAt(operands, 1),
+		b: numAt(operands, 2)
+	};
+}
+function cmykColor(operands) {
+	const c = numAt(operands, 0);
+	const m = numAt(operands, 1);
+	const y = numAt(operands, 2);
+	const k = numAt(operands, 3);
+	return {
+		r: (1 - c) * (1 - k),
+		g: (1 - m) * (1 - k),
+		b: (1 - y) * (1 - k)
+	};
+}
+function genericColor(operands) {
+	const numericOperands = operands.filter((o) => o.kind === "number");
+	if (numericOperands.length === 1) return grayColor(numAt(numericOperands, 0));
+	if (numericOperands.length === 3) return rgbColor(numericOperands);
+	if (numericOperands.length === 4) return cmykColor(numericOperands);
+}
+function matrixFromOperands(operands) {
+	return [
+		numAt(operands, 0),
+		numAt(operands, 1),
+		numAt(operands, 2),
+		numAt(operands, 3),
+		numAt(operands, 4),
+		numAt(operands, 5)
+	];
+}
+function isAxisAligned(m) {
+	return m[1] === 0 && m[2] === 0;
+}
+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];
+	return {
+		xPt: scaledW >= 0 ? scaledX : scaledX + scaledW,
+		yPt: scaledH >= 0 ? scaledY : scaledY + scaledH,
+		widthPt: Math.abs(scaledW),
+		heightPt: Math.abs(scaledH)
+	};
+}
+function interpretContentStream(bytes, resources, context) {
+	const items = [];
+	runContentStream(bytes, resources, {
+		ctm: IDENTITY_MATRIX,
+		fillColor: COLOR_BLACK,
+		strokeColor: COLOR_BLACK,
+		lineWidth: DEFAULT_LINE_WIDTH_PT
+	}, context, items, 0);
+	return items;
+}
+function lastPointOf(subpath) {
+	const last = subpath.segments[subpath.segments.length - 1];
+	return last === void 0 ? {
+		x: subpath.startXPt,
+		y: subpath.startYPt
+	} : {
+		x: last.xPt,
+		y: last.yPt
+	};
+}
+function runContentStream(bytes, resources, initialState, context, items, depth) {
+	const operations = readContentStream(bytes, context.sink);
+	const gsStack = [];
+	let gs = initialState;
+	let ts = defaultTextState();
+	let pendingRect;
+	let pathSubpaths = [];
+	let currentSubpath;
+	const finalizeCurrentSubpath = () => {
+		if (currentSubpath !== void 0) {
+			pathSubpaths.push(currentSubpath);
+			currentSubpath = void 0;
+		}
+	};
+	const resetPath = () => {
+		pendingRect = void 0;
+		pathSubpaths = [];
+		currentSubpath = void 0;
+	};
+	const appendRectSubpath = (operands, ctm) => {
+		finalizeCurrentSubpath();
+		const x = numAt(operands, 0);
+		const y = numAt(operands, 1);
+		const w = numAt(operands, 2);
+		const h = numAt(operands, 3);
+		const p1 = applyMatrix(ctm, {
+			x,
+			y
+		});
+		const p2 = applyMatrix(ctm, {
+			x: x + w,
+			y
+		});
+		const p3 = applyMatrix(ctm, {
+			x: x + w,
+			y: y + h
+		});
+		const p4 = applyMatrix(ctm, {
+			x,
+			y: y + h
+		});
+		pathSubpaths.push({
+			startXPt: p1.x,
+			startYPt: p1.y,
+			segments: [
+				{
+					kind: "line",
+					xPt: p2.x,
+					yPt: p2.y
+				},
+				{
+					kind: "line",
+					xPt: p3.x,
+					yPt: p3.y
+				},
+				{
+					kind: "line",
+					xPt: p4.x,
+					yPt: p4.y
+				}
+			],
+			closed: true
+		});
+	};
+	const paintFillRuleFor = (operator) => operator.endsWith("*") ? "evenodd" : "nonzero";
+	const emitPaint = (operator) => {
+		if (operator === "n") {
+			resetPath();
+			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),
+				fill: isFillOp ? gs.fillColor : void 0,
+				stroke: isStrokeOp ? {
+					color: gs.strokeColor,
+					widthPt: gs.lineWidth
+				} : void 0
+			});
+		}
+		resetPath();
+	};
+	const advanceThroughString = (codes) => {
+		if (ts.fontResourceName === void 0) return;
+		let offset = 0;
+		while (offset < codes.length) {
+			const glyph = context.fontMetrics.glyphAdvance(ts.fontResourceName, resources, codes, offset);
+			if (glyph === void 0) context.sink({
+				code: "pdf/font-not-resolved",
+				severity: "warning",
+				message: `could not resolve font resource /${ts.fontResourceName} to compute a glyph advance; assuming a fallback width`
+			});
+			const widthPer1000 = glyph?.widthPer1000 ?? FALLBACK_GLYPH_WIDTH_PER_1000;
+			const byteLength = glyph?.byteLengthConsumed ?? 1;
+			const isSingleByteSpace = byteLength === 1 && codes[offset] === 32;
+			const tx = (widthPer1000 / 1e3 * ts.fontSizePt + ts.charSpace + (isSingleByteSpace ? ts.wordSpace : 0)) * ts.horizScale;
+			ts.tm = multiplyMatrices(translationMatrix(tx, 0), ts.tm);
+			offset += byteLength;
+		}
+	};
+	const showTextArray = (elements) => {
+		if (ts.fontResourceName === void 0) return;
+		const startMatrix = computeTrm(gs.ctm, ts);
+		const chunks = [];
+		let totalLength = 0;
+		for (const el of elements) if (el.kind === "string") {
+			chunks.push(el.bytes);
+			totalLength += el.bytes.length;
+			advanceThroughString(el.bytes);
+		} else if (el.kind === "number") {
+			const adjustment = -(el.value / 1e3) * ts.fontSizePt * ts.horizScale;
+			ts.tm = multiplyMatrices(translationMatrix(adjustment, 0), ts.tm);
+		}
+		if (totalLength === 0) return;
+		const combined = new Uint8Array(totalLength);
+		let at = 0;
+		for (const chunk of chunks) {
+			combined.set(chunk, at);
+			at += chunk.length;
+		}
+		const endMatrix = computeTrm(gs.ctm, ts);
+		items.push({
+			kind: "text",
+			codes: combined,
+			fontResourceName: ts.fontResourceName,
+			resources,
+			startMatrix,
+			endMatrix,
+			sizePt: ts.fontSizePt,
+			color: gs.fillColor
+		});
+	};
+	const showText = (bytes) => {
+		showTextArray([{
+			kind: "string",
+			bytes,
+			hex: false
+		}]);
+	};
+	const nextLine = () => {
+		ts.tlm = multiplyMatrices(translationMatrix(0, -ts.leading), ts.tlm);
+		ts.tm = ts.tlm;
+	};
+	const handleDo = (name) => {
+		if (name === void 0) return;
+		const xobjects = context.resolver.resolveDict(dictGet(resources, "XObject"));
+		const xobj = xobjects !== void 0 ? context.resolver.resolve(dictGet(xobjects, name)) : void 0;
+		if (xobj?.kind !== "stream") {
+			context.sink({
+				code: "pdf/xobject-not-resolved",
+				severity: "warning",
+				message: `XObject resource /${name} did not resolve to a stream`
+			});
+			return;
+		}
+		const subtype = asName(dictGet(xobj.dict, "Subtype"));
+		if (subtype === "Image") {
+			items.push({
+				kind: "image",
+				resourceName: name,
+				resources,
+				matrix: gs.ctm
+			});
+			return;
+		}
+		if (subtype === "Form") {
+			if (depth >= MAX_FORM_XOBJECT_DEPTH) {
+				context.sink({
+					code: "pdf/form-recursion-limit",
+					severity: "warning",
+					message: "form XObject recursion exceeded the depth limit; skipping further nesting"
+				});
+				return;
+			}
+			const formMatrixArr = asArray(dictGet(xobj.dict, "Matrix"));
+			const formMatrix = formMatrixArr !== void 0 ? matrixFromOperands(formMatrixArr) : IDENTITY_MATRIX;
+			const formResources = context.resolver.resolveDict(dictGet(xobj.dict, "Resources")) ?? resources;
+			const decoded = decodeStream(xobj.raw, xobj.dict, context.sink);
+			const formState = {
+				...gs,
+				ctm: multiplyMatrices(formMatrix, gs.ctm)
+			};
+			runContentStream(decoded.bytes, formResources, formState, context, items, depth + 1);
+		}
+	};
+	for (const token of operations) {
+		if (token.kind === "inlineImage") {
+			items.push({
+				kind: "inlineImage",
+				dict: token.image.dict,
+				data: token.image.data,
+				matrix: gs.ctm
+			});
+			continue;
+		}
+		const { operands, operator } = token.operation;
+		switch (operator) {
+			case "q":
+				gsStack.push(gs);
+				break;
+			case "Q":
+				gs = gsStack.pop() ?? gs;
+				break;
+			case "cm":
+				gs = {
+					...gs,
+					ctm: multiplyMatrices(matrixFromOperands(operands), gs.ctm)
+				};
+				break;
+			case "g":
+				gs = {
+					...gs,
+					fillColor: grayColor(numAt(operands, 0))
+				};
+				break;
+			case "G":
+				gs = {
+					...gs,
+					strokeColor: grayColor(numAt(operands, 0))
+				};
+				break;
+			case "rg":
+				gs = {
+					...gs,
+					fillColor: rgbColor(operands)
+				};
+				break;
+			case "RG":
+				gs = {
+					...gs,
+					strokeColor: rgbColor(operands)
+				};
+				break;
+			case "k":
+				gs = {
+					...gs,
+					fillColor: cmykColor(operands)
+				};
+				break;
+			case "K":
+				gs = {
+					...gs,
+					strokeColor: cmykColor(operands)
+				};
+				break;
+			case "sc":
+			case "scn": {
+				const color = genericColor(operands);
+				if (color !== void 0) gs = {
+					...gs,
+					fillColor: color
+				};
+				break;
+			}
+			case "SC":
+			case "SCN": {
+				const color = genericColor(operands);
+				if (color !== void 0) gs = {
+					...gs,
+					strokeColor: color
+				};
+				break;
+			}
+			case "re":
+				pendingRect = rectFromOperands(operands, gs.ctm);
+				appendRectSubpath(operands, gs.ctm);
+				break;
+			case "m": {
+				finalizeCurrentSubpath();
+				const p = applyMatrix(gs.ctm, {
+					x: numAt(operands, 0),
+					y: numAt(operands, 1)
+				});
+				currentSubpath = {
+					startXPt: p.x,
+					startYPt: p.y,
+					segments: [],
+					closed: false
+				};
+				pendingRect = void 0;
+				break;
+			}
+			case "l": {
+				const p = applyMatrix(gs.ctm, {
+					x: numAt(operands, 0),
+					y: numAt(operands, 1)
+				});
+				currentSubpath?.segments.push({
+					kind: "line",
+					xPt: p.x,
+					yPt: p.y
+				});
+				pendingRect = void 0;
+				break;
+			}
+			case "c": {
+				const c1 = applyMatrix(gs.ctm, {
+					x: numAt(operands, 0),
+					y: numAt(operands, 1)
+				});
+				const c2 = applyMatrix(gs.ctm, {
+					x: numAt(operands, 2),
+					y: numAt(operands, 3)
+				});
+				const p = applyMatrix(gs.ctm, {
+					x: numAt(operands, 4),
+					y: numAt(operands, 5)
+				});
+				currentSubpath?.segments.push({
+					kind: "cubic",
+					c1xPt: c1.x,
+					c1yPt: c1.y,
+					c2xPt: c2.x,
+					c2yPt: c2.y,
+					xPt: p.x,
+					yPt: p.y
+				});
+				pendingRect = void 0;
+				break;
+			}
+			case "v":
+				if (currentSubpath !== void 0) {
+					const cur = lastPointOf(currentSubpath);
+					const c2 = applyMatrix(gs.ctm, {
+						x: numAt(operands, 0),
+						y: numAt(operands, 1)
+					});
+					const p = applyMatrix(gs.ctm, {
+						x: numAt(operands, 2),
+						y: numAt(operands, 3)
+					});
+					currentSubpath.segments.push({
+						kind: "cubic",
+						c1xPt: cur.x,
+						c1yPt: cur.y,
+						c2xPt: c2.x,
+						c2yPt: c2.y,
+						xPt: p.x,
+						yPt: p.y
+					});
+				}
+				pendingRect = void 0;
+				break;
+			case "y": {
+				const c1 = applyMatrix(gs.ctm, {
+					x: numAt(operands, 0),
+					y: numAt(operands, 1)
+				});
+				const p = applyMatrix(gs.ctm, {
+					x: numAt(operands, 2),
+					y: numAt(operands, 3)
+				});
+				currentSubpath?.segments.push({
+					kind: "cubic",
+					c1xPt: c1.x,
+					c1yPt: c1.y,
+					c2xPt: p.x,
+					c2yPt: p.y,
+					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 = {
+					...gs,
+					lineWidth: numAt(operands, 0)
+				};
+				break;
+			case "f":
+			case "F":
+			case "f*":
+			case "S":
+			case "s":
+			case "B":
+			case "B*":
+			case "b":
+			case "b*":
+			case "n":
+				emitPaint(operator);
+				break;
+			case "BT":
+				ts = defaultTextState();
+				break;
+			case "Tf":
+				ts.fontResourceName = asName(operands[0]);
+				ts.fontSizePt = numAt(operands, 1);
+				break;
+			case "Tc":
+				ts.charSpace = numAt(operands, 0);
+				break;
+			case "Tw":
+				ts.wordSpace = numAt(operands, 0);
+				break;
+			case "Tz":
+				ts.horizScale = numAt(operands, 0) / 100;
+				break;
+			case "TL":
+				ts.leading = numAt(operands, 0);
+				break;
+			case "Ts":
+				ts.rise = numAt(operands, 0);
+				break;
+			case "Td":
+				ts.tlm = multiplyMatrices(translationMatrix(numAt(operands, 0), numAt(operands, 1)), ts.tlm);
+				ts.tm = ts.tlm;
+				break;
+			case "TD":
+				ts.leading = -numAt(operands, 1);
+				ts.tlm = multiplyMatrices(translationMatrix(numAt(operands, 0), numAt(operands, 1)), ts.tlm);
+				ts.tm = ts.tlm;
+				break;
+			case "Tm":
+				ts.tlm = matrixFromOperands(operands);
+				ts.tm = ts.tlm;
+				break;
+			case "T*":
+				nextLine();
+				break;
+			case "Tj": {
+				const str = operands[0];
+				if (str?.kind === "string") showText(str.bytes);
+				break;
+			}
+			case "'": {
+				nextLine();
+				const str = operands[0];
+				if (str?.kind === "string") showText(str.bytes);
+				break;
+			}
+			case "\"": {
+				ts.wordSpace = numAt(operands, 0);
+				ts.charSpace = numAt(operands, 1);
+				nextLine();
+				const str = operands[2];
+				if (str?.kind === "string") showText(str.bytes);
+				break;
+			}
+			case "TJ": {
+				const array = asArray(operands[0]);
+				if (array !== void 0) showTextArray(array);
+				break;
+			}
+			case "Do": handleDo(asName(operands[0]));
+		}
+	}
+}
+//#endregion
+export { interpretContentStream };