reamkit 1.6.0 → 1.9.0

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

@@ -1,5 +1,7 @@
 import { pt } from "../core/ir/units.js";
-import { buildFlowDoc, paragraphBlock } from "./flow-build.js";
+import { ResourceStore } from "../core/ir/resources.js";
+import { buildFlowDoc, dedupeLosses, imageBlock, paragraphBlock, paragraphFromRuns } from "./flow-build.js";
+import { collectPageImages } from "./images.js";
 import { extractPageText } from "./text.js";
 import { readStructTree } from "./struct-tree.js";
 //#region src/pdf-reader/tagged.ts
@@ -7,12 +9,45 @@ var ASSUMED_CONTENT_WIDTH_PT = 468;
 function reconstructTaggedPdf(file) {
 	const root = readStructTree(file);
 	if (!root) return void 0;
-	const pageText = file.pages().map((page) => {
+	const pages = file.pages();
+	const pageRuns = pages.map((page) => {
 		const byMcid = /* @__PURE__ */ new Map();
-		for (const run of extractPageText(file, page)) if (run.mcid !== void 0) byMcid.set(run.mcid, (byMcid.get(run.mcid) ?? "") + run.text);
+		for (const run of extractPageText(file, page)) {
+			if (run.mcid === void 0) continue;
+			const list = byMcid.get(run.mcid);
+			if (list) list.push(run);
+			else byMcid.set(run.mcid, [run]);
+		}
+		return byMcid;
+	});
+	const runsOfMcid = (page, mcid) => pageRuns[page]?.get(mcid) ?? [];
+	const resources = new ResourceStore();
+	const pageImages = pages.map((page) => collectPageImages(file, page));
+	const imageLosses = dedupeLosses(pageImages.flatMap((p) => p.losses));
+	const imagesByMcid = pageImages.map((p) => {
+		const byMcid = /* @__PURE__ */ new Map();
+		for (const img of p.images) {
+			if (img.mcid === void 0) continue;
+			const list = byMcid.get(img.mcid);
+			if (list) list.push(img);
+			else byMcid.set(img.mcid, [img]);
+		}
 		return byMcid;
 	});
-	const textOf = (node) => squash(node.mcids.map(({ page, mcid }) => pageText[page]?.get(mcid) ?? "").join(" "));
+	const emitted = /* @__PURE__ */ new Set();
+	const imagesForNode = (node) => node.mcids.flatMap(({ page, mcid }) => imagesByMcid[page]?.get(mcid) ?? []);
+	const textOf = (node) => squash(node.mcids.map(({ page, mcid }) => runsOfMcid(page, mcid).map((r) => r.text).join("")).join(" "));
+	const spansOf = (node) => {
+		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 ? {
+				text: run.text,
+				href: run.href
+			} : { text: run.text });
+		});
+		return spans;
+	};
 	const collectText = (node) => squash([textOf(node), ...node.children.map(collectText)].join(" "));
 	function emit(node, out) {
 		if (node.type === "Table") {
@@ -20,14 +55,20 @@ function reconstructTaggedPdf(file) {
 			if (table) out.push(table);
 			return;
 		}
+		if (node.type === "Figure") {
+			for (const img of imagesForNode(node)) {
+				emitted.add(img);
+				out.push(imageBlock(img, resources, node.alt));
+			}
+			return;
+		}
 		if (node.type === "LI") {
 			const text = collectText(node);
 			if (text.length > 0) out.push(paragraphBlock(text, void 0));
 			return;
 		}
 		if (node.children.length === 0) {
-			const text = textOf(node);
-			if (text.length > 0) out.push(paragraphBlock(text, headingLevel(node.type)));
+			if (textOf(node).length > 0) out.push(paragraphFromRuns(spansOf(node), headingLevel(node.type)));
 			return;
 		}
 		for (const child of node.children) emit(child, out);
@@ -74,8 +115,20 @@ function reconstructTaggedPdf(file) {
 	}
 	const body = [];
 	emit(root, body);
+	const orphans = [];
+	pageImages.forEach((p, page) => {
+		for (const img of p.images) if (!emitted.has(img)) orphans.push({
+			page,
+			img
+		});
+	});
+	orphans.sort((a, b) => a.page - b.page || b.img.y - a.img.y);
+	for (const { img } of orphans) body.push(imageBlock(img, resources));
 	if (body.length === 0) return void 0;
-	return buildFlowDoc(body);
+	return {
+		doc: buildFlowDoc(body, resources),
+		losses: imageLosses
+	};
 }
 function squash(text) {
 	return text.replace(/\s+/g, " ").trim();

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

@@ -1,18 +1,99 @@
-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 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) => {
+		const link = links.find((l) => inRect(run.x, run.y, l.rect));
+		return link ? {
+			...run,
+			href: link.href
+		} : 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 (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 {}
-		}
+	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 [];
+	const out = [];
+	for (const a of annots) {
+		const annot = file.resolve(a);
+		if (!(annot instanceof Map)) continue;
+		const sub = file.get(annot, "Subtype");
+		if (!(sub instanceof PdfName) || sub.value !== "Link") continue;
+		const rect = normRect(file.get(annot, "Rect"));
+		if (!rect) continue;
+		const action = file.get(annot, "A");
+		if (!(action instanceof Map)) continue;
+		const s = file.get(action, "S");
+		if (!(s instanceof PdfName) || s.value !== "URI") continue;
+		const uri = file.get(action, "URI");
+		if (typeof uri === "string" && uri.length > 0) out.push({
+			rect,
+			href: uri
+		});
 	}
-	return interpretContent(file.pageContent(page), fonts);
+	return out;
+}
+function normRect(v) {
+	if (!Array.isArray(v) || v.length < 4) return void 0;
+	const n = v.slice(0, 4).map((x) => typeof x === "number" ? x : NaN);
+	if (n.some((x) => !Number.isFinite(x))) return void 0;
+	return [
+		Math.min(n[0], n[2]),
+		Math.min(n[1], n[3]),
+		Math.max(n[0], n[2]),
+		Math.max(n[1], n[3])
+	];
+}
+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 };

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

