pdf-codec 1.3.1 → 1.4.0

package/dist/read.cjs

@@ -0,0 +1,418 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_util_base64 = require("./util/base64.cjs");
+const require_bytes_crc32 = require("./bytes/crc32.cjs");
+const require_bytes_writer = require("./bytes/writer.cjs");
+const require_diagnostics = require("./diagnostics.cjs");
+const require_objects = require("./objects.cjs");
+const require_filters = require("./filters.cjs");
+const require_document = require("./document.cjs");
+const require_util_abort = require("./util/abort.cjs");
+const require_font_read = require("./font-read.cjs");
+const require_images_read = require("./images-read.cjs");
+const require_matrix = require("./matrix.cjs");
+const require_interpret = require("./interpret.cjs");
+require("./write.cjs");
+let document_schema_js = require("document-schema.js");
+//#region src/read.ts
+const PDF_HEADER_BYTES = new TextEncoder().encode("%PDF-");
+const HEADER_SEARCH_WINDOW = 1024;
+const DEFAULT_PAGE_WIDTH_PT = 612;
+const DEFAULT_PAGE_HEIGHT_PT = 792;
+function hasPdfHeader(bytes) {
+	const window = bytes.subarray(0, Math.min(HEADER_SEARCH_WINDOW, bytes.length));
+	outer: for (let i = 0; i <= window.length - PDF_HEADER_BYTES.length; i++) {
+		for (let j = 0; j < PDF_HEADER_BYTES.length; j++) if (window[i + j] !== PDF_HEADER_BYTES[j]) continue outer;
+		return true;
+	}
+	return false;
+}
+function readPdf(bytes, options) {
+	const sink = options?.sink ?? require_diagnostics.NOOP_DIAGNOSTIC_SINK;
+	const signal = options?.signal;
+	if (!hasPdfHeader(bytes)) throw new require_diagnostics.PdfParseError("pdf/no-header", "no \"%PDF-\" header found within the first bytes of the file; this does not look like a PDF at all");
+	const doc = require_document.openPdfDocument(bytes, sink);
+	const fontResolver = require_font_read.createFontResolver({
+		resolver: doc,
+		sink
+	});
+	const images = {};
+	const imageIdCache = /* @__PURE__ */ new Map();
+	const pages = doc.pages().map((pageDict) => {
+		require_util_abort.throwIfAborted(signal);
+		return readPage(pageDict, doc, fontResolver, images, imageIdCache, sink);
+	});
+	return {
+		formatVersion: document_schema_js.LAYOUT_FORMAT_VERSION,
+		metadata: readMetadata(doc.trailer, doc),
+		pages,
+		images
+	};
+}
+function readMediaBox(page) {
+	const arr = require_objects.asArray(require_objects.dictGet(page, "MediaBox"));
+	if (arr === void 0) return {
+		llx: 0,
+		lly: 0,
+		urx: DEFAULT_PAGE_WIDTH_PT,
+		ury: DEFAULT_PAGE_HEIGHT_PT
+	};
+	const a = require_objects.asNumber(arr[0]) ?? 0;
+	const b = require_objects.asNumber(arr[1]) ?? 0;
+	const c = require_objects.asNumber(arr[2]) ?? DEFAULT_PAGE_WIDTH_PT;
+	const d = require_objects.asNumber(arr[3]) ?? DEFAULT_PAGE_HEIGHT_PT;
+	return {
+		llx: Math.min(a, c),
+		lly: Math.min(b, d),
+		urx: Math.max(a, c),
+		ury: Math.max(b, d)
+	};
+}
+function normalizeRotation(rotate) {
+	if (rotate === void 0) return 0;
+	const normalized = (Math.round(rotate / 90) * 90 % 360 + 360) % 360;
+	return normalized === 90 || normalized === 180 || normalized === 270 ? normalized : 0;
+}
+function pageRotationTransform(rotation, w, h) {
+	if (rotation === 90) return {
+		matrix: [
+			0,
+			-1,
+			1,
+			0,
+			0,
+			w
+		],
+		widthPt: h,
+		heightPt: w
+	};
+	if (rotation === 180) return {
+		matrix: [
+			-1,
+			0,
+			0,
+			-1,
+			w,
+			h
+		],
+		widthPt: w,
+		heightPt: h
+	};
+	if (rotation === 270) return {
+		matrix: [
+			0,
+			1,
+			-1,
+			0,
+			h,
+			0
+		],
+		widthPt: h,
+		heightPt: w
+	};
+	return {
+		matrix: [
+			1,
+			0,
+			0,
+			1,
+			0,
+			0
+		],
+		widthPt: w,
+		heightPt: h
+	};
+}
+function readPageContentBytes(page, resolver, sink) {
+	const contentsObj = resolver.resolve(require_objects.dictGet(page, "Contents"));
+	if (contentsObj?.kind === "stream") return require_filters.decodeStream(contentsObj.raw, contentsObj.dict, sink).bytes;
+	if (contentsObj?.kind === "array") {
+		const chunks = [];
+		for (const item of contentsObj.items) {
+			const streamObj = resolver.resolve(item);
+			if (streamObj?.kind === "stream") chunks.push(require_filters.decodeStream(streamObj.raw, streamObj.dict, sink).bytes, new Uint8Array([10]));
+		}
+		return require_bytes_writer.concatBytes(chunks);
+	}
+	return /* @__PURE__ */ new Uint8Array(0);
+}
+function readPage(page, resolver, fontResolver, images, imageIdCache, sink) {
+	const resources = resolver.resolveDict(require_objects.dictGet(page, "Resources"));
+	const mediaBox = readMediaBox(page);
+	const rotationResult = pageRotationTransform(normalizeRotation(require_objects.asNumber(require_objects.dictGet(page, "Rotate"))), mediaBox.urx - mediaBox.llx, mediaBox.ury - mediaBox.lly);
+	const pageMatrix = require_matrix.multiplyMatrices(require_matrix.translationMatrix(-mediaBox.llx, -mediaBox.lly), rotationResult.matrix);
+	const items = [];
+	if (resources !== void 0) {
+		const contentBytes = readPageContentBytes(page, resolver, sink);
+		const extracted = require_interpret.interpretContentStream(contentBytes, resources, {
+			fontMetrics: fontResolver.metrics,
+			resolver,
+			sink
+		});
+		for (const item of extracted) {
+			const converted = convertExtractedItem(item, pageMatrix, fontResolver, images, imageIdCache, resolver, sink);
+			if (converted !== void 0) items.push(converted);
+		}
+	} else sink({
+		code: "pdf/object-missing-value",
+		severity: "warning",
+		message: "page has no /Resources dict; its content stream cannot be interpreted"
+	});
+	items.push(...readLinkAnnotations(page, pageMatrix, resolver));
+	const notes = readPageNotes(page, resolver);
+	return {
+		widthPt: rotationResult.widthPt,
+		heightPt: rotationResult.heightPt,
+		items,
+		...notes !== void 0 ? { notes } : {}
+	};
+}
+function convertExtractedItem(item, pageMatrix, fontResolver, images, imageIdCache, resolver, sink) {
+	if (item.kind === "text") return convertText(item, pageMatrix, fontResolver);
+	if (item.kind === "rect") return convertRect(item, pageMatrix);
+	if (item.kind === "path") return convertPath(item, pageMatrix);
+	if (item.kind === "image") return convertImage(item, pageMatrix, images, imageIdCache, resolver, sink);
+	return convertInlineImage(item, pageMatrix, images, resolver, sink);
+}
+function convertText(item, pageMatrix, fontResolver) {
+	const font = fontResolver.resolve(item.fontResourceName, item.resources);
+	const text = font?.decodeToUnicode(item.codes) ?? "";
+	if (text.length === 0) return;
+	const startTrm = require_matrix.multiplyMatrices(item.startMatrix, pageMatrix);
+	const endTrm = require_matrix.multiplyMatrices(item.endMatrix, pageMatrix);
+	const widthPt = Math.hypot(endTrm[4] - startTrm[4], endTrm[5] - startTrm[5]);
+	const sizePt = require_matrix.matrixScaleX(startTrm);
+	const rotationDeg = require_matrix.matrixRotationDegrees(startTrm);
+	const layoutFont = {
+		family: font?.family ?? "Helvetica",
+		weight: font?.bold === true ? "bold" : "normal",
+		style: font?.italic === true ? "italic" : "normal"
+	};
+	return {
+		kind: "text",
+		text,
+		xPt: startTrm[4],
+		yPt: startTrm[5],
+		font: layoutFont,
+		sizePt: sizePt > 0 ? sizePt : item.sizePt,
+		color: item.color,
+		widthPt,
+		rotationDeg: rotationDeg !== 0 ? rotationDeg : void 0
+	};
+}
+function convertRect(item, pageMatrix) {
+	const p1 = require_matrix.applyMatrix(pageMatrix, {
+		x: item.xPt,
+		y: item.yPt
+	});
+	const p2 = require_matrix.applyMatrix(pageMatrix, {
+		x: item.xPt + item.widthPt,
+		y: item.yPt + item.heightPt
+	});
+	return {
+		kind: "rect",
+		xPt: Math.min(p1.x, p2.x),
+		yPt: Math.min(p1.y, p2.y),
+		widthPt: Math.abs(p2.x - p1.x),
+		heightPt: Math.abs(p2.y - p1.y),
+		fill: item.color
+	};
+}
+function transformSubpath(subpath, pageMatrix) {
+	const start = require_matrix.applyMatrix(pageMatrix, {
+		x: subpath.startXPt,
+		y: subpath.startYPt
+	});
+	const segments = subpath.segments.map((segment) => {
+		if (segment.kind === "line") {
+			const p = require_matrix.applyMatrix(pageMatrix, {
+				x: segment.xPt,
+				y: segment.yPt
+			});
+			return {
+				kind: "line",
+				xPt: p.x,
+				yPt: p.y
+			};
+		}
+		const c1 = require_matrix.applyMatrix(pageMatrix, {
+			x: segment.c1xPt,
+			y: segment.c1yPt
+		});
+		const c2 = require_matrix.applyMatrix(pageMatrix, {
+			x: segment.c2xPt,
+			y: segment.c2yPt
+		});
+		const p = require_matrix.applyMatrix(pageMatrix, {
+			x: segment.xPt,
+			y: segment.yPt
+		});
+		return {
+			kind: "cubic",
+			c1xPt: c1.x,
+			c1yPt: c1.y,
+			c2xPt: c2.x,
+			c2yPt: c2.y,
+			xPt: p.x,
+			yPt: p.y
+		};
+	});
+	return {
+		startXPt: start.x,
+		startYPt: start.y,
+		segments,
+		closed: subpath.closed
+	};
+}
+function convertPath(item, pageMatrix) {
+	return {
+		kind: "path",
+		subpaths: item.subpaths.map((subpath) => transformSubpath(subpath, pageMatrix)),
+		...item.fill !== void 0 ? { fill: item.fill } : {},
+		...item.fill !== void 0 && item.fillRule === "evenodd" ? { fillRule: "evenodd" } : {},
+		...item.stroke !== void 0 ? { stroke: item.stroke } : {}
+	};
+}
+function imagePlacementFrom(matrix) {
+	const rotationDeg = require_matrix.matrixRotationDegrees(matrix);
+	return {
+		xPt: matrix[4],
+		yPt: matrix[5],
+		widthPt: require_matrix.matrixScaleX(matrix),
+		heightPt: require_matrix.matrixScaleY(matrix),
+		rotationDeg: rotationDeg !== 0 ? rotationDeg : void 0
+	};
+}
+function registerExtractedImage(format, bytes, widthPx, heightPx, images) {
+	const imageId = `img${require_bytes_crc32.crc32(bytes).toString(16)}`;
+	if (!(imageId in images)) images[imageId] = {
+		format,
+		base64: require_util_base64.bytesToBase64(bytes),
+		widthPx,
+		heightPx
+	};
+	return imageId;
+}
+function resolveCachedImageId(dict, raw, images, cache, resolver, sink) {
+	if (cache.has(dict)) return cache.get(dict) ?? void 0;
+	const decoded = require_images_read.readImageXObject(dict, raw, resolver, sink);
+	if (decoded === void 0) {
+		cache.set(dict, null);
+		return;
+	}
+	const imageId = registerExtractedImage(decoded.format, decoded.bytes, decoded.widthPx, decoded.heightPx, images);
+	cache.set(dict, imageId);
+	return imageId;
+}
+function convertImage(item, pageMatrix, images, cache, resolver, sink) {
+	const xobjects = resolver.resolveDict(require_objects.dictGet(item.resources, "XObject"));
+	const xobj = xobjects !== void 0 ? resolver.resolve(require_objects.dictGet(xobjects, item.resourceName)) : void 0;
+	if (xobj?.kind !== "stream") return;
+	const imageId = resolveCachedImageId(xobj.dict, xobj.raw, images, cache, resolver, sink);
+	if (imageId === void 0) return;
+	return {
+		kind: "image",
+		imageId,
+		...imagePlacementFrom(require_matrix.multiplyMatrices(item.matrix, pageMatrix))
+	};
+}
+function convertInlineImage(item, pageMatrix, images, resolver, sink) {
+	const decoded = require_images_read.readImageXObject(item.dict, item.data, resolver, sink);
+	if (decoded === void 0) return;
+	return {
+		kind: "image",
+		imageId: registerExtractedImage(decoded.format, decoded.bytes, decoded.widthPx, decoded.heightPx, images),
+		...imagePlacementFrom(require_matrix.multiplyMatrices(item.matrix, pageMatrix))
+	};
+}
+function readLinkAnnotations(page, pageMatrix, resolver) {
+	const annotsArr = require_objects.asArray(require_objects.dictGet(page, "Annots"));
+	if (annotsArr === void 0) return [];
+	const links = [];
+	for (const annotRef of annotsArr) {
+		const annot = resolver.resolveDict(annotRef);
+		if (annot === void 0 || require_objects.asName(require_objects.dictGet(annot, "Subtype")) !== "Link") continue;
+		const uri = readLinkUri(annot, resolver);
+		const rectArr = require_objects.asArray(require_objects.dictGet(annot, "Rect"));
+		if (uri === void 0 || rectArr === void 0) continue;
+		const x1 = require_objects.asNumber(rectArr[0]) ?? 0;
+		const y1 = require_objects.asNumber(rectArr[1]) ?? 0;
+		const x2 = require_objects.asNumber(rectArr[2]) ?? 0;
+		const y2 = require_objects.asNumber(rectArr[3]) ?? 0;
+		const p1 = require_matrix.applyMatrix(pageMatrix, {
+			x: Math.min(x1, x2),
+			y: Math.min(y1, y2)
+		});
+		const p2 = require_matrix.applyMatrix(pageMatrix, {
+			x: Math.max(x1, x2),
+			y: Math.max(y1, y2)
+		});
+		links.push({
+			kind: "link",
+			uri,
+			xPt: Math.min(p1.x, p2.x),
+			yPt: Math.min(p1.y, p2.y),
+			widthPt: Math.abs(p2.x - p1.x),
+			heightPt: Math.abs(p2.y - p1.y)
+		});
+	}
+	return links;
+}
+function readLinkUri(annot, resolver) {
+	const action = resolver.resolveDict(require_objects.dictGet(annot, "A"));
+	if (action === void 0 || require_objects.asName(require_objects.dictGet(action, "S")) !== "URI") return;
+	const uriObj = require_objects.dictGet(action, "URI");
+	return uriObj?.kind === "string" ? decodePdfString(uriObj.bytes) : void 0;
+}
+function readPageNotes(page, resolver) {
+	const annotsArr = require_objects.asArray(require_objects.dictGet(page, "Annots"));
+	if (annotsArr === void 0) return;
+	for (const annotRef of annotsArr) {
+		const annot = resolver.resolveDict(annotRef);
+		if (annot === void 0 || require_objects.asName(require_objects.dictGet(annot, "Subtype")) !== "Text") continue;
+		const titleObj = require_objects.dictGet(annot, "T");
+		if ((titleObj?.kind === "string" ? decodePdfString(titleObj.bytes) : void 0) !== "documents.js:notes") continue;
+		const contentsObj = require_objects.dictGet(annot, "Contents");
+		if (contentsObj?.kind === "string") return decodePdfString(contentsObj.bytes);
+	}
+}
+function decodePdfString(bytes) {
+	if (bytes.length >= 2 && bytes[0] === 254 && bytes[1] === 255) {
+		let out = "";
+		for (let i = 2; i + 1 < bytes.length; i += 2) out += String.fromCharCode((bytes[i] ?? 0) << 8 | (bytes[i + 1] ?? 0));
+		return out;
+	}
+	return Array.from(bytes, (b) => String.fromCharCode(b)).join("");
+}
+const PDF_DATE_PATTERN = /^D:(\d{4})(\d{2})?(\d{2})?(\d{2})?(\d{2})?(\d{2})?([+\-Z])?(\d{2})?'?(\d{2})?'?$/;
+function parsePdfDate(raw) {
+	if (raw === void 0) return;
+	const match = PDF_DATE_PATTERN.exec(raw);
+	if (match === null) return;
+	const [, year, month = "01", day = "01", hour = "00", minute = "00", second = "00", tzSign, tzHour = "00", tzMinute = "00"] = match;
+	return `${year}-${month}-${day}T${hour}:${minute}:${second}${tzSign === void 0 || tzSign === "Z" ? "Z" : `${tzSign}${tzHour}:${tzMinute}`}`;
+}
+function readMetadata(trailer, resolver) {
+	const info = resolver.resolveDict(require_objects.dictGet(trailer, "Info"));
+	if (info === void 0) return {};
+	const stringField = (key) => {
+		const obj = require_objects.dictGet(info, key);
+		return obj?.kind === "string" ? decodePdfString(obj.bytes) : void 0;
+	};
+	const keywords = stringField("Keywords")?.split(",").map((k) => k.trim()).filter((k) => k.length > 0);
+	return {
+		title: stringField("Title"),
+		author: stringField("Author"),
+		subject: stringField("Subject"),
+		keywords: keywords !== void 0 && keywords.length > 0 ? keywords : void 0,
+		creator: stringField("Creator"),
+		producer: stringField("Producer"),
+		createdIso: parsePdfDate(stringField("CreationDate")),
+		modifiedIso: parsePdfDate(stringField("ModDate"))
+	};
+}
+//#endregion
+exports.decodePdfString = decodePdfString;
+exports.normalizeRotation = normalizeRotation;
+exports.pageRotationTransform = pageRotationTransform;
+exports.parsePdfDate = parsePdfDate;
+exports.readPdf = readPdf;

