pdf-parser.js 5.2.30 → 5.3.1

package/dist/raster-EG2KYRZ0.cjs

@@ -0,0 +1,829 @@
+const require_objects = require("./objects.cjs");
+const require_bytes_writer = require("./bytes/writer.cjs");
+const require_matrix = require("./matrix.cjs");
+const require_filters = require("./filters.cjs");
+const require_sfnt = require("./sfnt.cjs");
+const require_cmap_table = require("./cmap-table.cjs");
+const require_font_tables = require("./font-tables.cjs");
+const require_images_read = require("./images-read.cjs");
+const require_optional_content = require("./optional-content.cjs");
+const require_diagnostics = require("./diagnostics.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_interpret = require("./interpret-CqXdXgkY.cjs");
+const require_read = require("./read.cjs");
+const require_glyf = require("./glyf.cjs");
+const require_glyf_contours = require("./glyf-contours.cjs");
+//#region src/raster-text.ts
+const CFF_HEADER_SIZE = 4;
+function openEmbeddedProgram(descriptorOwner, resolver) {
+	const descriptor = resolver.resolveDict(require_objects.dictGet(descriptorOwner, "FontDescriptor"));
+	if (descriptor === void 0) return { kind: "absent" };
+	for (const key of ["FontFile2", "FontFile3"]) {
+		const stream = resolver.resolve(require_objects.dictGet(descriptor, key));
+		if (stream?.kind !== "stream") continue;
+		const bytes = require_filters.decodeStream(stream.raw, stream.dict, require_diagnostics.NOOP_DIAGNOSTIC_SINK).bytes;
+		if (bytes[0] === 1 && bytes[1] === 0 && bytes[2] === CFF_HEADER_SIZE) return { kind: "cff" };
+		const sfnt = require_sfnt.parseSfnt(bytes);
+		if (sfnt === void 0) continue;
+		if (sfnt.tables.has("CFF ")) return { kind: "cff" };
+		const head = require_font_tables.parseHead(sfnt);
+		const maxp = require_font_tables.parseMaxp(sfnt);
+		if (head === void 0 || maxp === void 0) continue;
+		const glyf = require_glyf.parseGlyf(sfnt, {
+			numGlyphs: maxp.numGlyphs,
+			indexToLocFormat: head.indexToLocFormat
+		});
+		if (glyf === void 0) continue;
+		return {
+			kind: "glyf",
+			sfnt,
+			face: {
+				glyf,
+				unitsPerEm: head.unitsPerEm
+			}
+		};
+	}
+	return { kind: "absent" };
+}
+function resolveTextOutlineFace(fontResourceName, resources, resolver, fontResolver, outlineFaces, sink) {
+	const fontsDict = resolver.resolveDict(require_objects.dictGet(resources, "Font"));
+	const fontDict = fontsDict !== void 0 ? resolver.resolveDict(require_objects.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;
+}
+const BITS_PER_BYTE = 8;
+function buildTextOutlineFace(fontDict, resolver, fontResolver, fontResourceName, resources, sink) {
+	const faceName = require_objects.asName(require_objects.dictGet(fontDict, "BaseFont")) ?? require_objects.asName(require_objects.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 = require_objects.asName(require_objects.dictGet(fontDict, "Subtype"));
+	if (subtype === "Type0") {
+		const encoding = resolver.resolve(require_objects.dictGet(fontDict, "Encoding"));
+		if (encoding?.kind !== "name" || encoding.name !== "Identity-H" && encoding.name !== "Identity-V") return unavailable("a Type0 font whose /Encoding is neither Identity-H nor Identity-V (a predefined or embedded CMap this raster walk does not decode)");
+		const descendants = require_objects.asArray(require_objects.dictGet(fontDict, "DescendantFonts"));
+		const descendant = descendants !== void 0 ? resolver.resolveDict(descendants[0]) : void 0;
+		if (descendant === void 0) return unavailable("a Type0 font with no readable /DescendantFonts entry");
+		const descendantSubtype = require_objects.asName(require_objects.dictGet(descendant, "Subtype"));
+		if (descendantSubtype === "CIDFontType0") return cff();
+		if (descendantSubtype !== "CIDFontType2") return unavailable(`a descendant font of subtype ${descendantSubtype ?? "(none)"}`);
+		const cidToGidMap = resolver.resolve(require_objects.dictGet(descendant, "CIDToGIDMap"));
+		const program = openEmbeddedProgram(descendant, resolver);
+		if (program.kind === "cff") return cff();
+		if (program.kind === "absent") return unavailable("no readable /FontFile2 (or glyf-bearing /FontFile3) stream");
+		if (cidToGidMap !== void 0 && cidToGidMap.kind !== "name" && cidToGidMap.kind !== "stream") return unavailable("a /CIDToGIDMap that is neither /Identity nor a readable stream");
+		if (cidToGidMap?.kind === "stream") {
+			const decodedBytes = require_filters.decodeStream(cidToGidMap.raw, cidToGidMap.dict, require_diagnostics.NOOP_DIAGNOSTIC_SINK).bytes;
+			const entries = [];
+			for (let i = 0; i + 1 < decodedBytes.length; i += 2) entries.push(decodedBytes[i] << BITS_PER_BYTE | decodedBytes[i + 1]);
+			return {
+				glyf: program.face.glyf,
+				unitsPerEm: program.face.unitsPerEm,
+				glyphIdOf: (codes, offset) => {
+					const cid = codes[offset] << BITS_PER_BYTE | codes[offset + 1];
+					return entries[cid];
+				}
+			};
+		}
+		return {
+			glyf: program.face.glyf,
+			unitsPerEm: program.face.unitsPerEm,
+			glyphIdOf: (codes, offset) => codes[offset] << BITS_PER_BYTE | codes[offset + 1]
+		};
+	}
+	if (subtype === "TrueType") {
+		const program = openEmbeddedProgram(fontDict, resolver);
+		if (program.kind === "cff") return cff();
+		if (program.kind === "absent") return unavailable("no /FontDescriptor or no readable embedded program (a standard-14 or otherwise unembedded face states no outlines at all)");
+		const cmapLookup = require_cmap_table.buildCmapLookup(program.sfnt);
+		if (cmapLookup === void 0) return unavailable("an embedded program with no usable Unicode cmap subtable");
+		return {
+			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)`);
+}
+const METRICS_PER_1000_SCALE = 1e3;
+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 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 byteLength = advance.byteLengthConsumed;
+		placements.push({
+			glyphId: face.glyphIdOf(item.codes, offset),
+			advance: cumulative,
+			positionX: (advance.vertical?.positionXPer1000 ?? 0) / METRICS_PER_1000_SCALE,
+			positionY: (advance.vertical?.positionYPer1000 ?? 0) / METRICS_PER_1000_SCALE
+		});
+		cumulative += (advance.vertical?.displacementPer1000 ?? advance.widthPer1000) / METRICS_PER_1000_SCALE * item.sizePt;
+		offset += byteLength;
+	}
+	const startDeviceMatrix = require_matrix.multiplyMatrices(item.startMatrix, interpretToDeviceMatrix);
+	const endDeviceMatrix = require_matrix.multiplyMatrices(item.endMatrix, interpretToDeviceMatrix);
+	const vertical = item.vertical === true;
+	const startPoint = require_matrix.applyMatrix(startDeviceMatrix, {
+		x: 0,
+		y: 0
+	});
+	const endPoint = require_matrix.applyMatrix(endDeviceMatrix, {
+		x: 0,
+		y: 0
+	});
+	const rawEndPoint = require_matrix.applyMatrix(startDeviceMatrix, vertical ? {
+		x: 0,
+		y: cumulative
+	} : {
+		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 ? actualExtent / rawExtent : 1;
+	const firstPlacement = placements[0];
+	const glyphScale = require_matrix.scaleMatrix(1 / face.unitsPerEm, 1 / face.unitsPerEm);
+	for (const placement of placements) {
+		if (placement.glyphId === void 0) continue;
+		const outline = require_glyf_contours.decodeGlyphOutline(face.glyf, placement.glyphId);
+		if (outline === void 0) continue;
+		const trm = require_matrix.multiplyMatrices(require_matrix.translationMatrix((firstPlacement?.positionX ?? 0) - placement.positionX, (firstPlacement?.positionY ?? 0) - placement.positionY), require_matrix.multiplyMatrices(vertical ? require_matrix.translationMatrix(0, placement.advance * correction) : require_matrix.translationMatrix(placement.advance * correction, 0), item.startMatrix));
+		drawGlyphOutline(outline, require_matrix.multiplyMatrices(glyphScale, require_matrix.multiplyMatrices(trm, interpretToDeviceMatrix)), item.color, rasteriser);
+	}
+}
+function drawGlyphOutline(outline, glyphMatrix, color, rasteriser) {
+	const subpaths = glyphOutlineSubpaths(outline, glyphMatrix);
+	if (subpaths.length === 0) return;
+	rasteriser.draw({
+		kind: "path",
+		subpaths,
+		fill: {
+			color,
+			fillRule: "nonzero"
+		}
+	});
+}
+const MIN_CONTOUR_POINTS = 3;
+const QUADRATIC_TO_CUBIC_CONTROL_FRACTION = 2 / 3;
+function glyphOutlineSubpaths(outline, matrix) {
+	const subpaths = [];
+	for (const contour of outline.contours) {
+		if (contour.length < MIN_CONTOUR_POINTS) continue;
+		const firstOn = contour.findIndex((point) => point.onCurve);
+		const contourPoints = contour.map((point) => ({
+			x: point.x,
+			y: point.y,
+			onCurve: point.onCurve
+		}));
+		const hasLeadingOnCurvePoint = firstOn >= 0;
+		const ordered = hasLeadingOnCurvePoint ? [...contourPoints.slice(firstOn), ...contourPoints.slice(0, firstOn)] : contourPoints;
+		let current = hasLeadingOnCurvePoint ? {
+			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 = require_matrix.applyMatrix(matrix, from);
+			const q = require_matrix.applyMatrix(matrix, control);
+			const p1 = require_matrix.applyMatrix(matrix, to);
+			segments.push({
+				kind: "cubic",
+				c1xPx: p0.x + QUADRATIC_TO_CUBIC_CONTROL_FRACTION * (q.x - p0.x),
+				c1yPx: p0.y + QUADRATIC_TO_CUBIC_CONTROL_FRACTION * (q.y - p0.y),
+				c2xPx: p1.x + QUADRATIC_TO_CUBIC_CONTROL_FRACTION * (q.x - p1.x),
+				c2yPx: p1.y + QUADRATIC_TO_CUBIC_CONTROL_FRACTION * (q.y - p1.y),
+				xPx: p1.x,
+				yPx: p1.y
+			});
+		};
+		const emitLine = (to) => {
+			const p1 = require_matrix.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);
+		const startPx = require_matrix.applyMatrix(matrix, start);
+		subpaths.push({
+			startXPx: startPx.x,
+			startYPx: startPx.y,
+			segments,
+			closed: true
+		});
+	}
+	return subpaths;
+}
+//#endregion
+//#region src/raster.ts
+const PIXEL_ROUNDING_EPSILON = 1e-9;
+const POINTS_PER_INCH = 72;
+const EXTENT_ZERO_EPSILON = 1e-9;
+function regionPixels(extentPt, scale) {
+	return Math.max(1, Math.ceil(extentPt * scale - PIXEL_ROUNDING_EPSILON));
+}
+const HEADER_SEARCH_WINDOW = 1024;
+const DEFAULT_PAGE_WIDTH_PT = 612;
+const DEFAULT_PAGE_HEIGHT_PT = 792;
+const NEWLINE_BYTE = 10;
+function hasPdfHeader(bytes) {
+	const window = bytes.subarray(0, Math.min(HEADER_SEARCH_WINDOW, bytes.length));
+	return new TextDecoder("latin1").decode(window).includes("%PDF-");
+}
+function readDeclaredPageBox(page, key) {
+	const arr = require_objects.asArray(require_objects.dictGet(page, key));
+	if (arr === void 0) return;
+	const a = require_objects.asNumber(arr[0]) ?? 0;
+	const b = require_objects.asNumber(arr[1]) ?? 0;
+	const c = require_objects.asNumber(arr[2]) ?? 0;
+	const d = require_objects.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)
+	};
+}
+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]) => require_matrix.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(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 entry of contentsObj.items) {
+			const streamObj = resolver.resolve(entry);
+			if (streamObj?.kind === "stream") chunks.push(require_filters.decodeStream(streamObj.raw, streamObj.dict, sink).bytes, new Uint8Array([NEWLINE_BYTE]));
+		}
+		return require_bytes_writer.concatBytes(chunks);
+	}
+	return /* @__PURE__ */ new Uint8Array(0);
+}
+function renderPdfPage(pdfBytes, pageIndex, options, rasteriser) {
+	const sink = options.sink ?? require_diagnostics.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 / POINTS_PER_INCH : 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");
+	require_util_abort.throwIfAborted(options.signal);
+	if (!hasPdfHeader(pdfBytes)) 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(pdfBytes, sink);
+	const pages = doc.pages();
+	if (pageIndex < 0 || pageIndex >= pages.length) throw new require_diagnostics.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 = require_read.normalizeRotation(require_objects.asNumber(require_objects.dictGet(page, "Rotate")));
+	const rotationResult = require_read.pageRotationTransform(rotation, 0, 0);
+	const visibleRect = rotatedRectBounds(cropBox, rotationResult.matrix);
+	const pageWidthPt = visibleRect.maxX - visibleRect.minX;
+	const pageHeightPt = visibleRect.maxY - visibleRect.minY;
+	const pageMatrix = require_matrix.multiplyMatrices(rotationResult.matrix, require_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 = require_matrix.multiplyMatrices(pageMatrix, pageToDeviceMatrix);
+	const resources = doc.resolveDict(require_objects.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 = require_font_read.createFontResolver({
+		resolver: doc,
+		sink
+	});
+	const { layers, layerNameOf } = require_optional_content.readOptionalContent(doc.catalog, doc, sink);
+	const hiddenLayers = new Set(layers.filter((layer) => !layer.visible).map((layer) => layer.name));
+	const extracted = require_interpret.interpretContentStream(readPageContentBytes(page, doc, sink), resources, {
+		fontMetrics: fontResolver.metrics,
+		resolver: doc,
+		sink,
+		layerNameOf
+	});
+	const outlineFaces = /* @__PURE__ */ new Map();
+	for (const item of extracted) {
+		require_util_abort.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 = [
+		require_matrix.applyMatrix(matrix, {
+			x: item.xPt,
+			y: item.yPt
+		}),
+		require_matrix.applyMatrix(matrix, {
+			x: item.xPt + item.widthPt,
+			y: item.yPt
+		}),
+		require_matrix.applyMatrix(matrix, {
+			x: item.xPt,
+			y: item.yPt + item.heightPt
+		}),
+		require_matrix.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)
+	});
+}
+const ELLIPSE_QUADRANT_COUNT = 4;
+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 * require_matrix.BEZIER_KAPPA;
+	const dy = ry * require_matrix.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) => require_matrix.applyMatrix(matrix, {
+		x: point[0],
+		y: point[1]
+	});
+	const start = transformed(cardinalPoints[0]);
+	const segments = [];
+	for (let i = 0; i < ELLIPSE_QUADRANT_COUNT; i++) {
+		const end = transformed(cardinalPoints[(i + 1) % ELLIPSE_QUADRANT_COUNT]);
+		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 = require_matrix.applyMatrix(matrix, {
+		x: item.x1Pt,
+		y: item.y1Pt
+	});
+	const p2 = require_matrix.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 = require_matrix.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(require_matrix.applyMatrix(matrix, {
+				x: segment.xPt,
+				y: segment.yPt
+			}));
+			else {
+				const flattened = flattenCubic(prev, require_matrix.applyMatrix(matrix, {
+					x: segment.c1xPt,
+					y: segment.c1yPt
+				}), require_matrix.applyMatrix(matrix, {
+					x: segment.c2xPt,
+					y: segment.c2yPt
+				}), require_matrix.applyMatrix(matrix, {
+					x: segment.xPt,
+					y: segment.yPt
+				}));
+				for (const point of flattened) emitTo(point);
+			}
+		}
+		return;
+	}
+	const subpaths = item.subpaths.map((subpath) => ({
+		startXPx: require_matrix.applyMatrix(matrix, {
+			x: subpath.startXPt,
+			y: subpath.startYPt
+		}).x,
+		startYPx: require_matrix.applyMatrix(matrix, {
+			x: subpath.startXPt,
+			y: subpath.startYPt
+		}).y,
+		segments: subpath.segments.map((segment) => {
+			if (segment.kind === "line") {
+				const end = require_matrix.applyMatrix(matrix, {
+					x: segment.xPt,
+					y: segment.yPt
+				});
+				return {
+					kind: "line",
+					xPx: end.x,
+					yPx: end.y
+				};
+			}
+			const c1 = require_matrix.applyMatrix(matrix, {
+				x: segment.c1xPt,
+				y: segment.c1yPt
+			});
+			const c2 = require_matrix.applyMatrix(matrix, {
+				x: segment.c2xPt,
+				y: segment.c2yPt
+			});
+			const end = require_matrix.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(require_objects.dictGet(item.resources, "XObject"));
+	const stream = xobjects !== void 0 ? resolver.resolve(require_objects.dictGet(xobjects, item.resourceName)) : void 0;
+	if (stream?.kind !== "stream") return;
+	const image = require_images_read.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 = require_images_read.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 = require_matrix.multiplyMatrices([
+		1,
+		0,
+		0,
+		-1,
+		0,
+		1
+	], require_matrix.multiplyMatrices(ctm, interpretToDeviceMatrix));
+	rasteriser.draw({
+		kind: "image",
+		format: image.format,
+		bytes: image.bytes,
+		sourceWidthPx: image.widthPx,
+		sourceHeightPx: image.heightPx,
+		matrix
+	});
+}
+const DASHED_STROKE_WIDTH_MULTIPLE = 3;
+function strokeSpec(stroke, style, pixelsPerPt) {
+	const widthPx = stroke.widthPt * pixelsPerPt;
+	if (style === "dashed") return {
+		color: stroke.color,
+		widthPx,
+		dashPx: [widthPx * DASHED_STROKE_WIDTH_MULTIPLE, widthPx * DASHED_STROKE_WIDTH_MULTIPLE]
+	};
+	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;
+}
+//#endregion
+Object.defineProperty(exports, "EXTENT_ZERO_EPSILON", {
+	enumerable: true,
+	get: function() {
+		return EXTENT_ZERO_EPSILON;
+	}
+});
+Object.defineProperty(exports, "drawGlyphOutline", {
+	enumerable: true,
+	get: function() {
+		return drawGlyphOutline;
+	}
+});
+Object.defineProperty(exports, "drawTextRun", {
+	enumerable: true,
+	get: function() {
+		return drawTextRun;
+	}
+});
+Object.defineProperty(exports, "flattenCubic", {
+	enumerable: true,
+	get: function() {
+		return flattenCubic;
+	}
+});
+Object.defineProperty(exports, "glyphOutlineSubpaths", {
+	enumerable: true,
+	get: function() {
+		return glyphOutlineSubpaths;
+	}
+});
+Object.defineProperty(exports, "renderPdfPage", {
+	enumerable: true,
+	get: function() {
+		return renderPdfPage;
+	}
+});