reamkit 1.6.0 → 1.9.0

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

@@ -0,0 +1,90 @@
+import { PDF_NULL, PdfName, PdfStream } from "../pdf/objects.js";
+import { FEATURES } from "../core/ir/features.js";
+import { interpretContent, multiply } from "./content.js";
+import { decodePdfImage } from "./image-decode.js";
+//#region src/pdf-reader/images.ts
+var NO_FONTS = /* @__PURE__ */ new Map();
+var MAX_FORM_DEPTH = 12;
+var MAX_IMAGES = 4096;
+function collectPageImages(file, page) {
+	const images = [];
+	const lossByDetail = /* @__PURE__ */ new Map();
+	const visiting = /* @__PURE__ */ new Set();
+	const addLoss = (severity, detail) => {
+		if (!lossByDetail.has(detail)) lossByDetail.set(detail, {
+			severity,
+			feature: FEATURES.images,
+			detail
+		});
+	};
+	const walk = (resources, content, baseCtm, depth, inheritedMcid) => {
+		const xobjects = resources ? file.get(resources, "XObject") : PDF_NULL;
+		const xobjDict = xobjects instanceof Map ? xobjects : void 0;
+		for (const placement of interpretContent(content, NO_FONTS, baseCtm).images) {
+			if (images.length >= MAX_IMAGES) return;
+			const stream = xobjDict ? file.resolve(xobjDict.get(placement.name) ?? PDF_NULL) : PDF_NULL;
+			if (!(stream instanceof PdfStream)) continue;
+			const subtype = nameOf(file.get(stream.dict, "Subtype"));
+			const mcid = placement.mcid ?? inheritedMcid;
+			if (subtype === "Image") {
+				const decoded = decodePdfImage(file, stream);
+				if (decoded.ok) {
+					images.push(geometry(placement.ctm, decoded, mcid));
+					if (decoded.degraded) addLoss("degraded", decoded.degraded);
+				} else addLoss(decoded.severity, decoded.detail);
+			} else if (subtype === "Form" && depth < MAX_FORM_DEPTH && !visiting.has(stream)) {
+				visiting.add(stream);
+				const formRes = file.get(stream.dict, "Resources");
+				walk(formRes instanceof Map ? formRes : resources, file.streamData(stream), multiply(matrixOf(file, stream.dict), placement.ctm), depth + 1, mcid);
+				visiting.delete(stream);
+			}
+		}
+	};
+	walk(page.resources, file.pageContent(page), [
+		1,
+		0,
+		0,
+		1,
+		0,
+		0
+	], 0, void 0);
+	return {
+		images,
+		losses: [...lossByDetail.values()]
+	};
+}
+function geometry(ctm, decoded, mcid) {
+	return {
+		bytes: decoded.bytes,
+		format: decoded.format,
+		widthPt: Math.hypot(ctm[0], ctm[1]) || 1,
+		heightPt: Math.hypot(ctm[2], ctm[3]) || 1,
+		x: ctm[4],
+		y: ctm[5],
+		...mcid !== void 0 ? { mcid } : {}
+	};
+}
+function matrixOf(file, dict) {
+	const m = file.resolve(dict.get("Matrix") ?? PDF_NULL);
+	if (Array.isArray(m) && m.length >= 6 && m.every((v) => typeof v === "number")) return [
+		m[0],
+		m[1],
+		m[2],
+		m[3],
+		m[4],
+		m[5]
+	];
+	return [
+		1,
+		0,
+		0,
+		1,
+		0,
+		0
+	];
+}
+function nameOf(v) {
+	return v instanceof PdfName ? v.value : "";
+}
+//#endregion
+export { collectPageImages };

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

@@ -1,3 +1,3 @@
-import { FlowDoc } from '../core/ir/flow.js';
 import { PdfFile } from './document.js';
-export declare function reconstructByLayout(file: PdfFile): FlowDoc;
+import { Reconstruction } from './flow-build.js';
+export declare function reconstructByLayout(file: PdfFile): Reconstruction;

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

@@ -1,12 +1,77 @@
-import { buildFlowDoc, paragraphBlock } from "./flow-build.js";
+import { ResourceStore } from "../core/ir/resources.js";
+import { buildFlowDoc, dedupeLosses, imageBlock, paragraphFromRuns, shapeBlock } from "./flow-build.js";
+import { collectPageImages } from "./images.js";
 import { extractPageText } from "./text.js";
