reamkit 1.6.0 → 1.7.0

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.js

@@ -11,20 +11,26 @@ function sniffPdf(bytes) {
 function readPdf(bytes) {
 	const file = PdfFile.parse(bytes);
 	const losses = [];
+	if (file.encryptionUnsupported) losses.push({
+		severity: "dropped",
+		feature: FEATURES.text,
+		detail: "encrypted PDF — a user password is required and was not supplied"
+	});
 	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 stroked / shaded vector graphics (lines, gradients, clips) are not reconstructed"
 	});
 	return {
-		doc,
+		doc: reconstruction.doc,
 		losses
 	};
 }
@@ -34,7 +40,8 @@ var pdfReader = {
 	supports: new Set([
 		FEATURES.text,
 		FEATURES.tables,
-		FEATURES.lists
+		FEATURES.lists,
+		FEATURES.images
 	]),
 	sniff: sniffPdf,
 	read: (bytes) => readPdf(bytes)

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;

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,3 +1,4 @@
+import { PdfName } from "../pdf/objects.js";
 import { interpretContent } from "./content.js";
 import { buildContentFont } from "./font.js";
 //#region src/pdf-reader/text.ts
@@ -12,7 +13,53 @@ function extractPageText(file, page) {
 			} catch {}
 		}
 	}
-	return interpretContent(file.pageContent(page), fonts);
+	const runs = interpretContent(file.pageContent(page), fonts).texts;
+	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 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 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,12 @@
+import { PathSeg } from './content.js';
+import { PdfFile, PdfPage } from './document.js';
+export interface PdfVector {
+    readonly segs: ReadonlyArray<PathSeg>;
+    readonly fillHex: string;
+    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,54 @@
+import { interpretContent } from "./content.js";
+//#region src/pdf-reader/vector.ts
+var NO_FONTS = /* @__PURE__ */ new Map();
+var MIN_SIDE = 2;
+var MIN_AREA = 16;
+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 out = [];
+	for (const v of interpretContent(file.pageContent(page), NO_FONTS).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;
+		out.push({
+			segs: v.segs,
+			fillHex: v.fillHex,
+			...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/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 "";
@@ -402,7 +487,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 +525,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 +533,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/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 };