reamkit 1.5.0 → 1.7.0

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

@@ -0,0 +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 const pdfReader: DocumentReader<FlowDoc>;

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

@@ -0,0 +1,50 @@
+import { FEATURES } from "../core/ir/features.js";
+import { PdfFile } from "./document.js";
+import { reconstructByLayout } from "./layout.js";
+import { reconstructTaggedPdf } from "./tagged.js";
+//#region src/pdf-reader/reader.ts
+function sniffPdf(bytes) {
+	const limit = Math.min(bytes.length - 5, 1024);
+	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);
+	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 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 stroked / shaded vector graphics (lines, gradients, clips) are not reconstructed"
+	});
+	return {
+		doc: reconstruction.doc,
+		losses
+	};
+}
+var pdfReader = {
+	id: "pdf",
+	produces: "flow",
+	supports: new Set([
+		FEATURES.text,
+		FEATURES.tables,
+		FEATURES.lists,
+		FEATURES.images
+	]),
+	sniff: sniffPdf,
+	read: (bytes) => readPdf(bytes)
+};
+//#endregion
+export { pdfReader };

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

@@ -0,0 +1,14 @@
+import { PdfFile } from './document.js';
+export interface StructMcid {
+    readonly page: number;
+    readonly mcid: number;
+}
+export interface StructNode {
+    readonly type: string;
+    readonly mcids: ReadonlyArray<StructMcid>;
+    readonly children: ReadonlyArray<StructNode>;
+    readonly alt?: string;
+    readonly colSpan?: number;
+    readonly rowSpan?: number;
+}
+export declare function readStructTree(file: PdfFile): StructNode | undefined;

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

@@ -0,0 +1,92 @@
+import { PDF_NULL, PdfName } from "../pdf/objects.js";
+//#region src/pdf-reader/struct-tree.ts
+var MAX_NODES = 2e5;
+function readStructTree(file) {
+	const stRoot = file.get(file.catalog, "StructTreeRoot");
+	if (!(stRoot instanceof Map)) return void 0;
+	const pageMap = /* @__PURE__ */ new Map();
+	file.pages().forEach((p, i) => pageMap.set(p.dict, i));
+	const pageIndexOf = (pgVal) => {
+		const pg = file.resolve(pgVal);
+		return pg instanceof Map ? pageMap.get(pg) : void 0;
+	};
+	const seen = /* @__PURE__ */ new Set();
+	const read = (value, parentPage) => {
+		const elem = file.resolve(value);
+		if (!(elem instanceof Map) || seen.has(elem) || seen.size > MAX_NODES) return void 0;
+		seen.add(elem);
+		const ownPage = pageIndexOf(elem.get("Pg") ?? PDF_NULL) ?? parentPage;
+		const mcids = [];
+		const children = [];
+		for (const kid of kidList(file, elem.get("K"))) {
+			const rk = file.resolve(kid);
+			if (typeof rk === "number") {
+				if (ownPage >= 0) mcids.push({
+					page: ownPage,
+					mcid: rk
+				});
+			} else if (rk instanceof Map) {
+				const kind = nameOf(rk.get("Type"));
+				if (kind === "MCR") {
+					const m = rk.get("MCID");
+					const page = pageIndexOf(rk.get("Pg") ?? PDF_NULL) ?? ownPage;
+					if (typeof m === "number" && page >= 0) mcids.push({
+						page,
+						mcid: m
+					});
+				} else if (kind === "OBJR") {} else {
+					const child = read(rk, ownPage);
+					if (child) children.push(child);
+				}
+			}
+		}
+		const alt = elem.get("Alt");
+		const { colSpan, rowSpan } = readSpans(file, elem.get("A") ?? PDF_NULL);
+		return {
+			type: nameOf(elem.get("S")),
+			mcids,
+			children,
+			...typeof alt === "string" ? { alt } : {},
+			...colSpan > 1 ? { colSpan } : {},
+			...rowSpan > 1 ? { rowSpan } : {}
+		};
+	};
+	const roots = kidList(file, stRoot.get("K")).map((k) => read(k, -1)).filter((n) => n !== void 0);
+	if (roots.length === 1) return roots[0];
+	return {
+		type: "Document",
+		mcids: [],
+		children: roots
+	};
+}
+function kidList(file, kVal) {
+	if (kVal === void 0) return [];
+	const k = file.resolve(kVal);
+	if (Array.isArray(k)) return k;
+	if (k === PDF_NULL) return [];
+	return [k];
+}
+function nameOf(v) {
+	return v instanceof PdfName ? v.value : "";
+}
+function readSpans(file, aVal) {
+	let colSpan = 1;
+	let rowSpan = 1;
+	const a = file.resolve(aVal);
+	const attrs = Array.isArray(a) ? a : [a];
+	for (const entry of attrs) {
+		const d = file.resolve(entry);
+		if (d instanceof Map) {
+			const cs = d.get("ColSpan");
+			const rs = d.get("RowSpan");
+			if (typeof cs === "number") colSpan = cs;
+			if (typeof rs === "number") rowSpan = rs;
+		}
+	}
+	return {
+		colSpan,
+		rowSpan
+	};
+}
+//#endregion
+export { readStructTree };

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

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

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

