reamkit 1.7.0 → 1.9.0

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

@@ -1,5 +1,6 @@
 import { PDF_NULL, PdfHexString, PdfName, PdfStream } from "../pdf/objects.js";
 import { reversePredictor } from "./predictor.js";
+import { decodeCcitt } from "./ccitt.js";
 import { encodePng } from "./png-encode.js";
 import { unzlibSync } from "fflate";
 //#region src/pdf-reader/image-decode.ts
@@ -32,9 +33,8 @@ function decodePdfImage(file, stream) {
 		heightPx: height,
 		degraded: "JPEG 2000 image — limited viewer support"
 	};
-	if (last === "CCITTFaxDecode" || last === "CCF" || last === "JBIG2Decode") return fail("dropped", "fax-encoded (CCITT/JBIG2) image not decoded");
-	if (last === "LZWDecode" || last === "LZW") return fail("dropped", "LZW-encoded image not decoded");
-	const decoded = decodeToSamples(file, stream, filters, width, height);
+	if (last === "JBIG2Decode") return fail("dropped", "JBIG2-encoded image not decoded");
+	const decoded = last === "CCITTFaxDecode" || last === "CCF" ? decodeCcittImage(file, stream, filters, width, height) : decodeToSamples(file, stream, filters, width, height);
 	if (typeof decoded === "string") return fail("dropped", decoded);
 	const alpha = decodeSMask(file, d, width, height);
 	const { color, samples } = alpha ? combineAlpha(decoded, alpha) : decoded;
@@ -56,6 +56,30 @@ function decodeToSamples(file, stream, filters, width, height) {
 	const decodeArr = decodeArrayOf(file, d);
 	return toColor(cs, unpackSamples(raw, width, height, cs.components, bpc), width * height, bpc, decodeArr);
 }
