reamkit 1.24.0 → 1.25.1

package/dist/esm/pdf-reader/tagged.js

@@ -1,11 +1,15 @@
 import { pt } from "../core/ir/units.js";
 import { ResourceStore } from "../core/ir/resources.js";
-import { buildFlowDoc, dedupeLosses, imageBlock, paragraphBlock, paragraphFromRuns, sectionFromPdfPages } from "./flow-build.js";
+import { displayOf, placeVectors } from "./display.js";
+import { buildFlowDoc, dedupeLosses, imageBlock, paragraphBlock, paragraphFromRuns, sectionFromPdfPages, shapeBlock } from "./flow-build.js";
+import { collectEmbeddedFonts } from "./embedded-fonts.js";
 import { collectPageImages } from "./images.js";
 import { extractPageText } from "./text.js";
+import { collectPageVectors } from "./vector.js";
 import { readStructTree } from "./struct-tree.js";
 //#region src/pdf-reader/tagged.ts
 var ASSUMED_CONTENT_WIDTH_PT = 468;
+var MIN_COLUMN_PT = 6;
 /**
 * Reconstruct a {@link Reconstruction} from a tagged PDF's logical structure
 * (E-PDF EP3 — the honest inverse of the tagged PDF Ream writes). Walks the
@@ -54,10 +58,19 @@ function reconstructTaggedPdf(file) {
 		const spans = [];
 		node.mcids.forEach(({ page, mcid }, i) => {
 			if (i > 0) spans.push({ text: " " });
-			for (const run of runsOfMcid(page, mcid)) spans.push(run.href !== void 0 ? {
+			for (const run of runsOfMcid(page, mcid)) spans.push({
 				text: run.text,
-				href: run.href
-			} : { text: run.text });
+				sizePt: run.fontSizePt,
+				...run.colorHex !== "000000" ? { colorHex: run.colorHex } : {},
+				...run.fontName !== void 0 ? { fontName: run.fontName } : {},
+				...run.outlineHex !== void 0 ? { outline: {
+					colorHex: run.outlineHex,
+					widthPt: pt(run.outlineWidthPt ?? 1)
+				} } : {},
+				...run.bold ? { bold: true } : {},
+				...run.italic ? { italic: true } : {},
+				...run.href !== void 0 ? { href: run.href } : {}
+			});
 		});
 		return spans;
 	};
@@ -87,23 +100,42 @@ function reconstructTaggedPdf(file) {
 		for (const child of node.children) emit(child, out);
 	}
 	function buildTable(tableNode) {
-		const rows = [];
+		const raw = [];
 		const collectRows = (n) => {
-			for (const child of n.children) if (child.type === "TR") rows.push(buildRow(child));
+			for (const child of n.children) if (child.type === "TR") raw.push(buildRow(child));
 			else if (child.type === "THead" || child.type === "TBody" || child.type === "TFoot") collectRows(child);
 		};
 		collectRows(tableNode);
-		if (rows.length === 0) return void 0;
-		const numCols = Math.max(1, ...rows.map((r) => r.cells.reduce((s, c) => s + (c.properties.colSpan ?? 1), 0)));
-		const colWidth = pt(Math.max(1, ASSUMED_CONTENT_WIDTH_PT / numCols));
+		if (raw.length === 0) return void 0;
+		const laid = layOutColumns(raw);
 		return {
 			kind: "table",
 			table: {
 				properties: {},
-				grid: Array.from({ length: numCols }, () => colWidth),
-				rows
+				grid: laid.grid,
+				rows: laid.rows
+			}
+		};
+	}
+	/**
+	* The span of page x every glyph under a node covers — measured, since the
+	* interpreter advances the text matrix by the font's own widths (§9.4.4).
+	*/
+	function edgesOf(node) {
+		let left;
+		let right;
+		const visit = (n) => {
+			for (const { page, mcid } of n.mcids) for (const run of runsOfMcid(page, mcid)) {
+				if (left === void 0 || run.x < left) left = run.x;
+				if (right === void 0 || run.endX > right) right = run.endX;
 			}
+			for (const child of n.children) visit(child);
 		};
+		visit(node);
+		return left !== void 0 && right !== void 0 ? {
+			left,
+			right
+		} : void 0;
 	}
 	function buildRow(trNode) {
 		const cells = [];
@@ -114,20 +146,40 @@ function reconstructTaggedPdf(file) {
 			if (cell.type !== "TH") allHeader = false;
 			const content = [];
 			for (const child of cell.children) emit(child, content);
-			if (content.length === 0) content.push(paragraphBlock(textOf(cell), void 0));
-			const colSpan = cell.colSpan ?? 1;
+			if (content.length === 0) content.push(paragraphFromRuns(spansOf(cell)));
+			const edges = edgesOf(cell);
 			cells.push({
-				properties: colSpan > 1 ? { colSpan } : {},
-				content
+				content,
+				span: cell.colSpan ?? 1,
+				...edges ? {
+					x: edges.left,
+					right: edges.right
+				} : {}
 			});
 		}
 		return {
-			properties: allHeader && cells.length > 0 ? { isHeader: true } : {},
+			header: allHeader && cells.length > 0,
 			cells
 		};
 	}
 	const body = [];
 	emit(root, body);