@@ -0,0 +1,16 @@
+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 gradient?: ShapeGradient;
+    readonly strokeHex?: string;
+    readonly lineWidth?: number;
+    readonly minX: number;
+    readonly minY: number;
+    readonly maxX: number;
+    readonly maxY: number;
+    readonly mcid?: number;
+}
+export declare function collectPageVectors(file: PdfFile, page: PdfPage): Array<PdfVector>;

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

@@ -0,0 +1,63 @@
+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, IDENTITY, shadings).vectors) {
+		if (out.length >= MAX_VECTORS) break;
+		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;
+		if (!filled && !stroked) continue;
+		out.push({
+			segs: v.segs,
+			...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 } : {}
+		});
+	}
+	return out;
+}
+function bbox(segs) {
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX = -Infinity;
+	let maxY = -Infinity;
+	const add = (x, y) => {
+		minX = Math.min(minX, x);
+		minY = Math.min(minY, y);
+		maxX = Math.max(maxX, x);
+		maxY = Math.max(maxY, y);
+	};
+	for (const s of segs) if (s.op === "move" || s.op === "line") add(s.x, s.y);
+	else if (s.op === "cubic") {
+		add(s.x1, s.y1);
+		add(s.x2, s.y2);
+		add(s.x, s.y);
+	}
+	return Number.isFinite(minX) ? {
+		minX,
+		minY,
+		maxX,
+		maxY
+	} : void 0;
+}
+//#endregion
+export { collectPageVectors };

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

@@ -4,6 +4,8 @@ import { EMPTY_STYLE_SHEET, resolveParagraphProperties, resolveRunProperties } f
 import "../core/style-cascade/index.js";
 import { buildOpcPackage } from "../core/opc/opc-writer.js";
 import "../core/opc/index.js";
+import { omathXml } from "./omml-serializer.js";
+import { chartSpaceXml } from "../core/drawingml/chart-serializer.js";
 //#region src/word/docx-writer.ts
 var encoder = new TextEncoder();
 var DEFAULT_RUN = resolveRunProperties({}, {}, EMPTY_STYLE_SHEET);
@@ -15,6 +17,14 @@ var REL_NUMBERING = "http://schemas.openxmlformats.org/officeDocument/2006/relat
 var REL_HYPERLINK = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink";
 var REL_IMAGE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image";
 var NUMBERING_PART = "word/numbering.xml";