+function decodeCcittImage(file, stream, filters, width, height) {
+	const parms = decodeParmsOf(file, stream.dict);
+	const columns = (parms ? intOf(file.get(parms, "Columns")) : 0) || 1728;
+	const packed = decodeCcitt(applyChainExceptLast(filters, stream.data), {
+		k: parms ? intOf(file.get(parms, "K")) : 0,
+		columns,
+		rows: height,
+		byteAlign: parms ? boolOf(file.get(parms, "EncodedByteAlign")) : false
+	});
+	if (!packed) return "CCITT fax image not decoded (Group 3 2-D or malformed)";
+	const rowBytes = columns + 7 >> 3;
+	const samples = new Uint8Array(width * height);
+	for (let y = 0; y < height; y++) {
+		const rowOff = y * rowBytes;
+		for (let x = 0; x < width; x++) {
+			const black = x < columns ? packed[rowOff + (x >> 3)] >> 7 - (x & 7) & 1 : 0;
+			samples[y * width + x] = black ? 0 : 255;
+		}
+	}
+	return {
+		color: "gray",
+		samples
+	};
+}
 function resolveColorSpace(file, csVal) {
 	const cs = file.resolve(csVal ?? PDF_NULL);
 	if (cs instanceof PdfName) return namedColorSpace(cs.value);
@@ -296,18 +320,23 @@ function filterNames(file, d) {
 }
 function decodeChain(file, stream, filters) {
 	let data = stream.data;
-	let flate = false;
+	let mayPredict = false;
 	for (const f of filters) if (f === "FlateDecode" || f === "Fl") try {
 		data = unzlibSync(data);
-		flate = true;
+		mayPredict = true;
 	} catch {
 		return;
 	}
-	else if (f === "RunLengthDecode" || f === "RL") data = runLengthDecode(data);
+	else if (f === "LZWDecode" || f === "LZW") {
+		const dec = lzwDecode(data, lzwEarlyChange(file, stream.dict));
+		if (!dec) return void 0;
+		data = dec;
+		mayPredict = true;
+	} else if (f === "RunLengthDecode" || f === "RL") data = runLengthDecode(data);
 	else if (f === "ASCII85Decode" || f === "A85") data = ascii85Decode(data);
 	else if (f === "ASCIIHexDecode" || f === "AHx") data = asciiHexDecode(data);
 	else return;
-	return flate ? applyPredictor(file, stream.dict, data) : data;
+	return mayPredict ? applyPredictor(file, stream.dict, data) : data;
 }
 function applyChainExceptLast(filters, raw) {
 	let data = raw;
@@ -316,6 +345,7 @@ function applyChainExceptLast(filters, raw) {
 		if (f === "FlateDecode" || f === "Fl") try {
 			data = unzlibSync(data);
 		} catch {}
+		else if (f === "LZWDecode" || f === "LZW") data = lzwDecode(data, 1) ?? data;
 		else if (f === "RunLengthDecode" || f === "RL") data = runLengthDecode(data);
 		else if (f === "ASCII85Decode" || f === "A85") data = ascii85Decode(data);
 		else if (f === "ASCIIHexDecode" || f === "AHx") data = asciiHexDecode(data);
@@ -334,6 +364,84 @@ function applyPredictor(file, d, data) {
 		columns: intOf(file.get(parms, "Columns")) || 1
 	});
 }
+var MAX_LZW_OUT = MAX_PIXELS * 4;
+function lzwDecode(data, earlyChange) {
+	let out = new Uint8Array(4096);
+	let outLen = 0;
+	const emit = (e) => {
+		if (outLen + e.length > MAX_LZW_OUT) return false;
+		if (outLen + e.length > out.length) {
+			let cap = out.length * 2;
+			while (cap < outLen + e.length) cap *= 2;
+			const grown = new Uint8Array(cap);
+			grown.set(out.subarray(0, outLen));
+			out = grown;
+		}
+		out.set(e, outLen);
+		outLen += e.length;
+		return true;
+	};
+	let bitBuffer = 0;
+	let bitCount = 0;
+	let pos = 0;
+	let codeLength = 9;
+	const readCode = () => {
+		while (bitCount < codeLength) {
+			if (pos >= data.length) return -1;
+			bitBuffer = (bitBuffer << 8 | data[pos++]) >>> 0;
+			bitCount += 8;
+		}
+		bitCount -= codeLength;
+		return bitBuffer >>> bitCount & (1 << codeLength) - 1;
+	};
+	const dict = new Array(4096);
+	let nextCode = 258;
+	let prev = -1;
+	const reset = () => {
+		for (let i = 0; i < 256; i++) dict[i] = Uint8Array.of(i);
+		nextCode = 258;
+		codeLength = 9;
+		prev = -1;
+	};
+	reset();
+	for (;;) {
+		const code = readCode();
+		if (code < 0 || code === 257) break;
+		if (code === 256) {
+			reset();
+			continue;
+		}
+		if (prev < 0) {
+			const first = dict[code];
+			if (!first || !emit(first)) break;
+			prev = code;
+			continue;
+		}
+		const prevEntry = dict[prev];
+		let entry = code < nextCode ? dict[code] : void 0;
+		if (!entry) {
+			entry = new Uint8Array(prevEntry.length + 1);
+			entry.set(prevEntry);
+			entry[prevEntry.length] = prevEntry[0];
+		}
+		if (!emit(entry)) break;
+		if (nextCode < 4096) {
+			const added = new Uint8Array(prevEntry.length + 1);
+			added.set(prevEntry);
+			added[prevEntry.length] = entry[0];
+			dict[nextCode++] = added;
+			if (nextCode + earlyChange === 512) codeLength = 10;
+			else if (nextCode + earlyChange === 1024) codeLength = 11;
+			else if (nextCode + earlyChange === 2048) codeLength = 12;
+		}
+		prev = code;
+	}
+	return out.subarray(0, outLen);
+}
+function lzwEarlyChange(file, d) {
+	const ec = decodeParmsOf(file, d)?.get("EarlyChange");
+	return ec !== void 0 && file.resolve(ec) === 0 ? 0 : 1;
+}
 function runLengthDecode(data) {
 	const out = [];
 	let i = 0;

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

@@ -6,28 +6,42 @@ import { collectPageVectors } from "./vector.js";
 //#region src/pdf-reader/layout.ts
 function reconstructByLayout(file) {
 	const pages = file.pages();
-	const pageLines = pages.map((page) => groupIntoLines(extractPageText(file, page)).filter((l) => l.text.length > 0));
-	const medianFont = median(pageLines.flat().map((l) => l.fontSize)) || 12;
+	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 = [];
 	pages.forEach((page, i) => {
+		const runs = pageRuns[i];
+		const [px0, , px1] = page.mediaBox;
+		const gutter = detectGutter(runs, Math.abs(px1 - px0));
 		const blocks = [];
-		for (const para of groupIntoParagraphs(pageLines[i])) blocks.push({
-			top: para.top,
-			el: paragraphFromRuns(para.spans, headingLevel(para.fontSize, medianFont))
-		});
+		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) => b.top - a.top);
+		blocks.sort((a, b) => a.col - b.col || b.top - a.top);
 		for (const block of blocks) body.push(block.el);
 	});
 	return {
@@ -35,6 +49,30 @@ function reconstructByLayout(file) {
 		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);
 	const clusters = [];

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,13 +8,13 @@ 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 — a user password is required and was not supplied"
+		detail: "encrypted PDF — the user password was missing or incorrect, or the handler is unsupported"
 	});
 	const tagged = reconstructTaggedPdf(file);
 	const reconstruction = tagged ?? reconstructByLayout(file);