+	let zOrder = -1e6;
+	pages.forEach((page, index) => {
+		const display = displayOf(page);
+		const frame = {
+			left: 0,
+			top: display.height
+		};
+		const lifted = collectPageVectors(file, page, (pageImages[index]?.images ?? []).map((img) => ({
+			minX: img.x,
+			minY: img.y,
+			maxX: img.x + img.widthPt,
+			maxY: img.y + img.heightPt
+		})));
+		imageLosses.push(...lifted.losses);
+		for (const v of placeVectors(lifted.vectors, display)) body.push(shapeBlock(v, frame, zOrder++));
+	});
 	const orphans = [];
 	pageImages.forEach((p, page) => {
 		for (const img of p.images) if (!emitted.has(img)) orphans.push({
@@ -139,10 +191,97 @@ function reconstructTaggedPdf(file) {
 	for (const { img } of orphans) body.push(imageBlock(img, resources));
 	if (body.length === 0) return void 0;
 	return {
-		doc: buildFlowDoc(body, resources, sectionFromPdfPages(pages)),
+		doc: buildFlowDoc(body, resources, sectionFromPdfPages(pages), collectEmbeddedFonts(file, pages)),
 		losses: imageLosses
 	};
 }
+/** Two starts within this many points are the same column. */
+var COLUMN_TOLERANCE_PT = 2;
+/**
+* Lay the tagged cells onto a column grid read from the page.
+*
+* A structure tree states no column widths, and states `/ColSpan` only when its
+* producer bothered: 160F-2019.pdf tags twenty-six columns and then writes rows
+* of three plain `TD`s that visually run half the page. Believed literally,
+* those three sat in columns 0–2 while twenty-three stood empty beside them,
+* and 153 characters were asked to fit in 7.7pt — one page reconstructed as
+* five, a word to a line.
+*
+* So the grid comes from where the cells actually START. Every distinct start
+* across the table is a column boundary; a cell runs from its own boundary to
+* the next cell's in its row, which is its span; and the width of a column is
+* the distance to the next boundary. The tagged `/ColSpan` still sets a floor,
+* so a producer that did the work is never contradicted.
+*
+* Falls back to the tagged spans over an equal grid when the page says too
+* little — fewer than two distinct starts, or a table whose cells hold no text.
+*
+* @param raw The rows as tagged, each cell carrying its page x where it has one.
+* @returns The rows with spans resolved, and one width per column.
+*/
+function layOutColumns(raw) {
+	const bounds = columnBounds(raw);
+	if (bounds.length < 2) return equalGrid(raw);
+	const indexOf = (x) => {
+		let best = 0;
+		for (let i = 0; i < bounds.length; i++) if (x >= bounds[i] - COLUMN_TOLERANCE_PT) best = i;
+		return best;
+	};
+	const rows = raw.map(({ header, cells }) => {
+		const out = [];
+		let col = 0;
+		cells.forEach((cell, i) => {
+			const start = cell.x !== void 0 ? Math.max(col, indexOf(cell.x)) : col;
+			const nextX = cells.slice(i + 1).find((c) => c.x !== void 0)?.x;
+			const end = nextX !== void 0 ? Math.max(start + 1, indexOf(nextX)) : bounds.length;
+			const span = Math.max(cell.span, end - start, 1);
+			out.push({
+				properties: span > 1 ? { colSpan: span } : {},
+				content: cell.content
+			});
+			col = start + span;
+		});
+		return {
+			properties: header ? { isHeader: true } : {},
+			cells: out
+		};
+	});
+	const widths = bounds.map((x, i) => i + 1 < bounds.length ? bounds[i + 1] - x : 0);
+	const tableRight = Math.max(...raw.flatMap((r) => r.cells.map((c) => c.right ?? 0)), bounds[bounds.length - 1]);
+	widths[widths.length - 1] = Math.max(0, tableRight - bounds[bounds.length - 1]);
+	const total = widths.reduce((a, b) => a + Math.max(MIN_COLUMN_PT, b), 0);
+	const scale = total > 0 ? ASSUMED_CONTENT_WIDTH_PT / total : 1;
+	return {
+		rows,
+		grid: widths.map((w) => pt(Math.max(1, Math.max(MIN_COLUMN_PT, w) * scale)))
+	};
+}
+/** Every distinct cell start across the table, ascending — the column boundaries. */
+function columnBounds(raw) {
+	const xs = raw.flatMap((r) => r.cells.map((c) => c.x)).filter((x) => x !== void 0).sort((a, b) => a - b);
+	const bounds = [];
+	for (const x of xs) {
+		const last = bounds[bounds.length - 1];
+		if (last === void 0 || x - last > COLUMN_TOLERANCE_PT) bounds.push(x);
+	}
+	return bounds;
+}
+/** The old reading: the tagged spans, over columns of equal width. */
+function equalGrid(raw) {
+	const rows = raw.map(({ header, cells }) => ({
+		properties: header ? { isHeader: true } : {},
+		cells: cells.map((c) => ({
+			properties: c.span > 1 ? { colSpan: c.span } : {},
+			content: c.content
+		}))
+	}));
+	const numCols = Math.max(1, ...rows.map((r) => r.cells.reduce((s, c) => s + (c.properties.colSpan ?? 1), 0)));
+	const w = pt(Math.max(1, ASSUMED_CONTENT_WIDTH_PT / numCols));
+	return {
+		rows,
+		grid: Array.from({ length: numCols }, () => w)
+	};
+}
 function squash(text) {
 	return text.replace(/\s+/g, " ").trim();
 }

package/dist/esm/pdf-reader/text.d.ts

@@ -1,4 +1,5 @@
-import { TextRun } from './content.js';
+import { ContentFont, TextRun } from './content.js';
+import { PdfDict } from '../pdf/objects.js';
 import { PdfFile, PdfPage } from './document.js';
 /**
  * Extract a page's text as positioned {@link TextRun}s (E-PDF EP2/EP8/EP13).
@@ -12,3 +13,14 @@ import { PdfFile, PdfPage } from './document.js';
  * @returns The page's runs, each carrying an `href` when it sits under a link.
  */
 export declare function extractPageText(file: PdfFile, page: PdfPage): Array<TextRun>;
+/**
+ * The `/Font` resources of one dictionary, built into interpreter fonts. Shared
+ * with the path and picture walks, which need them for one thing only: a Type 3
+ * font's glyphs are content streams (§9.6.5), and a walk that interprets with
+ * no fonts at all cannot see that there is anything to run.
+ *
+ * @param file      The owning file.
+ * @param resources The resource dictionary to read `/Font` from.
+ * @returns Resource name → font, skipping any the reader cannot build.
+ */
+export declare function buildFonts(file: PdfFile, resources: PdfDict | undefined): Map<string, ContentFont>;

package/dist/esm/pdf-reader/text.js

@@ -1,6 +1,8 @@
 import { PDF_NULL, PdfName, PdfStream } from "../pdf/objects.js";
 import { IDENTITY, interpretContent, multiply } from "./content.js";
+import { collectPageAppearances } from "./annots.js";
 import { buildContentFont } from "./font.js";
+import { patternTint } from "./pattern-tint.js";
 //#region src/pdf-reader/text.ts
 var MAX_FORM_DEPTH = 8;
 /**
@@ -17,6 +19,7 @@ var MAX_FORM_DEPTH = 8;
 function extractPageText(file, page) {
 	const runs = [];
 	collectRuns(file, page.resources, file.pageContent(page), IDENTITY, 0, /* @__PURE__ */ new Set(), runs);
+	for (const appearance of collectPageAppearances(file, page)) collectRuns(file, appearance.resources ?? page.resources, file.streamData(appearance.stream), appearance.ctm, 1, new Set([appearance.stream]), runs);
 	const links = collectLinks(file, page);
 	if (links.length === 0) return runs;
 	return runs.map((run) => {
@@ -29,8 +32,15 @@ function extractPageText(file, page) {
 }
 function collectRuns(file, resources, content, baseCtm, depth, visiting, out) {
 	const result = interpretContent(content, buildFonts(file, resources), baseCtm);
-	out.push(...result.texts);
-	if (depth >= MAX_FORM_DEPTH || !resources) return;
+	out.push(...result.texts.map((r) => withPatternColour(file, resources, r, visiting)));
+	if (depth >= MAX_FORM_DEPTH) return;
+	for (const glyph of result.glyphs) {
+		if (visiting.has(glyph.stream)) continue;
+		visiting.add(glyph.stream);
+		collectRuns(file, glyph.resources ?? resources, file.streamData(glyph.stream), glyph.ctm, depth + 1, visiting, out);
+		visiting.delete(glyph.stream);
+	}
+	if (!resources) return;
 	const xobjects = file.get(resources, "XObject");
 	if (!(xobjects instanceof Map)) return;
 	for (const placement of result.images) {
@@ -44,6 +54,63 @@ function collectRuns(file, resources, content, baseCtm, depth, visiting, out) {
 		visiting.delete(stream);
 	}
 }
+/**
+* §8.6.6.2 — a run whose glyphs the page fills with a tiling PATTERN, given the
+* pattern's own colour.
+*
+* A pattern is a content stream, not a colour, and type cannot be filled with
+* one here: what a run carries is a single colour. Painting it in whatever was
+* set before the pattern was is simply wrong — it comes out black where the
+* page shows magenta. The pattern's first mark says what colour the page meant,
+* and the glyphs take that. A documented approximation: the shape of the
+* pattern is lost, its colour is not.
+*
+* @param file      The owning file.
+* @param resources The resources the run was drawn with.
+* @param run       The run, which may name a fill pattern.
+* @param visiting  The streams already being interpreted, against a cycle.
+* @returns The run, its colour taken from the pattern where there is one.
+*/
+function withPatternColour(file, resources, run, visiting) {
+	const name = run.fillPatternName;
+	if (name === void 0 || !resources) return run;
+	const patterns = file.get(resources, "Pattern");
+	if (!(patterns instanceof Map)) return run;
+	const stream = file.resolve(patterns.get(name) ?? PDF_NULL);
+	if (!(stream instanceof PdfStream) || visiting.has(stream)) return run;
+	visiting.add(stream);
+	try {
+		const tint = patternTint(file, resources, name);
+		return tint ? {
+			...run,
+			colorHex: tintedHex(tint.colorHex, tint.coverage)
+		} : run;
+	} catch {
+		return run;
+	} finally {
+		visiting.delete(stream);
+	}
+}
+/** A colour laid over white paper at `coverage` strength, as a 6-hex string. */
+function tintedHex(colorHex, coverage) {
+	const k = Math.min(1, Math.max(0, coverage));
+	if (k >= 1) return colorHex;
+	const channel = (at) => {
+		const c = Number.parseInt(colorHex.slice(at, at + 2), 16);
+		return Math.round(255 - (255 - (Number.isFinite(c) ? c : 0)) * k).toString(16).toUpperCase().padStart(2, "0");
+	};
+	return `${channel(0)}${channel(2)}${channel(4)}`;
+}
+/**
+* The `/Font` resources of one dictionary, built into interpreter fonts. Shared
+* with the path and picture walks, which need them for one thing only: a Type 3
+* font's glyphs are content streams (§9.6.5), and a walk that interprets with
+* no fonts at all cannot see that there is anything to run.
+*
+* @param file      The owning file.
+* @param resources The resource dictionary to read `/Font` from.
+* @returns Resource name → font, skipping any the reader cannot build.
+*/
 function buildFonts(file, resources) {
 	const fonts = /* @__PURE__ */ new Map();
 	if (!resources) return fonts;
@@ -107,4 +174,4 @@ function inRect(x, y, r) {
 	return x >= r[0] - 1 && x <= r[2] + 1 && y >= r[1] - 2 && y <= r[3] + 2;
 }
 //#endregion
-export { extractPageText };
+export { buildFonts, extractPageText };

package/dist/esm/pdf-reader/vector.d.ts

@@ -1,5 +1,6 @@
 import { PathSeg } from './content.js';
 import { ShapeGradient } from '../core/vector.js';
+import { Loss } from '../core/ir/index.js';
 import { PdfFile, PdfPage } from './document.js';
 /**
  * One painted vector path lifted off a page (E-PDF EP10/EP11/EP16c): the path
@@ -8,11 +9,21 @@ import { PdfFile, PdfPage } from './document.js';
  * marked-content id.
  */
 export interface PdfVector {
+    /**
+     * §8.5.3 — where this was painted, as the chain of positions leading to it:
+     * `[4]` is the fifth mark of the page, `[4, 2]` the third mark of the form
+     * that mark called. Compared element by element it is the page's painting
+     * order across forms and patterns alike, which is the only thing that says
+     * what covers what.
+     */
+    readonly orderKey: ReadonlyArray<number>;
     readonly segs: ReadonlyArray<PathSeg>;
     /** Present iff a qualifying solid fill survived (EP10). */
     readonly fillHex?: string;
     /** Present iff a shading-pattern fill survived (EP16c). */
     readonly gradient?: ShapeGradient;
+    /** §11.6.4.4 — how opaque the fill is, when the page asked for less than all. */
+    readonly alpha?: number;
     /** Present iff a qualifying stroke survived (EP11). */
     readonly strokeHex?: string;
     /** Stroke width in page-space points (EP11). */
@@ -32,4 +43,17 @@ export interface PdfVector {
  * genuine coloured shapes, lines and gradients without the dot / page-background
  * clutter. Clips and the bare `sh` operator are not captured (a documented loss).
  */
-export declare function collectPageVectors(file: PdfFile, page: PdfPage): Array<PdfVector>;
+export declare function collectPageVectors(file: PdfFile, page: PdfPage, occupied?: ReadonlyArray<Box>): PageVectors;
+/** The paths lifted off one page, plus a loss if the page ran past the cap. */
+export interface PageVectors {
+    readonly vectors: Array<PdfVector>;
+    readonly losses: ReadonlyArray<Loss>;
+}
+/** A page-space rectangle: what something covers. */
+interface Box {
+    readonly minX: number;
+    readonly minY: number;
+    readonly maxX: number;
+    readonly maxY: number;
+}
+export {};

package/dist/esm/pdf-reader/vector.js

@@ -1,11 +1,111 @@
-import { IDENTITY, interpretContent } from "./content.js";
-import { buildShadingMap } from "./shading.js";
+import { PDF_NULL, PdfName, PdfStream } from "../pdf/objects.js";
+import { FEATURES } from "../core/ir/features.js";
+import { IDENTITY, interpretContent, multiply } from "./content.js";
+import { collectPageAppearances } from "./annots.js";
+import { buildFonts } from "./text.js";
+import { buildAlphaMap, buildShadingMap } from "./shading.js";
 //#region src/pdf-reader/vector.ts
-var NO_FONTS = /* @__PURE__ */ new Map();
-var MIN_SIDE = 2;
-var MIN_AREA = 16;
+/**
+* Every vector the page paints, its FORM XOBJECTS included (§8.8).
+*
+* A `Do` of a form is a call: its content stream draws in the caller's space
+* through the form's own `/Matrix`. Interpreting the page stream alone reads
+* only what the page drew directly, and a document that puts its artwork in
+* forms — as every CAD and drawing producer does — comes back with none of it.
+* 22060_A1_01_Plans.pdf holds eleven, and its floor plans were simply absent.
+*
+* The same walk `collectPageImages` already makes, with the same depth and
+* cycle guards, collecting paths instead of pictures.
+*/
+function paintedVectors(file, page, shadings, alphas) {
+	const out = [];
+	const visiting = /* @__PURE__ */ new Set();
+	const walk = (resources, content, baseCtm, depth, prefix) => {
+		if (out.length >= MAX_VECTORS) return;
+		const xobjects = resources ? file.get(resources, "XObject") : PDF_NULL;
+		const xobjDict = xobjects instanceof Map ? xobjects : void 0;
+		const result = interpretContent(content, buildFonts(file, resources), baseCtm, shadings, alphas);
+		const events = [
+			...result.vectors.map((vector) => ({
+				order: vector.order,
+				vector
+			})),
+			...result.images.map((xobject) => ({
+				order: xobject.order,
+				xobject
+			})),
+			...result.glyphs.map((glyph) => ({
+				order: glyph.order,
+				glyph
+			}))
+		].sort((a, b) => a.order - b.order);
+		for (const event of events) {
+			if (out.length >= MAX_VECTORS) return;
+			if (event.vector) {
+				out.push({
+					...event.vector,
+					orderKey: [...prefix, event.order]
+				});
+				continue;
+			}
+			if (event.glyph) {
+				const call = event.glyph;
+				if (depth >= MAX_FORM_DEPTH || visiting.has(call.stream)) continue;
+				visiting.add(call.stream);
+				walk(call.resources ?? resources, file.streamData(call.stream), call.ctm, depth + 1, [...prefix, call.order]);
+				visiting.delete(call.stream);
+				continue;
+			}
+			const placement = event.xobject;
+			if (depth >= MAX_FORM_DEPTH) continue;
+			const stream = xobjDict ? file.resolve(xobjDict.get(placement.name) ?? PDF_NULL) : PDF_NULL;
+			if (!(stream instanceof PdfStream) || visiting.has(stream)) continue;
+			const subtype = file.get(stream.dict, "Subtype");
+			if (!(subtype instanceof PdfName) || subtype.value !== "Form") continue;
+			visiting.add(stream);
+			const formRes = file.get(stream.dict, "Resources");
+			walk(formRes instanceof Map ? formRes : resources, file.streamData(stream), multiply(formMatrix(file, stream.dict), placement.ctm), depth + 1, [...prefix, placement.order]);
+			visiting.delete(stream);
+		}
+	};
+	walk(page.resources, file.pageContent(page), IDENTITY, 0, []);
+	collectPageAppearances(file, page).forEach((appearance, index) => {
+		walk(appearance.resources ?? page.resources, file.streamData(appearance.stream), appearance.ctm, 1, [Number.MAX_SAFE_INTEGER, index]);
+	});
+	return out;
+}
+/** §8.10.2 `/Matrix` — the form's own space, composed onto the placement CTM. */
+function formMatrix(file, dict) {
+	const m = file.resolve(dict.get("Matrix") ?? PDF_NULL);
+	if (!Array.isArray(m) || m.length !== 6) return IDENTITY;
+	const n = m.map((v) => typeof file.resolve(v) === "number" ? file.resolve(v) : 0);
+	return [
+		n[0],
+		n[1],
+		n[2],
+		n[3],
+		n[4],
+		n[5]
+	];
+}
+var MIN_SIDE = .5;
+var MIN_AREA = 2;
 var MIN_STROKE_LEN = 6;
-var MAX_VECTORS = 2e3;
+var MIN_RULE_LEN = 2;
+/**
+* How many painted paths a page may hand over, as a guard against a file built
+* to exhaust a reader.
+*
+* This was two thousand, and it was not a guard, it was a silent truncation:
+* the busiest page of Brotli-Prototype-FileA.pdf keeps 1994 paths AFTER the
+* de-cluttering filter, so the cap cut the page off partway and took its whole
+* title block, the vegetation of its perspective and every hatch in its legend
+* with it — with nothing in the report to say a thing was missing. Twenty
+* thousand leaves room for a drawing and still bounds the work (that file's
+* twenty-five sheets read in 420ms); reaching it is now reported.
+*/
+var MAX_VECTORS = 2e4;
+var MAX_FORM_DEPTH = 12;
 /**
 * Lift the painted vector paths off a page (E-PDF EP10/EP11/EP16c). Runs the
 * content interpreter for its fill (EP10), stroke (EP11) and shading-pattern
@@ -15,25 +115,38 @@ var MAX_VECTORS = 2e3;
 * genuine coloured shapes, lines and gradients without the dot / page-background
 * clutter. Clips and the bare `sh` operator are not captured (a documented loss).
 */
-function collectPageVectors(file, page) {
+function collectPageVectors(file, page, occupied = []) {
 	const [px0, py0, px1, py1] = page.mediaBox;
 	const pageArea = Math.max(1, Math.abs((px1 - px0) * (py1 - py0)));
 	const shadings = buildShadingMap(file, page);
+	const alphas = buildAlphaMap(file, page);
 	const out = [];
-	for (const v of interpretContent(file.pageContent(page), NO_FONTS, IDENTITY, shadings).vectors) {
+	const painted = [...occupied];
+	const raws = paintedVectors(file, page, shadings, alphas);
+	for (const raw of raws) {
 		if (out.length >= MAX_VECTORS) break;
+		const v = clipped(raw);
+		if (!v) continue;
 		const b = bbox(v.segs);
 		if (!b) continue;
 		const w = b.maxX - b.minX;
 		const h = b.maxY - b.minY;
 		const area = w * h;
-		const solidFill = v.fillHex !== void 0 && v.fillHex !== "FFFFFF";
-		const filled = (v.gradient !== void 0 || solidFill) && w >= MIN_SIDE && h >= MIN_SIDE && area >= MIN_AREA && area <= .85 * pageArea;
-		const stroked = v.strokeHex !== void 0 && v.strokeHex !== "FFFFFF" && Math.max(w, h) >= MIN_STROKE_LEN && area <= .85 * pageArea;
+		const white = v.fillHex === "FFFFFF";
+		const solidFill = v.patternName === void 0 && v.fillHex !== void 0 && (!white || painted.some((box) => overlaps(box, b)));
+		const long = Math.max(w, h);
+		const short = Math.min(w, h);
+		const isBox = short >= MIN_SIDE && area >= MIN_AREA;
+		const isRule = long >= MIN_RULE_LEN && short > 0;
+		const filled = (v.gradient !== void 0 || solidFill) && (isBox || isRule) && area <= .85 * pageArea;
+		const stroked = v.strokeHex !== void 0 && (v.strokeHex !== "FFFFFF" || painted.some((box) => overlaps(box, b))) && Math.max(w, h) >= MIN_STROKE_LEN && area <= .85 * pageArea;
 		if (!filled && !stroked) continue;
+		painted.push(b);
 		out.push({
+			orderKey: v.orderKey,
 			segs: v.segs,
 			...filled ? v.gradient ? { gradient: v.gradient } : v.fillHex !== void 0 ? { fillHex: v.fillHex } : {} : {},
+			...filled && v.alpha !== void 0 ? { alpha: v.alpha } : {},
 			...stroked ? {
 				strokeHex: v.strokeHex,
 				...v.lineWidth !== void 0 ? { lineWidth: v.lineWidth } : {}
@@ -42,7 +155,50 @@ function collectPageVectors(file, page) {
 			...v.mcid !== void 0 ? { mcid: v.mcid } : {}
 		});
 	}
-	return out;
+	return {
+		vectors: out,
+		losses: out.length >= MAX_VECTORS || raws.length >= MAX_VECTORS ? [{
+			severity: "dropped",
+			feature: FEATURES.shapes,
+			detail: `page carries more than ${String(MAX_VECTORS)} painted paths; the rest were not read`
+		}] : []
+	};
+}
+/** Whether two boxes share any area at all. */
+function overlaps(a, b) {
+	return a.minX < b.maxX && b.minX < a.maxX && a.minY < b.maxY && b.minY < a.maxY;
+}
+/**
+* §8.5.4 — what a painted path actually MARKS, once its clip is honoured.
+*
+* The mark is the intersection of the path with the clipping region, and one
+* observation decides it without intersecting anything: where the path covers
+* the clip, the intersection IS the clip. That is the stencil every drawing
+* producer writes — 22060_A1_01_Plans.pdf paints four black rectangles of
+* 397×421pt through clips cut to its floor plans, and read as rectangles they
+* flooded two thirds of an A3 sheet in black.
+*
+* So the smaller region stands: a path inside its clip is itself, a path around
+* its clip becomes the clip in the paint's own colour. Neither is a general
+* path intersection, and where the two merely overlap the answer is the smaller
+* of them — bounded, never larger than the truth.
+*
+* @param v The painted path as the interpreter saw it.
+* @returns The path to draw, or `undefined` when the clip leaves nothing.
+*/
+function clipped(v) {
+	const clip = v.clip;
+	if (!clip) return v;
+	const b = bbox(v.segs);
+	if (!b) return v;
+	if (clip.minX >= b.maxX || clip.maxX <= b.minX || clip.minY >= b.maxY || clip.maxY <= b.minY) return;
+	const pathArea = Math.max(0, b.maxX - b.minX) * Math.max(0, b.maxY - b.minY);
+	if (Math.max(0, clip.maxX - clip.minX) * Math.max(0, clip.maxY - clip.minY) >= pathArea) return v;
+	return {
+		...v,
+		clip: void 0,
+		segs: clip.segs
+	};
 }
 function bbox(segs) {
 	let minX = Infinity;

package/dist/esm/pptx/slide-parser.js

@@ -665,6 +665,9 @@ function parseTxBody(txBody, ph, cascade, colors, resolveLink, styleColor, theme
 	const autofit = bodyPr ? poChildren(bodyPr).find((c) => poIs(c, "a:normAutofit")) : void 0;
 	const shrink = autofit !== void 0 && poIntAttr(autofit, "fontScale") === void 0;
 	const warp = bodyPr ? textWarp(bodyPr) : void 0;
+	const v = bodyPr ? poAttr(bodyPr, "vert") : void 0;
+	const vertical = v === "vert270" ? "vert270" : v !== void 0 && v !== "horz" ? "vert" : void 0;
+	const upright = bodyPr ? poAttr(bodyPr, "upright") === "1" : false;
 	const anchor = a === "ctr" || a === "b" || a === "t" ? a : ph && cascade ? cascade.anchorFor(ph) : void 0;
 	return {
 		content: fitted,
@@ -673,6 +676,8 @@ function parseTxBody(txBody, ph, cascade, colors, resolveLink, styleColor, theme
 		...rIns !== void 0 ? { insetRight: emuToPt(rIns) } : {},
 		...bIns !== void 0 ? { insetBottom: emuToPt(bIns) } : {},
 		...anchor ? { anchor } : {},
+		...vertical ? { vertical } : {},
+		...upright ? { upright } : {},
 		...shrink ? { shrinkToFit: true } : {},
 		...warp ? { warp } : {}
 	};