+var REL_FOOTNOTES = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footnotes";
+var REL_ENDNOTES = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/endnotes";
+var FOOTNOTES_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml";
+var ENDNOTES_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml";
+var FOOTNOTES_PART = "word/footnotes.xml";
+var ENDNOTES_PART = "word/endnotes.xml";
+var REL_CHART = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart";
+var CHART_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.drawingml.chart+xml";
 var EMU_PER_PT = 12700;
 var RASTER_MEDIA = {
 	png: {
@@ -78,7 +88,10 @@ function writeDocx(flow) {
 		mediaParts: [],
 		mediaFileByResource: /* @__PURE__ */ new Map(),
 		bookmarkSeq: 0,
-		drawingSeq: 0
+		drawingSeq: 0,
+		chartParts: [],
+		chartSeq: 0,
+		...flow.charts ? { charts: flow.charts } : {}
 	};
 	const docScope = newScope();
 	const extraParts = [];
@@ -112,6 +125,24 @@ function writeDocx(flow) {
 		target: "numbering.xml",
 		targetMode: "Internal"
 	});
+	emitNotes(flow.footnotes, {
+		noteKind: "footnote",
+		partPath: FOOTNOTES_PART,
+		rootTag: "w:footnotes",
+		noteTag: "w:footnote",
+		contentType: FOOTNOTES_CONTENT_TYPE,
+		relType: REL_FOOTNOTES,
+		target: "footnotes.xml"
+	}, state, losses, docScope, extraParts, extraPartRels);
+	emitNotes(flow.endnotes, {
+		noteKind: "endnote",
+		partPath: ENDNOTES_PART,
+		rootTag: "w:endnotes",
+		noteTag: "w:endnote",
+		contentType: ENDNOTES_CONTENT_TYPE,
+		relType: REL_ENDNOTES,
+		target: "endnotes.xml"
+	}, state, losses, docScope, extraParts, extraPartRels);
 	const partRelationships = [...docScope.rels.length > 0 ? [{
 		sourcePart: "word/document.xml",
 		relationships: docScope.rels
@@ -126,6 +157,7 @@ function writeDocx(flow) {
 				},
 				...numberingPart ? [numberingPart] : [],
 				...extraParts,
+				...state.chartParts,
 				...state.mediaParts
 			],
 			rootRelationships: [{
@@ -139,6 +171,34 @@ function writeDocx(flow) {
 		losses
 	};
 }
+function emitNotes(notes, cfg, state, losses, docScope, extraParts, extraPartRels) {
+	if (!notes || notes.size === 0) return;
+	const scope = newScope();
+	scope.noteKind = cfg.noteKind;
+	const stub = (type, id, mark) => `<${cfg.noteTag} w:type="${type}" w:id="${id}"><w:p><w:r>${mark}</w:r></w:p></${cfg.noteTag}>`;
+	const noteXmls = [];
+	for (const [id, content] of notes) {
+		const inner = [];
+		for (const el of content) emitBlock(inner, el, losses, state, scope);
+		noteXmls.push(`<${cfg.noteTag} w:id="${escapeAttr(id)}">${inner.join("") || "<w:p/>"}</${cfg.noteTag}>`);
+	}
+	const xml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><${cfg.rootTag} xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">` + stub("separator", -1, "<w:separator/>") + stub("continuationSeparator", 0, "<w:continuationSeparator/>") + noteXmls.join("") + `</${cfg.rootTag}>`;
+	extraParts.push({
+		path: cfg.partPath,
+		data: encoder.encode(xml),
+		contentType: cfg.contentType
+	});
+	if (scope.rels.length > 0) extraPartRels.push({
+		sourcePart: cfg.partPath,
+		relationships: scope.rels
+	});
+	docScope.rels.push({
+		id: `rId${++docScope.relSeq}`,
+		type: cfg.relType,
+		target: cfg.target,
+		targetMode: "Internal"
+	});
+}
 function emitHeadersFooters(flow, section, state, docScope, extraParts, extraPartRels, hfCache, losses) {
 	const refs = {
 		headers: [],
@@ -226,12 +286,37 @@ function emitBlock(out, el, losses, state, scope, closingSectPr) {
 		out.push(`<w:p>${pPrWithSect(el.shape.paragraphProperties, closingSectPr)}<w:r>${drawing}</w:r></w:p>`);
 		return;
 	}
-	if (closingSectPr) out.push(`<w:p><w:pPr>${closingSectPr}</w:pPr></w:p>`);
-	losses.push({
-		severity: "dropped",
-		feature: FEATURES.charts,
-		detail: `${el.kind} not written by the docx writer (v0)`
+	const chartDrawing = chartBlockXml(el.chart, state, scope, losses);
+	if (chartDrawing) out.push(`<w:p>${pPrWithSect(el.chart.paragraphProperties, closingSectPr)}<w:r>${chartDrawing}</w:r></w:p>`);
+	else if (closingSectPr) out.push(`<w:p><w:pPr>${closingSectPr}</w:pPr></w:p>`);
+}
+function chartBlockXml(chart, state, scope, losses) {
+	const data = state.charts?.get(chart.chartRelId);
+	if (!data) {
+		losses.push({
+			severity: "dropped",
+			feature: FEATURES.charts,
+			detail: "chart data missing"
+		});
+		return "";
+	}
+	const cid = ++state.chartSeq;
+	state.chartParts.push({
+		path: `word/charts/chart${cid}.xml`,
+		data: encoder.encode(chartSpaceXml(data)),
+		contentType: CHART_CONTENT_TYPE
 	});
+	const relId = `rId${++scope.relSeq}`;
+	scope.rels.push({
+		id: relId,
+		type: REL_CHART,
+		target: `charts/chart${cid}.xml`,
+		targetMode: "Internal"
+	});
+	const cx = Math.round(chart.width * EMU_PER_PT);
+	const cy = Math.round(chart.height * EMU_PER_PT);
+	const id = ++state.drawingSeq;
+	return `<w:drawing><wp:inline xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing"><wp:extent cx="${cx}" cy="${cy}"/><wp:docPr id="${id}" name="Chart ${id}"${chart.altText ? ` descr="${escapeAttr(chart.altText)}"` : ""}/><a:graphic xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"><a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/chart"><c:chart xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" r:id="${relId}"/></a:graphicData></a:graphic></wp:inline></w:drawing>`;
 }
 function drawingXml(resource, widthPt, heightPt, altText, state, scope) {
 	if (resource === void 0) return "";
@@ -274,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)}"` : "";
@@ -402,7 +494,7 @@ function cellMarginsXml(tag, margins) {
 	return inner ? `<${tag}>${inner}</${tag}>` : "";
 }
 function paragraphXml(p, state, scope, closingSectPr) {
-	const visible = p.runs.filter((run) => !run.listMarker && run.math === void 0 && (run.text !== "" || run.inlineImage !== void 0 || run.pageBreak || run.href !== void 0 || run.anchor !== void 0));
+	const visible = p.runs.filter((run) => !run.listMarker && (run.math !== void 0 || run.text !== "" || run.inlineImage !== void 0 || run.pageBreak || run.footnoteRef !== void 0 || run.endnoteRef !== void 0 || run.noteNumber === true || run.href !== void 0 || run.anchor !== void 0));
 	const inner = [];
 	let i = 0;
 	while (i < visible.length) {
@@ -440,6 +532,7 @@ function hyperlinkXml(run, inner, _state, scope) {
 	return `<w:hyperlink w:anchor="${escapeAttr(run.anchor)}">${inner}</w:hyperlink>`;
 }
 function runXml(run, state, scope) {
+	if (run.math !== void 0) return `<m:oMath xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math">${omathXml(run.math)}</m:oMath>`;
 	const rPr = rPrXml(run.properties);
 	if (run.inlineImage !== void 0) {
 		const img = run.inlineImage;
@@ -447,6 +540,9 @@ function runXml(run, state, scope) {
 		if (drawing) return `<w:r>${rPr}${drawing}</w:r>`;
 		if (run.text === "" && !run.pageBreak) return "";
 	}
+	if (run.footnoteRef !== void 0) return `<w:r>${rPr}<w:footnoteReference w:id="${escapeAttr(run.footnoteRef)}"/></w:r>`;
+	if (run.endnoteRef !== void 0) return `<w:r>${rPr}<w:endnoteReference w:id="${escapeAttr(run.endnoteRef)}"/></w:r>`;
+	if (run.noteNumber) return `<w:r>${rPr}<${scope.noteKind === "endnote" ? "w:endnoteRef" : "w:footnoteRef"}/></w:r>`;
 	const brk = run.pageBreak ? "<w:br w:type=\"page\"/>" : "";
 	if (run.text === "") return brk ? `<w:r>${rPr}${brk}</w:r>` : "";
 	return `<w:r>${rPr}<w:t xml:space="preserve">${escapeXml(run.text)}</w:t>${brk}</w:r>`;

package/dist/esm/word/drawing-parser.js

@@ -353,10 +353,10 @@ function parseFill(spPr, resolveColor) {
 			} : { kind: "none" };
 		}
 		if (poIs(child, "a:gradFill")) {
-			const hex = colorFromGradient(child, resolveColor);
-			return hex ? {
-				kind: "solid",
-				colorHex: hex
+			const gradient = parseGradient(child, resolveColor);
+			return gradient ? {
+				kind: "gradient",
+				gradient
 			} : { kind: "none" };
 		}
 	}
@@ -404,13 +404,10 @@ function colorFromContainer(parent, resolveColor) {
 		if (hex) return hex;
 	}
 }
-function colorFromGradient(grad, resolveColor) {
+function parseGradient(grad, resolveColor) {
 	const gsLst = poChildren(grad).find((c) => poIs(c, "a:gsLst"));
 	if (!gsLst) return void 0;
-	let r = 0;
-	let g = 0;
-	let b = 0;
-	let n = 0;
+	const stops = [];
 	for (const gs of poChildren(gsLst)) {
 		if (!poIs(gs, "a:gs")) continue;
 		let hex;
@@ -419,15 +416,29 @@ function colorFromGradient(grad, resolveColor) {
 			if (hex) break;
 		}
 		if (!hex) continue;
-		const num = parseInt(hex, 16);
-		r += num >> 16 & 255;
-		g += num >> 8 & 255;
-		b += num & 255;
-		n++;
+		const pos = poIntAttr(gs, "pos");
+		const offset = pos !== void 0 ? clampUnit(pos / 1e5) : stops.length === 0 ? 0 : 1;
+		stops.push({
+			offset,
+			colorHex: hex
+		});
 	}
-	if (n === 0) return void 0;
-	const toHex = (x) => Math.round(x / n).toString(16).padStart(2, "0");
-	return (toHex(r) + toHex(g) + toHex(b)).toUpperCase();
+	if (stops.length === 0) return void 0;
+	stops.sort((a, b) => a.offset - b.offset);
+	if (poChildren(grad).some((c) => poIs(c, "a:path"))) return {
+		kind: "radial",
+		stops
+	};
+	const lin = poChildren(grad).find((c) => poIs(c, "a:lin"));
+	const ang = lin ? poIntAttr(lin, "ang") : void 0;
+	return {
+		kind: "linear",
+		angle: ang !== void 0 ? ang / 6e4 % 360 : 0,
+		stops
+	};
+}
+function clampUnit(x) {
+	return x < 0 ? 0 : x > 1 ? 1 : x;
 }
 //#endregion
 export { expandMcChildren, parseDrawing, parseVmlPicture };

package/dist/esm/word/omml-serializer.d.ts

@@ -0,0 +1,2 @@
+import { MathNode } from '../core/document-model/index.js';
+export declare function omathXml(node: MathNode): string;

package/dist/esm/word/omml-serializer.js

@@ -0,0 +1,48 @@
+//#region src/word/omml-serializer.ts
+function omathXml(node) {
+	return ser(node);
+}
+function ser(node) {
+	switch (node.type) {
+		case "row": return node.children.map(ser).join("");
+		case "run": return `<m:r>${runPr(node)}<m:t xml:space="preserve">${esc(node.text)}</m:t></m:r>`;
+		case "fraction": return "<m:f>" + (node.barless ? "<m:fPr><m:type m:val=\"noBar\"/></m:fPr>" : "") + `<m:num>${ser(node.num)}</m:num><m:den>${ser(node.den)}</m:den></m:f>`;
+		case "script": return scriptXml(node);
+		case "radical": return "<m:rad>" + (node.degree ? "" : "<m:radPr><m:degHide m:val=\"1\"/></m:radPr>") + (node.degree ? `<m:deg>${ser(node.degree)}</m:deg>` : "<m:deg/>") + `<m:e>${ser(node.radicand)}</m:e></m:rad>`;
+		case "nary": return `<m:nary><m:naryPr><m:chr m:val="${attr(node.op)}"/>` + (node.limLoc ? `<m:limLoc m:val="${node.limLoc}"/>` : "") + (node.sub ? "" : "<m:subHide m:val=\"1\"/>") + (node.sup ? "" : "<m:supHide m:val=\"1\"/>") + `</m:naryPr><m:sub>${node.sub ? ser(node.sub) : ""}</m:sub><m:sup>${node.sup ? ser(node.sup) : ""}</m:sup><m:e>${ser(node.body)}</m:e></m:nary>`;
+		case "func": return `<m:func><m:fName>${ser(node.name)}</m:fName><m:e>${ser(node.body)}</m:e></m:func>`;
+		case "limit": return `<m:lim${node.pos === "upp" ? "Upp" : "Low"}><m:e>${ser(node.base)}</m:e><m:lim>${ser(node.lim)}</m:lim></m:lim${node.pos === "upp" ? "Upp" : "Low"}>`;
+		case "delimiter": return `<m:d><m:dPr><m:begChr m:val="${attr(node.begChr)}"/>` + (node.sepChr !== void 0 ? `<m:sepChr m:val="${attr(node.sepChr)}"/>` : "") + `<m:endChr m:val="${attr(node.endChr)}"/></m:dPr>` + node.children.map((c) => `<m:e>${ser(c)}</m:e>`).join("") + "</m:d>";
+		case "matrix": return "<m:m>" + node.rows.map((row) => `<m:mr>${row.map((c) => `<m:e>${ser(c)}</m:e>`).join("")}</m:mr>`).join("") + "</m:m>";
+		case "accent": return `<m:acc><m:accPr><m:chr m:val="${attr(node.char)}"/></m:accPr><m:e>${ser(node.base)}</m:e></m:acc>`;
+		case "bar": return `<m:bar><m:barPr><m:pos m:val="${node.pos}"/></m:barPr><m:e>${ser(node.base)}</m:e></m:bar>`;
+		case "groupChr": return `<m:groupChr><m:groupChrPr><m:chr m:val="${attr(node.char)}"/><m:pos m:val="${node.pos}"/></m:groupChrPr><m:e>${ser(node.base)}</m:e></m:groupChr>`;
+		case "eqArr": return `<m:eqArr>${node.rows.map((r) => `<m:e>${ser(r)}</m:e>`).join("")}</m:eqArr>`;
+	}
+}
+function scriptXml(node) {
+	const base = `<m:e>${ser(node.base)}</m:e>`;
+	const sub = `<m:sub>${node.sub ? ser(node.sub) : ""}</m:sub>`;
+	const sup = `<m:sup>${node.sup ? ser(node.sup) : ""}</m:sup>`;
+	if (node.pre) return `<m:sPre>${base}${sub}${sup}</m:sPre>`;
+	if (node.sub && node.sup) return `<m:sSubSup>${base}${sub}${sup}</m:sSubSup>`;
+	if (node.sub) return `<m:sSub>${base}${sub}</m:sSub>`;
+	if (node.sup) return `<m:sSup>${base}${sup}</m:sSup>`;
+	return ser(node.base);
+}
+function runPr(run) {
+	let sty;
+	if (run.bold && run.italic) sty = "bi";
+	else if (run.bold) sty = "b";
+	else if (run.italic) sty = "i";
+	else if (run.nor) sty = "p";
+	return sty ? `<m:rPr><m:sty m:val="${sty}"/></m:rPr>` : "";
+}
+function esc(s) {
+	return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function attr(s) {
+	return esc(s).replace(/"/g, "&quot;");
+}
+//#endregion
+export { omathXml };