+import { collectPageVectors } from "./vector.js";
 //#region src/pdf-reader/layout.ts
 function reconstructByLayout(file) {
-	const pages = file.pages().map((page) => groupIntoLines(extractPageText(file, page)).filter((l) => l.text.length > 0));
-	const medianFont = median(pages.flat().map((l) => l.fontSize)) || 12;
+	const pages = file.pages();
+	const pageRuns = pages.map((page) => extractPageText(file, page));
+	const medianFont = median(pageRuns.flat().map((r) => r.fontSizePt).filter((s) => s > 0)) || 12;
+	const resources = new ResourceStore();
+	const losses = [];
 	const body = [];
-	for (const lines of pages) for (const para of groupIntoParagraphs(lines)) body.push(paragraphBlock(para.text, headingLevel(para.fontSize, medianFont)));
-	return buildFlowDoc(body);
+	pages.forEach((page, i) => {
+		const runs = pageRuns[i];
+		const [px0, , px1] = page.mediaBox;
+		const gutter = detectGutter(runs, Math.abs(px1 - px0));
+		const blocks = [];
+		const addColumn = (colRuns, col) => {
+			const lines = groupIntoLines(colRuns).filter((l) => l.text.length > 0);
+			for (const para of groupIntoParagraphs(lines)) blocks.push({
+				col,
+				top: para.top,
+				el: paragraphFromRuns(para.spans, headingLevel(para.fontSize, medianFont))
+			});
+		};
+		if (gutter !== void 0) {
+			addColumn(runs.filter((r) => r.x < gutter), 0);
+			addColumn(runs.filter((r) => r.x >= gutter), 1);
+		} else addColumn(runs, 0);
+		const colOf = (centerX) => gutter !== void 0 && centerX >= gutter ? 1 : 0;
+		const imgs = collectPageImages(file, page);
+		losses.push(...imgs.losses);
+		for (const img of imgs.images) blocks.push({
+			col: colOf(img.x + img.widthPt / 2),
+			top: img.y + img.heightPt,
+			el: imageBlock(img, resources)
+		});
+		for (const v of collectPageVectors(file, page)) blocks.push({
+			col: colOf((v.minX + v.maxX) / 2),
+			top: v.maxY,
+			el: shapeBlock(v)
+		});
+		blocks.sort((a, b) => a.col - b.col || b.top - a.top);
+		for (const block of blocks) body.push(block.el);
+	});
+	return {
+		doc: buildFlowDoc(body, resources),
+		losses: dedupeLosses(losses)
+	};
+}
+function detectGutter(runs, pageWidth) {
+	if (runs.length < 30 || pageWidth <= 0) return void 0;
+	const fontSize = median(runs.map((r) => r.fontSizePt).filter((s) => s > 0)) || 10;
+	const right = (r) => r.x + Math.max(1, r.text.length) * (r.fontSizePt || fontSize) * .5;
+	const intervals = runs.map((r) => [r.x, right(r)]).sort((a, b) => a[0] - b[0]);
+	const minX = intervals[0][0];
+	const span = Math.max(...intervals.map((iv) => iv[1])) - minX;
+	if (span < pageWidth * .5) return void 0;
+	let curEnd = intervals[0][1];
+	let gapMid = 0;
+	let gapW = 0;
+	for (const [l, r] of intervals) {
+		if (l - curEnd > gapW) {
+			gapW = l - curEnd;
+			gapMid = (curEnd + l) / 2;
+		}
+		if (r > curEnd) curEnd = r;
+	}
+	const frac = (gapMid - minX) / span;
+	if (gapW < fontSize * 3 || frac < .35 || frac > .65) return void 0;
+	const left = runs.filter((r) => r.x < gapMid).length;
+	if (left < runs.length * .25 || left > runs.length * .75) return void 0;
+	return gapMid;
 }
 function groupIntoLines(runs) {
 	const sorted = [...runs].sort((a, b) => b.y - a.y || a.x - b.x);
@@ -25,22 +90,28 @@ function groupIntoLines(runs) {
 	}
 	return clusters.map((c) => {
 		const ordered = c.runs.sort((a, b) => a.x - b.x);
+		const fontSize = c.fontSize || 10;
+		const spans = lineSpans(ordered, fontSize);
 		return {
 			y: c.y,
-			fontSize: c.fontSize || 10,
-			text: joinLine(ordered, c.fontSize || 10)
+			fontSize,
+			text: spans.map((s) => s.text).join("").replace(/\s+/g, " ").trim(),
+			spans
 		};
 	});
 }
