pdf-parser.js 5.2.30 → 5.3.1

package/dist/interpret-aWWhdIzr.js

@@ -0,0 +1,677 @@
+import { asArray, asName, asNumber, dictGet } from "./objects.js";
+import { IDENTITY_MATRIX, applyMatrix, multiplyMatrices, translationMatrix } from "./matrix.js";
+import { decodeStream } from "./filters.js";
+import { readContentStream } from "./content-read.js";
+import { MarkedContentStack, classifyShape, strokeStyleFromDashArray } from "./interpret-shapes.js";
+import { markedContentProperties, markedContentScopeProps } from "./interpret-marked.js";
+import { COLOR_BLACK } from "document-schema.js";
+//#region src/interpret-colors.ts
+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)
+	};
+}
+const CMYK_K_INDEX = 3;
+function cmykColor(operands) {
+	const c = numAt(operands, 0);
+	const m = numAt(operands, 1);
+	const y = numAt(operands, 2);
+	const k = numAt(operands, CMYK_K_INDEX);
+	return {
+		r: (1 - c) * (1 - k),
+		g: (1 - m) * (1 - k),
+		b: (1 - y) * (1 - k)
+	};
+}
+const RGB_COMPONENT_COUNT = 3;
+const CMYK_COMPONENT_COUNT = 4;
+function genericColor(operands) {
+	const numericOperands = operands.filter((o) => o.kind === "number");
+	if (numericOperands.length === 1) return grayColor(numAt(numericOperands, 0));
+	if (numericOperands.length === RGB_COMPONENT_COUNT) return rgbColor(numericOperands);
+	if (numericOperands.length === CMYK_COMPONENT_COUNT) return cmykColor(numericOperands);
+}
+//#endregion
+//#region src/interpret.ts
+const MAX_FORM_XOBJECT_DEPTH = 12;
+const FALLBACK_GLYPH_WIDTH_PER_1000 = 500;
+const GLYPH_SPACE_PER_TEXT_SPACE_UNIT = 1e3;
+const ASCII_SPACE = 32;
+const DEFAULT_LINE_WIDTH_PT = 1;
+function initialTextParameters() {
+	return {
+		fontResourceName: void 0,
+		fontSizePt: 0,
+		charSpace: 0,
+		wordSpace: 0,
+		horizScale: 1,
+		leading: 0,
+		rise: 0
+	};
+}
+function defaultTextObjectState() {
+	return {
+		tm: IDENTITY_MATRIX,
+		tlm: IDENTITY_MATRIX
+	};
+}
+function computeTrm(gs, text) {
+	const fontMatrix = [
+		gs.fontSizePt * gs.horizScale,
+		0,
+		0,
+		gs.fontSizePt,
+		0,
+		gs.rise
+	];
+	return multiplyMatrices(multiplyMatrices(fontMatrix, text.tm), gs.ctm);
+}
+function numAt(operands, index) {
+	return asNumber(operands[index]) ?? 0;
+}
+const MATRIX_D_INDEX = 3;
+const MATRIX_E_INDEX = 4;
+const MATRIX_F_INDEX = 5;
+function matrixFromOperands(operands) {
+	return [
+		numAt(operands, 0),
+		numAt(operands, 1),
+		numAt(operands, 2),
+		numAt(operands, MATRIX_D_INDEX),
+		numAt(operands, MATRIX_E_INDEX),
+		numAt(operands, MATRIX_F_INDEX)
+	];
+}
+const RE_HEIGHT_INDEX = 3;
+const OPERAND_INDEX_3 = 3;
+const OPERAND_INDEX_4 = 4;
+const OPERAND_INDEX_5 = 5;
+const TZ_PERCENT_DIVISOR = 100;
+function interpretContentStream(bytes, resources, context) {
+	return runContentStream(bytes, resources, {
+		ctm: IDENTITY_MATRIX,
+		fillColor: COLOR_BLACK,
+		strokeColor: COLOR_BLACK,
+		lineWidth: DEFAULT_LINE_WIDTH_PT,
+		dashArray: [],
+		...initialTextParameters()
+	}, context, 0, new MarkedContentStack());
+}
+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, depth, markedContent) {
+	const items = [];
+	const operations = readContentStream(bytes, context.sink);
+	const gsStack = [];
+	let gs = initialState;
+	let text = defaultTextObjectState();
+	let pathSubpaths = [];
+	let currentSubpath;
+	const inScope = (key) => markedContent.inScope(key);
+	const pushItem = (item) => {
+		if (item.kind === "text") {
+			const layer = item.layerName ?? inScope("layerName");
+			const actualText = inScope("actualText");
+			const alt = inScope("alt");
+			const mcid = inScope("mcid");
+			items.push({
+				...item,
+				...layer !== void 0 ? { layerName: layer } : {},
+				...actualText !== void 0 ? { actualText } : {},
+				...alt !== void 0 ? { alt } : {},
+				...mcid !== void 0 ? { mcid } : {}
+			});
+			return;
+		}
+		const layer = item.layerName ?? inScope("layerName");
+		const layerStamped = layer === void 0 ? item : {
+			...item,
+			layerName: layer
+		};
+		const mcid = inScope("mcid");
+		items.push(mcid === void 0 ? layerStamped : {
+			...layerStamped,
+			mcid
+		});
+	};
+	const finalizeCurrentSubpath = () => {
+		if (currentSubpath !== void 0) {
+			pathSubpaths.push(currentSubpath);
+			currentSubpath = void 0;
+		}
+	};
+	const resetPath = () => {
+		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, RE_HEIGHT_INDEX);
+		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;
+		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*";
+			const paint = {
+				fill: isFillOp ? gs.fillColor : void 0,
+				stroke: isStrokeOp ? {
+					color: gs.strokeColor,
+					widthPt: gs.lineWidth
+				} : void 0
+			};
+			const strokeStyle = isStrokeOp ? strokeStyleFromDashArray(gs.dashArray) : void 0;
+			pushItem(classifyShape(pathSubpaths, paint, strokeStyle) ?? {
+				kind: "path",
+				subpaths: pathSubpaths,
+				fillRule: paintFillRuleFor(operator),
+				...paint,
+				...strokeStyle !== void 0 ? { style: strokeStyle } : {}
+			});
+		}
+		resetPath();
+	};
+	const advanceThroughString = (codes) => {
+		const fontResourceName = gs.fontResourceName;
+		if (fontResourceName === void 0) return;
+		let offset = 0;
+		while (offset < codes.length) {
+			const glyph = context.fontMetrics.glyphAdvance(fontResourceName, resources, codes, offset);
+			if (glyph === void 0) context.sink({
+				code: "pdf/font-not-resolved",
+				severity: "warning",
+				message: `could not resolve font resource /${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] === ASCII_SPACE;
+			const spacing = gs.charSpace + (isSingleByteSpace ? gs.wordSpace : 0);
+			const vertical = glyph?.vertical;
+			text.tm = vertical === void 0 ? multiplyMatrices(translationMatrix((widthPer1000 / GLYPH_SPACE_PER_TEXT_SPACE_UNIT * gs.fontSizePt + spacing) * gs.horizScale, 0), text.tm) : multiplyMatrices(translationMatrix(0, vertical.displacementPer1000 / GLYPH_SPACE_PER_TEXT_SPACE_UNIT * gs.fontSizePt + spacing), text.tm);
+			offset += byteLength;
+		}
+	};
+	const positionVectorOf = (codes) => {
+		const fontResourceName = gs.fontResourceName;
+		if (fontResourceName === void 0) return;
+		const vertical = context.fontMetrics.glyphAdvance(fontResourceName, resources, codes, 0)?.vertical;
+		if (vertical === void 0) return;
+		return {
+			x: vertical.positionXPer1000 / GLYPH_SPACE_PER_TEXT_SPACE_UNIT,
+			y: vertical.positionYPer1000 / GLYPH_SPACE_PER_TEXT_SPACE_UNIT
+		};
+	};
+	const showTextArray = (elements) => {
+		const fontResourceName = gs.fontResourceName;
+		if (fontResourceName === void 0) return;
+		const vertical = context.fontMetrics.isVertical(fontResourceName, resources);
+		const startMatrix = computeTrm(gs, text);
+		const chunks = [];
+		let totalLength = 0;
+		let firstGlyphPosition;
+		for (const el of elements) if (el.kind === "string") {
+			firstGlyphPosition ??= vertical ? positionVectorOf(el.bytes) : void 0;
+			chunks.push(el.bytes);
+			totalLength += el.bytes.length;
+			advanceThroughString(el.bytes);
+		} else if (el.kind === "number") {
+			const adjustment = -(el.value / GLYPH_SPACE_PER_TEXT_SPACE_UNIT) * gs.fontSizePt;
+			text.tm = multiplyMatrices(vertical ? translationMatrix(0, adjustment) : translationMatrix(adjustment * gs.horizScale, 0), text.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, text);
+		const shift = firstGlyphPosition === void 0 ? void 0 : translationMatrix(-firstGlyphPosition.x, -firstGlyphPosition.y);
+		pushItem({
+			kind: "text",
+			codes: combined,
+			fontResourceName,
+			resources,
+			startMatrix: shift === void 0 ? startMatrix : multiplyMatrices(shift, startMatrix),
+			endMatrix: shift === void 0 ? endMatrix : multiplyMatrices(shift, endMatrix),
+			sizePt: gs.fontSizePt,
+			color: gs.fillColor,
+			...vertical ? { vertical: true } : {}
+		});
+	};
+	const showText = (textBytes) => {
+		showTextArray([{
+			kind: "string",
+			bytes: textBytes,
+			hex: false
+		}]);
+	};
+	const nextLine = () => {
+		text.tlm = multiplyMatrices(translationMatrix(0, -gs.leading), text.tlm);
+		text.tm = text.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"));
+		const ownLayer = context.layerNameOf?.(dictGet(xobj.dict, "OC"));
+		if (subtype === "Image") {
+			pushItem({
+				kind: "image",
+				resourceName: name,
+				resources,
+				matrix: gs.ctm,
+				...ownLayer !== void 0 ? { layerName: ownLayer } : {}
+			});
+			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)
+			};
+			const formLayer = ownLayer ?? inScope("layerName");
+			const formMcid = dictGet(xobj.dict, "StructParents") !== void 0 ? void 0 : inScope("mcid");
+			for (const formItem of runContentStream(decoded.bytes, formResources, formState, context, depth + 1, new MarkedContentStack([{
+				...formLayer !== void 0 ? { layerName: formLayer } : {},
+				...formMcid !== void 0 ? { mcid: formMcid } : {}
+			}]))) items.push(formItem);
+		}
+	};
+	for (const token of operations) {
+		if (token.kind === "inlineImage") {
+			pushItem({
+				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":
+				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
+				};
+				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
+				});
+				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, OPERAND_INDEX_3)
+				});
+				const p = applyMatrix(gs.ctm, {
+					x: numAt(operands, OPERAND_INDEX_4),
+					y: numAt(operands, OPERAND_INDEX_5)
+				});
+				currentSubpath?.segments.push({
+					kind: "cubic",
+					c1xPt: c1.x,
+					c1yPt: c1.y,
+					c2xPt: c2.x,
+					c2yPt: c2.y,
+					xPt: p.x,
+					yPt: p.y
+				});
+				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, OPERAND_INDEX_3)
+					});
+					currentSubpath.segments.push({
+						kind: "cubic",
+						c1xPt: cur.x,
+						c1yPt: cur.y,
+						c2xPt: c2.x,
+						c2yPt: c2.y,
+						xPt: p.x,
+						yPt: p.y
+					});
+				}
+				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, OPERAND_INDEX_3)
+				});
+				currentSubpath?.segments.push({
+					kind: "cubic",
+					c1xPt: c1.x,
+					c1yPt: c1.y,
+					c2xPt: p.x,
+					c2yPt: p.y,
+					xPt: p.x,
+					yPt: p.y
+				});
+				break;
+			}
+			case "h":
+				if (currentSubpath !== void 0) currentSubpath.closed = true;
+				break;
+			case "w":
+				gs = {
+					...gs,
+					lineWidth: numAt(operands, 0)
+				};
+				break;
+			case "d":
+				gs = {
+					...gs,
+					dashArray: (asArray(operands[0]) ?? []).map((entry) => asNumber(entry) ?? 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":
+				text = defaultTextObjectState();
+				break;
+			case "Tf":
+				gs = {
+					...gs,
+					fontResourceName: asName(operands[0]),
+					fontSizePt: numAt(operands, 1)
+				};
+				break;
+			case "Tc":
+				gs = {
+					...gs,
+					charSpace: numAt(operands, 0)
+				};
+				break;
+			case "Tw":
+				gs = {
+					...gs,
+					wordSpace: numAt(operands, 0)
+				};
+				break;
+			case "Tz":
+				gs = {
+					...gs,
+					horizScale: numAt(operands, 0) / TZ_PERCENT_DIVISOR
+				};
+				break;
+			case "TL":
+				gs = {
+					...gs,
+					leading: numAt(operands, 0)
+				};
+				break;
+			case "Ts":
+				gs = {
+					...gs,
+					rise: numAt(operands, 0)
+				};
+				break;
+			case "Td":
+				text.tlm = multiplyMatrices(translationMatrix(numAt(operands, 0), numAt(operands, 1)), text.tlm);
+				text.tm = text.tlm;
+				break;
+			case "TD":
+				gs = {
+					...gs,
+					leading: -numAt(operands, 1)
+				};
+				text.tlm = multiplyMatrices(translationMatrix(numAt(operands, 0), numAt(operands, 1)), text.tlm);
+				text.tm = text.tlm;
+				break;
+			case "Tm":
+				text.tlm = matrixFromOperands(operands);
+				text.tm = text.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 "\"": {
+				gs = {
+					...gs,
+					wordSpace: numAt(operands, 0),
+					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]));
+				break;
+			case "BDC": {
+				const props = markedContentProperties(operands[1], resources, context.resolver);
+				const layerName = context.layerNameOf?.(props === void 0 ? void 0 : dictGet(props, "OC"));
+				const scopeProps = {
+					...layerName !== void 0 ? { layerName } : {},
+					...markedContentScopeProps(props)
+				};
+				markedContent.open(depth === 0 ? scopeProps : {
+					...scopeProps,
+					mcid: void 0
+				});
+				break;
+			}
+			case "BMC":
+				markedContent.open({});
+				break;
+			case "EMC": markedContent.close();
+		}
+	}
+	return items;
+}
+//#endregion
+export { grayColor as a, genericColor as i, numAt as n, rgbColor as o, cmykColor as r, interpretContentStream as t };

package/dist/interpret-colors.cjs

@@ -0,0 +1,6 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_interpret = require("./interpret-CqXdXgkY.cjs");
+exports.cmykColor = require_interpret.cmykColor;
+exports.genericColor = require_interpret.genericColor;
+exports.grayColor = require_interpret.grayColor;
+exports.rgbColor = require_interpret.rgbColor;

package/dist/interpret-colors.d.cts

@@ -0,0 +1,9 @@
+import { r as PdfObject } from "./objects-e2RS3-yT.cjs";
+import { Color } from "document-schema.js";
+//#region src/interpret-colors.d.ts
+declare function grayColor(value: number): Color;
+declare function rgbColor(operands: readonly PdfObject[]): Color;
+declare function cmykColor(operands: readonly PdfObject[]): Color;
+declare function genericColor(operands: readonly PdfObject[]): Color | undefined;
+//#endregion
+export { cmykColor, genericColor, grayColor, rgbColor };

package/dist/interpret-colors.d.ts

@@ -0,0 +1,9 @@
+import { r as PdfObject } from "./objects-e2RS3-yT.js";
+import { Color } from "document-schema.js";
+//#region src/interpret-colors.d.ts
+declare function grayColor(value: number): Color;
+declare function rgbColor(operands: readonly PdfObject[]): Color;
+declare function cmykColor(operands: readonly PdfObject[]): Color;
+declare function genericColor(operands: readonly PdfObject[]): Color | undefined;
+//#endregion
+export { cmykColor, genericColor, grayColor, rgbColor };

package/dist/interpret-colors.js

@@ -0,0 +1,2 @@
+import { a as grayColor, i as genericColor, o as rgbColor, r as cmykColor } from "./interpret-aWWhdIzr.js";
+export { cmykColor, genericColor, grayColor, rgbColor };