package/dist/read.d.cts

@@ -0,0 +1,21 @@
+import { PdfDiagnosticSink } from "./diagnostics.cjs";
+import { n as Matrix } from "./matrix-B3c2_a2f.cjs";
+import { LayoutDocument } from "document-schema.js";
+//#region src/read.d.ts
+interface ReadPdfOptions {
+  readonly sink?: PdfDiagnosticSink;
+  readonly signal?: AbortSignal;
+}
+declare function readPdf(bytes: Uint8Array<ArrayBuffer>, options?: ReadPdfOptions): LayoutDocument;
+type PageRotation = 0 | 90 | 180 | 270;
+declare function normalizeRotation(rotate: number | undefined): PageRotation;
+interface PageRotationResult {
+  readonly matrix: Matrix;
+  readonly widthPt: number;
+  readonly heightPt: number;
+}
+declare function pageRotationTransform(rotation: PageRotation, w: number, h: number): PageRotationResult;
+declare function decodePdfString(bytes: Uint8Array<ArrayBuffer>): string;
+declare function parsePdfDate(raw: string | undefined): string | undefined;
+//#endregion
+export { ReadPdfOptions, decodePdfString, normalizeRotation, pageRotationTransform, parsePdfDate, readPdf };

package/dist/read.d.ts

@@ -0,0 +1,21 @@
+import { PdfDiagnosticSink } from "./diagnostics.js";
+import { n as Matrix } from "./matrix-B3c2_a2f.js";
+import { LayoutDocument } from "document-schema.js";
+//#region src/read.d.ts
+interface ReadPdfOptions {
+  readonly sink?: PdfDiagnosticSink;
+  readonly signal?: AbortSignal;
+}
+declare function readPdf(bytes: Uint8Array<ArrayBuffer>, options?: ReadPdfOptions): LayoutDocument;
+type PageRotation = 0 | 90 | 180 | 270;
+declare function normalizeRotation(rotate: number | undefined): PageRotation;
+interface PageRotationResult {
+  readonly matrix: Matrix;
+  readonly widthPt: number;
+  readonly heightPt: number;
+}
+declare function pageRotationTransform(rotation: PageRotation, w: number, h: number): PageRotationResult;
+declare function decodePdfString(bytes: Uint8Array<ArrayBuffer>): string;
+declare function parsePdfDate(raw: string | undefined): string | undefined;
+//#endregion
+export { ReadPdfOptions, decodePdfString, normalizeRotation, pageRotationTransform, parsePdfDate, readPdf };