@@ -27,7 +27,7 @@ function readPdf(bytes) {
 	losses.push({
 		severity: "dropped",
 		feature: FEATURES.images,
-		detail: "PDF stroked / shaded vector graphics (lines, gradients, clips) are not reconstructed"
+		detail: "PDF clipping paths and bare-shading (sh) vector regions are not reconstructed"
 	});
 	return {
 		doc: reconstruction.doc,
@@ -44,7 +44,7 @@ var pdfReader = {
 		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/text.js

@@ -1,19 +1,11 @@
-import { PdfName } from "../pdf/objects.js";
-import { interpretContent } from "./content.js";
+import { PDF_NULL, PdfName, PdfStream } from "../pdf/objects.js";
+import { IDENTITY, interpretContent, multiply } from "./content.js";
 import { buildContentFont } from "./font.js";
 //#region src/pdf-reader/text.ts
+var MAX_FORM_DEPTH = 8;
 function extractPageText(file, page) {
-	const fonts = /* @__PURE__ */ new Map();
-	if (page.resources) {
-		const fontContainer = file.get(page.resources, "Font");
-		if (fontContainer instanceof Map) for (const [fontName, fontRef] of fontContainer) {
-			const fontDict = file.resolve(fontRef);
-			if (fontDict instanceof Map) try {
-				fonts.set(fontName, buildContentFont(file, fontDict));
-			} catch {}
-		}
-	}
-	const runs = interpretContent(file.pageContent(page), fonts).texts;
+	const runs = [];
+	collectRuns(file, page.resources, file.pageContent(page), IDENTITY, 0, /* @__PURE__ */ new Set(), runs);
 	const links = collectLinks(file, page);
 	if (links.length === 0) return runs;
 	return runs.map((run) => {
@@ -24,6 +16,48 @@ function extractPageText(file, page) {
 		} : run;
 	});
 }
+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;
+	const xobjects = file.get(resources, "XObject");
+	if (!(xobjects instanceof Map)) return;
+	for (const placement of result.images) {
+		const stream = file.resolve(xobjects.get(placement.name) ?? PDF_NULL);
+		if (!(stream instanceof PdfStream) || visiting.has(stream)) continue;
+		const sub = file.get(stream.dict, "Subtype");
+		if (!(sub instanceof PdfName) || sub.value !== "Form") continue;
+		visiting.add(stream);
+		const formRes = file.get(stream.dict, "Resources");
+		collectRuns(file, formRes instanceof Map ? formRes : resources, file.streamData(stream), multiply(matrixOf(file, stream.dict), placement.ctm), depth + 1, visiting, out);
+		visiting.delete(stream);
+	}
+}
+function buildFonts(file, resources) {
+	const fonts = /* @__PURE__ */ new Map();
+	if (!resources) return fonts;
+	const fontContainer = file.get(resources, "Font");
+	if (!(fontContainer instanceof Map)) return fonts;
+	for (const [fontName, fontRef] of fontContainer) {
+		const fontDict = file.resolve(fontRef);
+		if (fontDict instanceof Map) try {
+			fonts.set(fontName, buildContentFont(file, fontDict));
+		} catch {}
+	}
+	return fonts;
+}
+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 IDENTITY;
+}
 function collectLinks(file, page) {
 	const annots = file.get(page.dict, "Annots");
 	if (!Array.isArray(annots)) return [];

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

@@ -1,8 +1,12 @@
 import { PathSeg } from './content.js';
+import { ShapeGradient } from '../core/vector.js';
 import { PdfFile, PdfPage } from './document.js';
 export interface PdfVector {
     readonly segs: ReadonlyArray<PathSeg>;
-    readonly fillHex: string;
+    readonly fillHex?: string;
+    readonly gradient?: ShapeGradient;
+    readonly strokeHex?: string;
+    readonly lineWidth?: number;
     readonly minX: number;
     readonly minY: number;
     readonly maxX: number;

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

@@ -1,25 +1,34 @@
-import { interpretContent } from "./content.js";
+import { IDENTITY, interpretContent } from "./content.js";
+import { buildShadingMap } from "./shading.js";
 //#region src/pdf-reader/vector.ts
 var NO_FONTS = /* @__PURE__ */ new Map();
 var MIN_SIDE = 2;
 var MIN_AREA = 16;
+var MIN_STROKE_LEN = 6;
 var MAX_VECTORS = 2e3;
 function collectPageVectors(file, page) {
 	const [px0, py0, px1, py1] = page.mediaBox;
 	const pageArea = Math.max(1, Math.abs((px1 - px0) * (py1 - py0)));
+	const shadings = buildShadingMap(file, page);
 	const out = [];
-	for (const v of interpretContent(file.pageContent(page), NO_FONTS).vectors) {
+	for (const v of interpretContent(file.pageContent(page), NO_FONTS, IDENTITY, shadings).vectors) {
 		if (out.length >= MAX_VECTORS) break;
-		if (v.fillHex === "FFFFFF") continue;
 		const b = bbox(v.segs);
 		if (!b) continue;
 		const w = b.maxX - b.minX;
 		const h = b.maxY - b.minY;
-		if (w < MIN_SIDE || h < MIN_SIDE || w * h < MIN_AREA) continue;
-		if (w * h > .85 * pageArea) continue;
+		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;
+		if (!filled && !stroked) continue;
 		out.push({
 			segs: v.segs,
-			fillHex: v.fillHex,
+			...filled ? v.gradient ? { gradient: v.gradient } : v.fillHex !== void 0 ? { fillHex: v.fillHex } : {} : {},
+			...stroked ? {
+				strokeHex: v.strokeHex,
+				...v.lineWidth !== void 0 ? { lineWidth: v.lineWidth } : {}
+			} : {},
 			...b,
 			...v.mcid !== void 0 ? { mcid: v.mcid } : {}
 		});

package/dist/esm/svg/svg-writer.js

@@ -1,5 +1,6 @@
 import { FEATURES } from "../core/ir/features.js";
 import { svgPathData } from "../core/vector.js";
+import { gradientSvgDef } from "../core/drawingml/shape-render.js";
 import { paintPlan } from "../layout/page-doc.js";
 import { toBase64 } from "../core/bytes.js";
 //#region src/svg/svg-writer.ts
@@ -12,10 +13,11 @@ function writeSvg(laid, opts = {}) {
 	const parts = [];
 	parts.push(`<svg xmlns="http://www.w3.org/2000/svg" width="${fmt(width)}" height="${fmt(height)}" viewBox="0 0 ${fmt(width)} ${fmt(height)}">`);
 	let yOffset = 0;
+	const idc = { n: 0 };
 	laid.pages.forEach((page, i) => {
 		parts.push(`<g transform="translate(0 ${fmt(yOffset)})" data-page="${i + 1}">`);
 		parts.push(`<rect x="0" y="0" width="${fmt(page.width)}" height="${fmt(page.height)}" fill="#ffffff" stroke="#cccccc"/>`);
-		emitPage(parts, page, laid, losses);
+		emitPage(parts, page, laid, losses, idc);
 		parts.push("</g>");
 		yOffset += page.height + gap;
 	});
@@ -36,7 +38,7 @@ var svgWriter = {
 	]),
 	write: (doc, opts) => writeSvg(doc, opts ?? {})
 };
-function emitPage(out, page, laid, losses) {
+function emitPage(out, page, laid, losses, idc) {
 	const plan = paintPlan(page.commands);
 	for (const f of plan.fills) out.push(`<rect x="${fmt(f.x)}" y="${fmt(f.y)}" width="${fmt(f.width)}" height="${fmt(f.height)}" fill="#${f.fillColorHex}"/>`);
 	for (const img of plan.images) {
@@ -71,7 +73,7 @@ function emitPage(out, page, laid, losses) {
 		];
 		out.push(`<line x1="${fmt(ax)}" y1="${fmt(ay)}" x2="${fmt(bx)}" y2="${fmt(by)}" stroke="#${b.borderColorHex}" stroke-width="${fmt(b.borderSizePt)}"/>`);
 	}
-	for (const sh of plan.shapes) emitShape(out, sh.shape);
+	for (const sh of plan.shapes) emitShape(out, sh.shape, idc);
 	for (const t of plan.lines) emitTextLine(out, t, losses);
 }
 function emitTextLine(out, item, losses) {
@@ -95,10 +97,15 @@ function emitTextLine(out, item, losses) {
 		x += tok.widthPt;
 	}
 }
-function emitShape(out, shape) {
+function emitShape(out, shape, idc) {
 	const [a, b, c, d, e, f] = shape.transform;
 	const transform = `matrix(${fmt(a)} ${fmt(b)} ${fmt(c)} ${fmt(d)} ${fmt(e)} ${fmt(f)})`;
-	const fill = shape.fillColorHex ? `#${shape.fillColorHex}` : "none";
+	let fill;
+	if (shape.fillGradient) {
+		const id = `grad${idc.n++}`;
+		out.push(gradientSvgDef(id, shape.fillGradient));
+		fill = `url(#${id})`;
+	} else fill = shape.fillColorHex ? `#${shape.fillColorHex}` : "none";
 	const stroke = shape.stroke ? ` stroke="#${shape.stroke.colorHex}" stroke-width="${fmt(shape.stroke.widthPt)}"` : "";
 	for (const path of shape.paths) {
 		const d2 = pathData(path.segments);

package/dist/esm/word/docx-writer.js

@@ -359,7 +359,14 @@ function geomXml(g) {
 	return `<a:prstGeom prst="${escapeAttr(g.preset ?? "rect")}"><a:avLst>${gds}</a:avLst></a:prstGeom>`;
 }
 function fillXml(f) {
-	return f.kind === "solid" && f.colorHex ? `<a:solidFill><a:srgbClr val="${f.colorHex}"/></a:solidFill>` : "<a:noFill/>";
+	if (f.kind === "solid" && f.colorHex) return `<a:solidFill><a:srgbClr val="${f.colorHex}"/></a:solidFill>`;
+	if (f.kind === "gradient" && f.gradient) return gradFillXml(f.gradient);
+	return "<a:noFill/>";
+}
+function gradFillXml(g) {
+	return `<a:gradFill><a:gsLst>${g.stops.map((s) => {
+		return `<a:gs pos="${Math.round(Math.max(0, Math.min(1, s.offset)) * 1e5)}"><a:srgbClr val="${s.colorHex}"/></a:gs>`;
+	}).join("")}</a:gsLst>${g.kind === "radial" ? "<a:path path=\"circle\"/>" : `<a:lin ang="${Math.round(((g.angle ?? 0) % 360 + 360) % 360 * 6e4)}" scaled="1"/>`}</a:gradFill>`;
 }
 function lineXml(l) {
 	const w = l.width !== void 0 ? ` w="${Math.round(l.width * EMU_PER_PT)}"` : "";