-function joinLine(runs, fontSize) {
-	let text = "";
+function lineSpans(runs, fontSize) {
+	const spans = [];
 	let prevEnd;
 	for (const run of runs) {
-		if (prevEnd !== void 0 && run.x - prevEnd > fontSize * .25) text += " ";
-		text += run.text;
+		if (prevEnd !== void 0 && run.x - prevEnd > fontSize * .25) spans.push({ text: " " });
+		spans.push(run.href !== void 0 ? {
+			text: run.text,
+			href: run.href
+		} : { text: run.text });
 		prevEnd = run.x + run.text.length * (run.fontSizePt || fontSize) * .5;
 	}
-	return text.replace(/\s+/g, " ").trim();
+	return spans;
 }
 function groupIntoParagraphs(lines) {
 	const groups = [];
@@ -52,8 +123,9 @@ function groupIntoParagraphs(lines) {
 		prevY = line.y;
 	}
 	return groups.map((g) => ({
-		text: g.map((l) => l.text).join(" ").replace(/\s+/g, " ").trim(),
-		fontSize: Math.max(...g.map((l) => l.fontSize))
+		spans: g.flatMap((l, i) => i > 0 ? [{ text: " " }, ...l.spans] : [...l.spans]),
+		fontSize: Math.max(...g.map((l) => l.fontSize)),
+		top: g[0].y
 	}));
 }
 function headingLevel(fontSize, medianFont) {

package/dist/esm/pdf-reader/png-encode.d.ts

@@ -0,0 +1,2 @@
+export type PngColor = 'gray' | 'rgb' | 'gray-alpha' | 'rgba';
+export declare function encodePng(width: number, height: number, color: PngColor, samples: Uint8Array): Uint8Array;

package/dist/esm/pdf-reader/png-encode.js

@@ -0,0 +1,98 @@
+import { zlibSync } from "fflate";
+//#region src/pdf-reader/png-encode.ts
+var COLOR_TYPE = {
+	gray: 0,
+	rgb: 2,
+	"gray-alpha": 4,
+	rgba: 6
+};
+var CHANNELS = {
+	gray: 1,
+	rgb: 3,
+	"gray-alpha": 2,
+	rgba: 4
+};
+var SIGNATURE = Uint8Array.from([
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10
+]);
+function encodePng(width, height, color, samples) {
+	const stride = width * CHANNELS[color];
+	const raw = new Uint8Array(height * (stride + 1));
+	for (let y = 0; y < height; y++) {
+		const dst = y * (stride + 1);
+		raw[dst] = 0;
+		raw.set(samples.subarray(y * stride, y * stride + stride), dst + 1);
+	}
+	const idat = zlibSync(raw);
+	const ihdr = new Uint8Array(13);
+	writeU32(ihdr, 0, width);
+	writeU32(ihdr, 4, height);
+	ihdr[8] = 8;
+	ihdr[9] = COLOR_TYPE[color];
+	ihdr[10] = 0;
+	ihdr[11] = 0;
+	ihdr[12] = 0;
+	return concat([
+		SIGNATURE,
+		chunk("IHDR", ihdr),
+		chunk("IDAT", idat),
+		chunk("IEND", new Uint8Array(0))
+	]);
+}
+function chunk(type, data) {
+	const typeBytes = Uint8Array.from([
+		type.charCodeAt(0),
+		type.charCodeAt(1),
+		type.charCodeAt(2),
+		type.charCodeAt(3)
+	]);
+	const out = new Uint8Array(12 + data.length);
+	writeU32(out, 0, data.length);
+	out.set(typeBytes, 4);
+	out.set(data, 8);
+	const crcInput = new Uint8Array(4 + data.length);
+	crcInput.set(typeBytes, 0);
+	crcInput.set(data, 4);
+	writeU32(out, 8 + data.length, crc32(crcInput));
+	return out;
+}
+function writeU32(buf, offset, value) {
+	buf[offset] = value >>> 24 & 255;
+	buf[offset + 1] = value >>> 16 & 255;
+	buf[offset + 2] = value >>> 8 & 255;
+	buf[offset + 3] = value & 255;
+}
+function concat(parts) {
+	let total = 0;
+	for (const p of parts) total += p.length;
+	const out = new Uint8Array(total);
+	let off = 0;
+	for (const p of parts) {
+		out.set(p, off);
+		off += p.length;
+	}
+	return out;
+}
+var crcTable;
+function crc32(bytes) {
+	if (!crcTable) {
+		crcTable = new Uint32Array(256);
+		for (let n = 0; n < 256; n++) {
+			let c = n;
+			for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+			crcTable[n] = c >>> 0;
+		}
+	}
+	let crc = 4294967295;
+	for (const b of bytes) crc = crcTable[(crc ^ b) & 255] ^ crc >>> 8;
+	return (crc ^ 4294967295) >>> 0;
+}
+//#endregion
+export { encodePng };

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

@@ -0,0 +1,7 @@
+export interface PredictorParams {
+    readonly predictor: number;
+    readonly colors: number;
+    readonly bitsPerComponent: number;
+    readonly columns: number;
+}
+export declare function reversePredictor(data: Uint8Array, p: PredictorParams): Uint8Array;

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

@@ -0,0 +1,61 @@
+//#region src/pdf-reader/predictor.ts
+function reversePredictor(data, p) {
+	if (p.predictor < 2) return data;
+	const bpp = Math.max(1, Math.ceil(p.colors * p.bitsPerComponent / 8));
+	const rowBytes = Math.ceil(p.colors * p.bitsPerComponent * p.columns / 8);
+	if (rowBytes <= 0) return data;
+	if (p.predictor === 2) {
+		if (p.bitsPerComponent !== 8) return data;
+		const rows = Math.floor(data.length / rowBytes);
+		const out = data.slice(0, rows * rowBytes);
+		for (let r = 0; r < rows; r++) {
+			const off = r * rowBytes;
+			for (let i = bpp; i < rowBytes; i++) out[off + i] = out[off + i] + out[off + i - bpp] & 255;
+		}
+		return out;
+	}
+	const stride = rowBytes + 1;
+	const rows = Math.floor(data.length / stride);
+	const out = new Uint8Array(rows * rowBytes);
+	let prev = new Uint8Array(rowBytes);
+	for (let r = 0; r < rows; r++) {
+		const ft = data[r * stride];
+		const src = r * stride + 1;
+		const dst = r * rowBytes;
+		for (let i = 0; i < rowBytes; i++) {
+			const x = data[src + i];
+			const a = i >= bpp ? out[dst + i - bpp] : 0;
+			const b = prev[i];
+			const c = i >= bpp ? prev[i - bpp] : 0;
+			let v;
+			switch (ft) {
+				case 1:
+					v = x + a;
+					break;
+				case 2:
+					v = x + b;
+					break;
+				case 3:
+					v = x + (a + b >> 1);
+					break;
+				case 4:
+					v = x + paeth(a, b, c);
+					break;
+				default: v = x;
+			}
+			out[dst + i] = v & 255;
+		}
+		prev = out.subarray(dst, dst + rowBytes);
+	}
+	return out;
+}
+function paeth(a, b, c) {
+	const p = a + b - c;
+	const pa = Math.abs(p - a);
+	const pb = Math.abs(p - b);
+	const pc = Math.abs(p - c);
+	if (pa <= pb && pa <= pc) return a;
+	return pb <= pc ? b : c;
+}
+//#endregion
+export { reversePredictor };

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

@@ -1,4 +1,4 @@
 import { DocumentReader, ReadResult } from '../core/ir/adapters.js';
 import { FlowDoc } from '../core/ir/flow.js';
-export declare function readPdf(bytes: Uint8Array): ReadResult<FlowDoc>;
+export declare function readPdf(bytes: Uint8Array, password?: string): ReadResult<FlowDoc>;
 export declare const pdfReader: DocumentReader<FlowDoc>;

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

@@ -8,23 +8,29 @@ function sniffPdf(bytes) {
 	for (let i = 0; i <= limit; i++) if (bytes[i] === 37 && bytes[i + 1] === 80 && bytes[i + 2] === 68 && bytes[i + 3] === 70 && bytes[i + 4] === 45) return true;
 	return false;
 }
-function readPdf(bytes) {
-	const file = PdfFile.parse(bytes);
+function readPdf(bytes, password = "") {
+	const file = PdfFile.parse(bytes, password);
 	const losses = [];
+	if (file.encryptionUnsupported) losses.push({
+		severity: "dropped",
+		feature: FEATURES.text,
+		detail: "encrypted PDF — the user password was missing or incorrect, or the handler is unsupported"
+	});
 	const tagged = reconstructTaggedPdf(file);
-	const doc = tagged ?? reconstructByLayout(file);
+	const reconstruction = tagged ?? reconstructByLayout(file);
 	if (!tagged) losses.push({
 		severity: "degraded",
 		feature: FEATURES.text,
 		detail: "untagged PDF — text and headings reconstructed heuristically from glyph positions; structure is approximate"
 	});
+	losses.push(...reconstruction.losses);
 	losses.push({
 		severity: "dropped",
 		feature: FEATURES.images,
-		detail: "PDF images and vector graphics are not reconstructed"
+		detail: "PDF clipping paths and bare-shading (sh) vector regions are not reconstructed"
 	});
 	return {
-		doc,
+		doc: reconstruction.doc,
 		losses
 	};
 }
@@ -34,10 +40,11 @@ var pdfReader = {
 	supports: new Set([
 		FEATURES.text,
 		FEATURES.tables,
-		FEATURES.lists
+		FEATURES.lists,
+		FEATURES.images
 	]),
 	sniff: sniffPdf,
-	read: (bytes) => readPdf(bytes)
+	read: (bytes, opts) => readPdf(bytes, typeof opts?.password === "string" ? opts.password : "")
 };
 //#endregion
 export { pdfReader };

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

@@ -0,0 +1,3 @@
+import { ShapeGradient } from '../core/vector.js';
+import { PdfFile, PdfPage } from './document.js';
+export declare function buildShadingMap(file: PdfFile, page: PdfPage): Map<string, ShapeGradient>;

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

@@ -0,0 +1,147 @@
+import { PDF_NULL, PdfStream } from "../pdf/objects.js";
+//#region src/pdf-reader/shading.ts
+function buildShadingMap(file, page) {
+	const out = /* @__PURE__ */ new Map();
+	if (!page.resources) return out;
+	const patterns = file.get(page.resources, "Pattern");
+	if (!(patterns instanceof Map)) return out;
+	for (const [nm, value] of patterns) {
+		const pat = file.resolve(value);
+		if (!(pat instanceof Map)) continue;
+		const shading = dictOf(file.resolve(pat.get("Shading") ?? PDF_NULL));
+		if (!shading) continue;
+		const gradient = parseShading(file, shading);
+		if (gradient) out.set(nm, gradient);
+	}
+	return out;
+}
+function parseShading(file, sh) {
+	const type = numOf(file.get(sh, "ShadingType"));
+	if (type !== 2 && type !== 3) return void 0;
+	const stops = parseFunction(file, sh.get("Function"));
+	if (!stops || stops.length === 0) return void 0;
+	if (type === 3) return {
+		kind: "radial",
+		stops
+	};
+	const c = numArray(file, sh.get("Coords"));
+	return {
+		kind: "linear",
+		angle: c && c.length >= 4 ? (Math.atan2(-(c[3] - c[1]), c[2] - c[0]) * 180 / Math.PI % 360 + 360) % 360 : 0,
+		stops
+	};
+}
+function parseFunction(file, value) {
+	const resolved = value !== void 0 ? file.resolve(value) : void 0;
+	const dict = dictOf(resolved);
+	if (!dict) return void 0;
+	const type = numOf(file.get(dict, "FunctionType"));
+	if (type === 2) {
+		const c0 = colorOf(numArray(file, dict.get("C0")) ?? [0]);
+		const c1 = colorOf(numArray(file, dict.get("C1")) ?? [1]);
+		return [{
+			offset: 0,
+			colorHex: c0
+		}, {
+			offset: 1,
+			colorHex: c1
+		}];
+	}
+	if (type === 3) {
+		const fns = dict.get("Functions");
+		const subs = Array.isArray(fns) ? fns : void 0;
+		if (!subs) return void 0;
+		const bounds = numArray(file, dict.get("Bounds")) ?? [];
+		const domain = numArray(file, dict.get("Domain")) ?? [0, 1];
+		const d0 = domain[0] ?? 0;
+		const d1 = domain[domain.length - 1] ?? 1;
+		const edges = [
+			d0,
+			...bounds,
+			d1
+		];
+		const stops = [];
+		const span = d1 - d0 || 1;
+		for (let i = 0; i < subs.length; i++) {
+			const sub = parseFunction(file, subs[i]);
+			if (!sub || sub.length < 2) continue;
+			pushStop(stops, ((edges[i] ?? d0) - d0) / span, sub[0].colorHex);
+			pushStop(stops, ((edges[i + 1] ?? d1) - d0) / span, sub[sub.length - 1].colorHex);
+		}
+		return stops.length > 0 ? stops : void 0;
+	}
+	if (type === 0 && resolved instanceof PdfStream) return sampleFunction(file, resolved);
+}
+function sampleFunction(file, stream) {
+	const d = stream.dict;
+	const size = numArray(file, d.get("Size"));
+	const range = numArray(file, d.get("Range"));
+	const bps = numOf(file.get(d, "BitsPerSample"));
+	if (!size || !range || size.length < 1 || range.length < 2 || bps < 1) return void 0;
+	const n = size[0];
+	const comps = range.length / 2;
+	const data = file.streamData(stream);
+	const maxv = 2 ** bps - 1;
+	const bitAt = (sampleIdx, comp) => {
+		let bit = (sampleIdx * comps + comp) * bps;
+		let v = 0;
+		for (let k = 0; k < bps; k++) {
+			const byte = data[bit >> 3] ?? 0;
+			v = v << 1 | byte >> 7 - (bit & 7) & 1;
+			bit++;
+		}
+		return v;
+	};
+	const count = Math.min(Math.max(n, 2), 16);
+	const stops = [];
+	for (let s = 0; s < count; s++) {
+		const off = s / (count - 1);
+		const j = Math.round(off * (n - 1));
+		const c = [];
+		for (let comp = 0; comp < comps; comp++) {
+			const lo = range[comp * 2];
+			const hi = range[comp * 2 + 1];
+			c.push(lo + bitAt(j, comp) / maxv * (hi - lo));
+		}
+		pushStop(stops, off, colorOf(c));
+	}
+	return stops.length > 0 ? stops : void 0;
+}
+function dictOf(v) {
+	if (v instanceof PdfStream) return v.dict;
+	if (v instanceof Map) return v;
+}
+function numOf(v) {
+	return typeof v === "number" ? v : 0;
+}
+function numArray(file, v) {
+	const r = v !== void 0 ? file.resolve(v) : void 0;
+	if (!Array.isArray(r)) return void 0;
+	return r.map((x) => typeof x === "number" ? x : 0);
+}
+function colorOf(c) {
+	if (c.length >= 4) {
+		const k = c[3];
+		return hex255(255 * (1 - c[0]) * (1 - k), 255 * (1 - c[1]) * (1 - k), 255 * (1 - c[2]) * (1 - k));
+	}
+	if (c.length === 3) return hex255(c[0] * 255, c[1] * 255, c[2] * 255);
+	const g = (c[0] ?? 0) * 255;
+	return hex255(g, g, g);
+}
+function hex255(r, g, b) {
+	const h = (x) => Math.max(0, Math.min(255, Math.round(x))).toString(16).padStart(2, "0");
+	return (h(r) + h(g) + h(b)).toUpperCase();
+}
+function pushStop(stops, offset, colorHex) {
+	const o = Math.max(0, Math.min(1, offset));
+	const last = stops[stops.length - 1];
+	if (last && Math.abs(last.offset - o) < 1e-6) {
+		if (last.colorHex === colorHex) return;
+	}
+	stops.push({
+		offset: o,
+		colorHex
+	});
+}
+//#endregion
+export { buildShadingMap };

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

@@ -1,3 +1,3 @@
-import { FlowDoc } from '../core/ir/flow.js';
 import { PdfFile } from './document.js';
-export declare function reconstructTaggedPdf(file: PdfFile): FlowDoc | undefined;
+import { Reconstruction } from './flow-build.js';
+export declare function reconstructTaggedPdf(file: PdfFile): Reconstruction | undefined;