@@ -0,0 +1,141 @@
+import { pt } from "../core/ir/units.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
+var ASSUMED_CONTENT_WIDTH_PT = 468;
+function reconstructTaggedPdf(file) {
+	const root = readStructTree(file);
+	if (!root) return void 0;
+	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) 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 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") {
+			const table = buildTable(node);
+			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) {
+			if (textOf(node).length > 0) out.push(paragraphFromRuns(spansOf(node), headingLevel(node.type)));
+			return;
+		}
+		for (const child of node.children) emit(child, out);
+	}
+	function buildTable(tableNode) {
+		const rows = [];
+		const collectRows = (n) => {
+			for (const child of n.children) if (child.type === "TR") rows.push(buildRow(child));
+			else if (child.type === "THead" || child.type === "TBody" || child.type === "TFoot") collectRows(child);
+		};
+		collectRows(tableNode);
+		if (rows.length === 0) return void 0;
+		const numCols = Math.max(1, ...rows.map((r) => r.cells.reduce((s, c) => s + (c.properties.colSpan ?? 1), 0)));
+		const colWidth = pt(Math.max(1, ASSUMED_CONTENT_WIDTH_PT / numCols));
+		return {
+			kind: "table",
+			table: {
+				properties: {},
+				grid: Array.from({ length: numCols }, () => colWidth),
+				rows
+			}
+		};
+	}
+	function buildRow(trNode) {
+		const cells = [];
+		let allHeader = false;
+		for (const cell of trNode.children) {
+			if (cell.type !== "TH" && cell.type !== "TD") continue;
+			if (cells.length === 0) allHeader = true;
+			if (cell.type !== "TH") allHeader = false;
+			const content = [];
+			for (const child of cell.children) emit(child, content);
+			if (content.length === 0) content.push(paragraphBlock(textOf(cell), void 0));
+			const colSpan = cell.colSpan ?? 1;
+			cells.push({
+				properties: colSpan > 1 ? { colSpan } : {},
+				content
+			});
+		}
+		return {
+			properties: allHeader && cells.length > 0 ? { isHeader: true } : {},
+			cells
+		};
+	}
+	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 {
+		doc: buildFlowDoc(body, resources),
+		losses: imageLosses
+	};
+}
+function squash(text) {
+	return text.replace(/\s+/g, " ").trim();
+}
+function headingLevel(type) {
+	const m = /^H([1-6])$/.exec(type);
+	return m ? Number(m[1]) - 1 : void 0;
+}
+//#endregion
+export { reconstructTaggedPdf };

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

@@ -0,0 +1,3 @@
+import { TextRun } from './content.js';
+import { PdfFile, PdfPage } from './document.js';
+export declare function extractPageText(file: PdfFile, page: PdfPage): Array<TextRun>;

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

@@ -0,0 +1,65 @@
+import { PdfName } from "../pdf/objects.js";
+import { interpretContent } from "./content.js";
+import { buildContentFont } from "./font.js";
+//#region src/pdf-reader/text.ts
+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 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>`;