pdf-parser.js 4.7.0 → 4.8.0

package/dist/raster.js

@@ -0,0 +1,815 @@
+import { asArray, asName, asNumber, dictGet } from "./objects.js";
+import { concatBytes } from "./bytes/writer.js";
+import { BEZIER_KAPPA, applyMatrix, multiplyMatrices, scaleMatrix, translationMatrix } from "./matrix.js";
+import { decodeStream } from "./filters.js";
+import { parseSfnt } from "./sfnt.js";
+import { buildCmapLookup } from "./cmap-table.js";
+import { parseHead, parseMaxp } from "./font-tables.js";
+import { readOptionalContent } from "./optional-content.js";
+import { NOOP_DIAGNOSTIC_SINK, PdfParseError } from "./diagnostics.js";
+import { openPdfDocument } from "./document.js";
+import { throwIfAborted } from "./util/abort.js";
+import { createFontResolver } from "./font-read.js";
+import { readImageXObject } from "./images-read.js";
+import { interpretContentStream } from "./interpret.js";
+import { normalizeRotation, pageRotationTransform } from "./read.js";
+import { parseGlyf } from "./glyf.js";
+import { decodeGlyphOutline } from "./glyf-contours.js";
+//#region src/raster.ts
+const FALLBACK_GLYPH_WIDTH_PER_1000 = 500;
+function regionPixels(extentPt, scale) {
+	return Math.max(1, Math.ceil(extentPt * scale - 1e-9));
+}
+function renderPdfPage(pdfBytes, pageIndex, options, rasteriser) {
+	const sink = options.sink ?? NOOP_DIAGNOSTIC_SINK;
+	if (options.scale !== void 0 && options.dpi !== void 0) throw new Error("renderPdfPage accepts at most one of scale and dpi; they name the same factor in different units (dpi = 72 x scale)");
+	const scale = options.dpi !== void 0 ? options.dpi / 72 : options.scale;
+	if (scale !== void 0 && !(scale > 0)) throw new Error(`renderPdfPage requires a positive scale factor (received scale ${options.scale}, dpi ${options.dpi})`);
+	const pixelsPerPt = scale ?? 1;
+	if (options.clipPt !== void 0 && (!(options.clipPt.widthPt > 0) || !(options.clipPt.heightPt > 0))) throw new Error("renderPdfPage clipPt must carry positive widthPt and heightPt; a zero-extent region has no pixels to render");
+	throwIfAborted(options.signal);
+	if (!hasPdfHeader(pdfBytes)) throw new 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 = openPdfDocument(pdfBytes, sink);
+	const pages = doc.pages();
+	if (pageIndex < 0 || pageIndex >= pages.length) throw new PdfParseError("pdf/page-index-out-of-range", `page index ${pageIndex} is outside this document's page tree (it declares ${pages.length} page${pages.length === 1 ? "" : "s"})`);
+	const page = pages[pageIndex];
+	const mediaBox = readMediaBox(page);
+	let cropBox = readDeclaredPageBox(page, "CropBox") ?? mediaBox;
+	if (cropBox.urx - cropBox.llx <= 0 || cropBox.ury - cropBox.lly <= 0) {
+		sink({
+			code: "pdf/invalid-crop-box",
+			severity: "warning",
+			pageIndex,
+			message: "page /CropBox is degenerate (zero width or height); falling back to the /MediaBox as the visible region"
+		});
+		cropBox = mediaBox;
+	}
+	const rotation = normalizeRotation(asNumber(dictGet(page, "Rotate")));
+	const rotationResult = pageRotationTransform(rotation, mediaBox.urx - mediaBox.llx, mediaBox.ury - mediaBox.lly);
+	const visibleRect = rotatedRectBounds(cropBox, rotationResult.matrix);
+	const pageWidthPt = visibleRect.maxX - visibleRect.minX;
+	const pageHeightPt = visibleRect.maxY - visibleRect.minY;
+	const pageMatrix = multiplyMatrices(rotationResult.matrix, translationMatrix(-visibleRect.minX, -visibleRect.minY));
+	const requested = options.clipPt ?? {
+		xPt: 0,
+		yPt: 0,
+		widthPt: pageWidthPt,
+		heightPt: pageHeightPt
+	};
+	const clipLeft = Math.max(0, requested.xPt);
+	const clipBottom = Math.max(0, requested.yPt);
+	const clipRight = Math.min(pageWidthPt, requested.xPt + requested.widthPt);
+	const clipTop = Math.min(pageHeightPt, requested.yPt + requested.heightPt);
+	if (clipRight - clipLeft <= 0 || clipTop - clipBottom <= 0) throw new Error(`renderPdfPage clipPt does not intersect the page's visible region (clip x ${requested.xPt}..${requested.xPt + requested.widthPt}, y ${requested.yPt}..${requested.yPt + requested.heightPt}; page 0..${pageWidthPt} x 0..${pageHeightPt})`);
+	const regionWidthPt = clipRight - clipLeft;
+	const regionHeightPt = clipTop - clipBottom;
+	const widthPx = regionPixels(regionWidthPt, pixelsPerPt);
+	const heightPx = regionPixels(regionHeightPt, pixelsPerPt);
+	const pageToDeviceMatrix = [
+		pixelsPerPt,
+		0,
+		0,
+		-pixelsPerPt,
+		-clipLeft * pixelsPerPt,
+		(clipBottom + regionHeightPt) * pixelsPerPt
+	];
+	const interpretToDeviceMatrix = multiplyMatrices(pageMatrix, pageToDeviceMatrix);
+	const resources = doc.resolveDict(dictGet(page, "Resources"));
+	rasteriser.beginPage({
+		widthPx,
+		heightPx,
+		scale: pixelsPerPt,
+		widthPt: regionWidthPt,
+		heightPt: regionHeightPt
+	});
+	if (resources === void 0) {
+		sink({
+			code: "pdf/object-missing-value",
+			severity: "warning",
+			message: "page has no /Resources dict; its content stream cannot be interpreted"
+		});
+		return rasteriser.finish();
+	}
+	const fontResolver = createFontResolver({
+		resolver: doc,
+		sink
+	});
+	const { layers, layerNameOf } = readOptionalContent(doc.catalog, doc, sink);
+	const hiddenLayers = new Set(layers.filter((layer) => !layer.visible).map((layer) => layer.name));
+	const extracted = interpretContentStream(readPageContentBytes(page, doc, sink), resources, {
+		fontMetrics: fontResolver.metrics,
+		resolver: doc,
+		sink,
+		layerNameOf
+	});
+	const outlineFaces = /* @__PURE__ */ new Map();
+	for (const item of extracted) {
+		throwIfAborted(options.signal);
+		if (item.layerName !== void 0 && hiddenLayers.has(item.layerName)) continue;
+		drawExtractedItem(item, doc, fontResolver, outlineFaces, interpretToDeviceMatrix, pixelsPerPt, rasteriser, sink);
+	}
+	return rasteriser.finish();
+}
+function drawExtractedItem(item, resolver, fontResolver, outlineFaces, interpretToDeviceMatrix, pixelsPerPt, rasteriser, sink) {
+	if (item.kind === "text") {
+		drawTextRun(item, fontResolver, resolver, outlineFaces, interpretToDeviceMatrix, rasteriser, sink);
+		return;
+	}
+	if (item.kind === "rect") {
+		drawRect(item, interpretToDeviceMatrix, pixelsPerPt, rasteriser);
+		return;
+	}
+	if (item.kind === "ellipse") {
+		drawEllipse(item, interpretToDeviceMatrix, pixelsPerPt, rasteriser);
+		return;
+	}
+	if (item.kind === "line") {
+		drawLine(item, interpretToDeviceMatrix, pixelsPerPt, rasteriser);
+		return;
+	}
+	if (item.kind === "path") {
+		drawPath(item, interpretToDeviceMatrix, pixelsPerPt, rasteriser);
+		return;
+	}
+	if (item.kind === "image") {
+		drawImageXObjectItem(item, resolver, interpretToDeviceMatrix, rasteriser, sink);
+		return;
+	}
+	drawInlineImageItem(item, resolver, interpretToDeviceMatrix, rasteriser, sink);
+}
+function drawRect(item, matrix, pixelsPerPt, rasteriser) {
+	const corners = [
+		applyMatrix(matrix, {
+			x: item.xPt,
+			y: item.yPt
+		}),
+		applyMatrix(matrix, {
+			x: item.xPt + item.widthPt,
+			y: item.yPt
+		}),
+		applyMatrix(matrix, {
+			x: item.xPt,
+			y: item.yPt + item.heightPt
+		}),
+		applyMatrix(matrix, {
+			x: item.xPt + item.widthPt,
+			y: item.yPt + item.heightPt
+		})
+	];
+	const minX = Math.min(...corners.map((corner) => corner.x));
+	const minY = Math.min(...corners.map((corner) => corner.y));
+	const maxX = Math.max(...corners.map((corner) => corner.x));
+	const maxY = Math.max(...corners.map((corner) => corner.y));
+	if (item.fill !== void 0) rasteriser.draw({
+		kind: "fillRect",
+		xPx: minX,
+		yPx: minY,
+		widthPx: maxX - minX,
+		heightPx: maxY - minY,
+		color: item.fill
+	});
+	if (item.stroke !== void 0) rasteriser.draw({
+		kind: "path",
+		subpaths: [{
+			startXPx: minX,
+			startYPx: minY,
+			segments: [
+				{
+					kind: "line",
+					xPx: maxX,
+					yPx: minY
+				},
+				{
+					kind: "line",
+					xPx: maxX,
+					yPx: maxY
+				},
+				{
+					kind: "line",
+					xPx: minX,
+					yPx: maxY
+				}
+			],
+			closed: true
+		}],
+		stroke: strokeSpec(item.stroke, void 0, pixelsPerPt)
+	});
+}
+function drawEllipse(item, matrix, pixelsPerPt, rasteriser) {
+	const cx = item.xPt + item.widthPt / 2;
+	const cy = item.yPt + item.heightPt / 2;
+	const rx = item.widthPt / 2;
+	const ry = item.heightPt / 2;
+	const dx = rx * BEZIER_KAPPA;
+	const dy = ry * BEZIER_KAPPA;
+	const cardinalPoints = [
+		[cx + rx, cy],
+		[cx, cy + ry],
+		[cx - rx, cy],
+		[cx, cy - ry]
+	];
+	const controls = [
+		[cx + rx, cy + dy],
+		[cx + dx, cy + ry],
+		[cx - dx, cy + ry],
+		[cx - rx, cy + dy],
+		[cx - rx, cy - dy],
+		[cx - dx, cy - ry],
+		[cx + dx, cy - ry],
+		[cx + rx, cy - dy]
+	];
+	const transformed = (point) => applyMatrix(matrix, {
+		x: point[0],
+		y: point[1]
+	});
+	const start = transformed(cardinalPoints[0]);
+	const segments = [];
+	for (let i = 0; i < 4; i++) {
+		const end = transformed(cardinalPoints[(i + 1) % 4]);
+		const c1 = transformed(controls[i * 2]);
+		const c2 = transformed(controls[i * 2 + 1]);
+		segments.push({
+			kind: "cubic",
+			c1xPx: c1.x,
+			c1yPx: c1.y,
+			c2xPx: c2.x,
+			c2yPx: c2.y,
+			xPx: end.x,
+			yPx: end.y
+		});
+	}
+	rasteriser.draw({
+		kind: "path",
+		subpaths: [{
+			startXPx: start.x,
+			startYPx: start.y,
+			segments,
+			closed: true
+		}],
+		...item.fill !== void 0 ? { fill: {
+			color: item.fill,
+			fillRule: "nonzero"
+		} } : {},
+		...item.stroke !== void 0 ? { stroke: strokeSpec(item.stroke, void 0, pixelsPerPt) } : {}
+	});
+}
+function drawLine(item, matrix, pixelsPerPt, rasteriser) {
+	const p1 = applyMatrix(matrix, {
+		x: item.x1Pt,
+		y: item.y1Pt
+	});
+	const p2 = applyMatrix(matrix, {
+		x: item.x2Pt,
+		y: item.y2Pt
+	});
+	if (item.style === "dotted") {
+		drawDottedSegment(p1, p2, item.widthPt * pixelsPerPt, item.color, rasteriser);
+		return;
+	}
+	rasteriser.draw({
+		kind: "path",
+		subpaths: [{
+			startXPx: p1.x,
+			startYPx: p1.y,
+			segments: [{
+				kind: "line",
+				xPx: p2.x,
+				yPx: p2.y
+			}],
+			closed: false
+		}],
+		stroke: strokeSpec({
+			color: item.color,
+			widthPt: item.widthPt
+		}, item.style, pixelsPerPt)
+	});
+}
+function drawPath(item, matrix, pixelsPerPt, rasteriser) {
+	if (item.stroke !== void 0 && item.style === "dotted") {
+		const widthPx = item.stroke.widthPt * pixelsPerPt;
+		for (const subpath of item.subpaths) {
+			let prev = applyMatrix(matrix, {
+				x: subpath.startXPt,
+				y: subpath.startYPt
+			});
+			const emitTo = (end) => {
+				drawDottedSegment(prev, end, widthPx, item.stroke.color, rasteriser);
+				prev = end;
+			};
+			for (const segment of subpath.segments) if (segment.kind === "line") emitTo(applyMatrix(matrix, {
+				x: segment.xPt,
+				y: segment.yPt
+			}));
+			else {
+				const flattened = flattenCubic(prev, applyMatrix(matrix, {
+					x: segment.c1xPt,
+					y: segment.c1yPt
+				}), applyMatrix(matrix, {
+					x: segment.c2xPt,
+					y: segment.c2yPt
+				}), applyMatrix(matrix, {
+					x: segment.xPt,
+					y: segment.yPt
+				}));
+				for (const point of flattened) emitTo(point);
+			}
+		}
+		return;
+	}
+	const subpaths = item.subpaths.map((subpath) => ({
+		startXPx: applyMatrix(matrix, {
+			x: subpath.startXPt,
+			y: subpath.startYPt
+		}).x,
+		startYPx: applyMatrix(matrix, {
+			x: subpath.startXPt,
+			y: subpath.startYPt
+		}).y,
+		segments: subpath.segments.map((segment) => {
+			if (segment.kind === "line") {
+				const end = applyMatrix(matrix, {
+					x: segment.xPt,
+					y: segment.yPt
+				});
+				return {
+					kind: "line",
+					xPx: end.x,
+					yPx: end.y
+				};
+			}
+			const c1 = applyMatrix(matrix, {
+				x: segment.c1xPt,
+				y: segment.c1yPt
+			});
+			const c2 = applyMatrix(matrix, {
+				x: segment.c2xPt,
+				y: segment.c2yPt
+			});
+			const end = applyMatrix(matrix, {
+				x: segment.xPt,
+				y: segment.yPt
+			});
+			return {
+				kind: "cubic",
+				c1xPx: c1.x,
+				c1yPx: c1.y,
+				c2xPx: c2.x,
+				c2yPx: c2.y,
+				xPx: end.x,
+				yPx: end.y
+			};
+		}),
+		closed: subpath.closed
+	}));
+	rasteriser.draw({
+		kind: "path",
+		subpaths,
+		...item.fill !== void 0 ? { fill: {
+			color: item.fill,
+			fillRule: item.fillRule
+		} } : {},
+		...item.stroke !== void 0 ? { stroke: strokeSpec(item.stroke, item.style, pixelsPerPt) } : {}
+	});
+}
+function drawImageXObjectItem(item, resolver, interpretToDeviceMatrix, rasteriser, sink) {
+	const xobjects = resolver.resolveDict(dictGet(item.resources, "XObject"));
+	const stream = xobjects !== void 0 ? resolver.resolve(dictGet(xobjects, item.resourceName)) : void 0;
+	if (stream?.kind !== "stream") return;
+	const image = readImageXObject(stream.dict, stream.raw, resolver, sink);
+	if (image === void 0) return;
+	drawImage(image, item.matrix, interpretToDeviceMatrix, rasteriser);
+}
+function drawInlineImageItem(item, resolver, interpretToDeviceMatrix, rasteriser, sink) {
+	const image = readImageXObject(item.dict, item.data, resolver, sink);
+	if (image === void 0) return;
+	drawImage(image, item.matrix, interpretToDeviceMatrix, rasteriser);
+}
+function drawImage(image, ctm, interpretToDeviceMatrix, rasteriser) {
+	const matrix = multiplyMatrices([
+		1,
+		0,
+		0,
+		-1,
+		0,
+		1
+	], multiplyMatrices(ctm, interpretToDeviceMatrix));
+	rasteriser.draw({
+		kind: "image",
+		format: image.format,
+		bytes: image.bytes,
+		sourceWidthPx: image.widthPx,
+		sourceHeightPx: image.heightPx,
+		matrix
+	});
+}
+function strokeSpec(stroke, style, pixelsPerPt) {
+	const widthPx = stroke.widthPt * pixelsPerPt;
+	if (style === "dashed") return {
+		color: stroke.color,
+		widthPx,
+		dashPx: [widthPx * 3, widthPx * 3]
+	};
+	return {
+		color: stroke.color,
+		widthPx
+	};
+}
+function drawDottedSegment(p1, p2, widthPx, color, rasteriser) {
+	const length = Math.hypot(p2.x - p1.x, p2.y - p1.y);
+	if (length === 0) return;
+	const spacing = Math.max(widthPx * 2, 1);
+	const dotHalf = widthPx / 2;
+	for (let distance = 0; distance <= length; distance += spacing) {
+		const t = distance / length;
+		rasteriser.draw({
+			kind: "fillRect",
+			xPx: p1.x + (p2.x - p1.x) * t - dotHalf,
+			yPx: p1.y + (p2.y - p1.y) * t - dotHalf,
+			widthPx,
+			heightPx: widthPx,
+			color
+		});
+	}
+}
+const STROKE_FLATTEN_TOLERANCE_PX = .05;
+const MAX_FLATTEN_DEPTH = 16;
+function flattenCubic(p0, c1, c2, p1) {
+	const points = [];
+	const flatten = (a, b, c, d, depth) => {
+		const chordX = d.x - a.x;
+		const chordY = d.y - a.y;
+		const chordLength = Math.hypot(chordX, chordY) || 1;
+		const dist1 = Math.abs((b.x - a.x) * chordY - (b.y - a.y) * chordX) / chordLength;
+		const dist2 = Math.abs((c.x - a.x) * chordY - (c.y - a.y) * chordX) / chordLength;
+		if (depth >= MAX_FLATTEN_DEPTH || Math.max(dist1, dist2) <= STROKE_FLATTEN_TOLERANCE_PX) {
+			points.push(d);
+			return;
+		}
+		const ab = {
+			x: (a.x + b.x) / 2,
+			y: (a.y + b.y) / 2
+		};
+		const bc = {
+			x: (b.x + c.x) / 2,
+			y: (b.y + c.y) / 2
+		};
+		const cd = {
+			x: (c.x + d.x) / 2,
+			y: (c.y + d.y) / 2
+		};
+		const abc = {
+			x: (ab.x + bc.x) / 2,
+			y: (ab.y + bc.y) / 2
+		};
+		const bcd = {
+			x: (bc.x + cd.x) / 2,
+			y: (bc.y + cd.y) / 2
+		};
+		const mid = {
+			x: (abc.x + bcd.x) / 2,
+			y: (abc.y + bcd.y) / 2
+		};
+		flatten(a, ab, abc, mid, depth + 1);
+		flatten(mid, bcd, cd, d, depth + 1);
+	};
+	flatten(p0, c1, c2, p1, 0);
+	return points;
+}
+function openEmbeddedProgram(descriptorOwner, resolver) {
+	const descriptor = resolver.resolveDict(dictGet(descriptorOwner, "FontDescriptor"));
+	if (descriptor === void 0) return { kind: "absent" };
+	for (const key of ["FontFile2", "FontFile3"]) {
+		const stream = resolver.resolve(dictGet(descriptor, key));
+		if (stream?.kind !== "stream") continue;
+		const bytes = decodeStream(stream.raw, stream.dict, NOOP_DIAGNOSTIC_SINK).bytes;
+		if (bytes.length >= 3 && bytes[0] === 1 && bytes[1] === 0 && bytes[2] === 4) return { kind: "cff" };
+		const sfnt = parseSfnt(bytes);
+		if (sfnt === void 0) continue;
+		if (sfnt.tables.has("CFF ")) return { kind: "cff" };
+		const head = parseHead(sfnt);
+		const maxp = parseMaxp(sfnt);
+		if (head === void 0 || maxp === void 0) continue;
+		const glyf = parseGlyf(sfnt, {
+			numGlyphs: maxp.numGlyphs,
+			indexToLocFormat: head.indexToLocFormat
+		});
+		if (glyf === void 0) continue;
+		return {
+			kind: "glyf",
+			sfnt,
+			face: {
+				composite: false,
+				glyf,
+				unitsPerEm: head.unitsPerEm,
+				glyphIdOf: () => void 0
+			}
+		};
+	}
+	return { kind: "absent" };
+}
+function resolveTextOutlineFace(fontResourceName, resources, resolver, fontResolver, outlineFaces, sink) {
+	const fontsDict = resolver.resolveDict(dictGet(resources, "Font"));
+	const fontDict = fontsDict !== void 0 ? resolver.resolveDict(dictGet(fontsDict, fontResourceName)) : void 0;
+	if (fontDict === void 0) return;
+	if (outlineFaces.has(fontDict)) return outlineFaces.get(fontDict);
+	const face = buildTextOutlineFace(fontDict, resolver, fontResolver, fontResourceName, resources, sink);
+	outlineFaces.set(fontDict, face);
+	return face;
+}
+function buildTextOutlineFace(fontDict, resolver, fontResolver, fontResourceName, resources, sink) {
+	const faceName = asName(dictGet(fontDict, "BaseFont")) ?? asName(dictGet(fontDict, "Subtype")) ?? "font";
+	const unavailable = (reason) => {
+		sink({
+			code: "raster/text-outlines-unavailable",
+			severity: "warning",
+			message: `font resource /${fontResourceName} (${faceName}) has no drawable outline (${reason}); its text is not rendered`
+		});
+	};
+	const cff = () => {
+		sink({
+			code: "raster/text-cff-outlines",
+			severity: "warning",
+			message: `font resource /${fontResourceName} (${faceName}) carries CFF outlines; this raster surface fills sfnt (TrueType/glyf) outlines only, so its text is not rendered rather than approximated`
+		});
+	};
+	const subtype = asName(dictGet(fontDict, "Subtype"));
+	if (subtype === "Type0") {
+		const encoding = resolver.resolve(dictGet(fontDict, "Encoding"));
+		if (encoding?.kind !== "name" || encoding.name !== "Identity-H") {
+			unavailable("a Type0 font whose /Encoding is not Identity-H (a predefined or embedded CMap this raster walk does not decode)");
+			return;
+		}
+		const descendants = asArray(dictGet(fontDict, "DescendantFonts"));
+		const descendant = descendants !== void 0 ? resolver.resolveDict(descendants[0]) : void 0;
+		if (descendant === void 0) {
+			unavailable("a Type0 font with no readable /DescendantFonts entry");
+			return;
+		}
+		const descendantSubtype = asName(dictGet(descendant, "Subtype"));
+		if (descendantSubtype === "CIDFontType0") {
+			cff();
+			return;
+		}
+		if (descendantSubtype !== "CIDFontType2") {
+			unavailable(`a descendant font of subtype ${descendantSubtype ?? "(none)"}`);
+			return;
+		}
+		const cidToGidMap = resolver.resolve(dictGet(descendant, "CIDToGIDMap"));
+		const program = openEmbeddedProgram(descendant, resolver);
+		if (program.kind === "cff") {
+			cff();
+			return;
+		}
+		if (program.kind === "absent") {
+			unavailable("no readable /FontFile2 (or glyf-bearing /FontFile3) stream");
+			return;
+		}
+		if (cidToGidMap !== void 0 && cidToGidMap.kind !== "name" && cidToGidMap.kind !== "stream") {
+			unavailable("a /CIDToGIDMap that is neither /Identity nor a readable stream");
+			return;
+		}
+		if (cidToGidMap?.kind === "stream") {
+			const decodedBytes = decodeStream(cidToGidMap.raw, cidToGidMap.dict, NOOP_DIAGNOSTIC_SINK).bytes;
+			const entries = [];
+			for (let i = 0; i + 1 < decodedBytes.length; i += 2) entries.push(decodedBytes[i] << 8 | decodedBytes[i + 1]);
+			return {
+				composite: true,
+				glyf: program.face.glyf,
+				unitsPerEm: program.face.unitsPerEm,
+				glyphIdOf: (codes, offset) => {
+					const cid = codes[offset] << 8 | codes[offset + 1];
+					return cid < entries.length ? entries[cid] : void 0;
+				}
+			};
+		}
+		return {
+			composite: true,
+			glyf: program.face.glyf,
+			unitsPerEm: program.face.unitsPerEm,
+			glyphIdOf: (codes, offset) => codes[offset] << 8 | codes[offset + 1]
+		};
+	}
+	if (subtype === "TrueType") {
+		const program = openEmbeddedProgram(fontDict, resolver);
+		if (program.kind === "cff") {
+			cff();
+			return;
+		}
+		if (program.kind === "absent") {
+			unavailable("no /FontDescriptor or no readable embedded program (a standard-14 or otherwise unembedded face states no outlines at all)");
+			return;
+		}
+		const cmapLookup = buildCmapLookup(program.sfnt);
+		if (cmapLookup === void 0) {
+			unavailable("an embedded program with no usable Unicode cmap subtable");
+			return;
+		}
+		return {
+			composite: false,
+			glyf: program.face.glyf,
+			unitsPerEm: program.face.unitsPerEm,
+			glyphIdOf: (codes, offset) => {
+				const codePoint = (fontResolver.resolve(fontResourceName, resources)?.decodeToUnicode(codes.subarray(offset, offset + 1)))?.codePointAt(0);
+				return codePoint === void 0 ? void 0 : cmapLookup(codePoint);
+			}
+		};
+	}
+	if (subtype === "Type1" || subtype === "MMType1") {
+		if (openEmbeddedProgram(fontDict, resolver).kind === "cff") return cff();
+		return unavailable("a Type 1 PostScript program, whose outlines are charstrings rather than sfnt glyf data");
+	}
+	return unavailable(`a font of subtype ${subtype ?? "(none)"} (a Type3 glyph-procedure font has no static outline at all)`);
+}
+function drawTextRun(item, fontResolver, resolver, outlineFaces, interpretToDeviceMatrix, rasteriser, sink) {
+	const face = resolveTextOutlineFace(item.fontResourceName, item.resources, resolver, fontResolver, outlineFaces, sink);
+	if (face === void 0) return;
+	const composite = face.composite;
+	const placements = [];
+	let offset = 0;
+	let cumulative = 0;
+	while (offset < item.codes.length) {
+		const advance = fontResolver.metrics.glyphAdvance(item.fontResourceName, item.resources, item.codes, offset);
+		const widthPer1000 = advance?.widthPer1000 ?? FALLBACK_GLYPH_WIDTH_PER_1000;
+		const byteLength = advance?.byteLengthConsumed ?? (composite ? 2 : 1);
+		placements.push({
+			glyphId: face.glyphIdOf(item.codes, offset),
+			advance: cumulative
+		});
+		cumulative += widthPer1000 / 1e3 * item.sizePt;
+		offset += byteLength;
+	}
+	const startDeviceMatrix = multiplyMatrices(item.startMatrix, interpretToDeviceMatrix);
+	const endDeviceMatrix = multiplyMatrices(item.endMatrix, interpretToDeviceMatrix);
+	const startPoint = applyMatrix(startDeviceMatrix, {
+		x: 0,
+		y: 0
+	});
+	const endPoint = applyMatrix(endDeviceMatrix, {
+		x: 0,
+		y: 0
+	});
+	const rawEndPoint = applyMatrix(startDeviceMatrix, {
+		x: cumulative,
+		y: 0
+	});
+	const rawExtent = Math.hypot(rawEndPoint.x - startPoint.x, rawEndPoint.y - startPoint.y);
+	const actualExtent = Math.hypot(endPoint.x - startPoint.x, endPoint.y - startPoint.y);
+	const correction = rawExtent > 1e-9 && cumulative > 0 ? actualExtent / rawExtent : 1;
+	const glyphScale = scaleMatrix(1 / face.unitsPerEm, 1 / face.unitsPerEm);
+	for (const placement of placements) {
+		if (placement.glyphId === void 0) continue;
+		const outline = decodeGlyphOutline(face.glyf, placement.glyphId);
+		if (outline === void 0 || outline.contours.length === 0) continue;
+		const trm = multiplyMatrices(translationMatrix(placement.advance * correction, 0), item.startMatrix);
+		const subpaths = glyphOutlineSubpaths(outline, multiplyMatrices(glyphScale, multiplyMatrices(trm, interpretToDeviceMatrix)));
+		if (subpaths.length === 0) continue;
+		rasteriser.draw({
+			kind: "path",
+			subpaths,
+			fill: {
+				color: item.color,
+				fillRule: "nonzero"
+			}
+		});
+	}
+}
+function glyphOutlineSubpaths(outline, matrix) {
+	const subpaths = [];
+	for (const contour of outline.contours) {
+		if (contour.length < 3) continue;
+		const firstOn = contour.findIndex((point) => point.onCurve);
+		const contourPoints = contour.map((point) => ({
+			x: point.x,
+			y: point.y,
+			onCurve: point.onCurve
+		}));
+		const ordered = firstOn >= 0 ? [...contourPoints.slice(firstOn), ...contourPoints.slice(0, firstOn)] : contourPoints;
+		let current = firstOn >= 0 ? {
+			x: contourPoints[firstOn].x,
+			y: contourPoints[firstOn].y
+		} : {
+			x: (contourPoints[contourPoints.length - 1].x + contourPoints[0].x) / 2,
+			y: (contourPoints[contourPoints.length - 1].y + contourPoints[0].y) / 2
+		};
+		const start = current;
+		const segments = [];
+		let pendingOffCurve;
+		const emitQuad = (from, control, to) => {
+			const p0 = applyMatrix(matrix, from);
+			const q = applyMatrix(matrix, control);
+			const p1 = applyMatrix(matrix, to);
+			segments.push({
+				kind: "cubic",
+				c1xPx: p0.x + 2 / 3 * (q.x - p0.x),
+				c1yPx: p0.y + 2 / 3 * (q.y - p0.y),
+				c2xPx: p1.x + 2 / 3 * (q.x - p1.x),
+				c2yPx: p1.y + 2 / 3 * (q.y - p1.y),
+				xPx: p1.x,
+				yPx: p1.y
+			});
+		};
+		const emitLine = (to) => {
+			const p1 = applyMatrix(matrix, to);
+			segments.push({
+				kind: "line",
+				xPx: p1.x,
+				yPx: p1.y
+			});
+		};
+		for (const point of ordered) if (point.onCurve) {
+			if (pendingOffCurve === void 0) emitLine(point);
+			else emitQuad(current, pendingOffCurve, point);
+			current = point;
+			pendingOffCurve = void 0;
+		} else {
+			if (pendingOffCurve !== void 0) {
+				const implied = {
+					x: (pendingOffCurve.x + point.x) / 2,
+					y: (pendingOffCurve.y + point.y) / 2
+				};
+				emitQuad(current, pendingOffCurve, implied);
+				current = implied;
+			}
+			pendingOffCurve = point;
+		}
+		if (pendingOffCurve !== void 0) emitQuad(current, pendingOffCurve, start);
+		if (segments.length >= 2) {
+			const startPx = applyMatrix(matrix, start);
+			subpaths.push({
+				startXPx: startPx.x,
+				startYPx: startPx.y,
+				segments,
+				closed: true
+			});
+		}
+	}
+	return subpaths;
+}
+const PDF_HEADER_BYTES = new TextEncoder().encode("%PDF-");
+const HEADER_SEARCH_WINDOW = 1024;
+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 readDeclaredPageBox(page, key) {
+	const arr = asArray(dictGet(page, key));
+	if (arr === void 0) return;
+	const a = asNumber(arr[0]) ?? 0;
+	const b = asNumber(arr[1]) ?? 0;
+	const c = asNumber(arr[2]) ?? 0;
+	const d = asNumber(arr[3]) ?? 0;
+	return {
+		llx: Math.min(a, c),
+		lly: Math.min(b, d),
+		urx: Math.max(a, c),
+		ury: Math.max(b, d)
+	};
+}
+const DEFAULT_PAGE_WIDTH_PT = 612;
+const DEFAULT_PAGE_HEIGHT_PT = 792;
+function readMediaBox(page) {
+	return readDeclaredPageBox(page, "MediaBox") ?? {
+		llx: 0,
+		lly: 0,
+		urx: DEFAULT_PAGE_WIDTH_PT,
+		ury: DEFAULT_PAGE_HEIGHT_PT
+	};
+}
+function rotatedRectBounds(rect, matrix) {
+	const transformed = [
+		[rect.llx, rect.lly],
+		[rect.urx, rect.lly],
+		[rect.llx, rect.ury],
+		[rect.urx, rect.ury]
+	].map(([x, y]) => applyMatrix(matrix, {
+		x,
+		y
+	}));
+	const xs = transformed.map((point) => point.x);
+	const ys = transformed.map((point) => point.y);
+	return {
+		minX: Math.min(...xs),
+		minY: Math.min(...ys),
+		maxX: Math.max(...xs),
+		maxY: Math.max(...ys)
+	};
+}
+function readPageContentBytes(page, resolver, sink) {
+	const contentsObj = resolver.resolve(dictGet(page, "Contents"));
+	if (contentsObj?.kind === "stream") return decodeStream(contentsObj.raw, contentsObj.dict, sink).bytes;
+	if (contentsObj?.kind === "array") {
+		const chunks = [];
+		for (const entry of contentsObj.items) {
+			const streamObj = resolver.resolve(entry);
+			if (streamObj?.kind === "stream") chunks.push(decodeStream(streamObj.raw, streamObj.dict, sink).bytes, new Uint8Array([10]));
+		}
+		return concatBytes(chunks);
+	}
+	return /* @__PURE__ */ new Uint8Array(0);
+}
+//#endregion
+export { renderPdfPage };