reamkit 1.3.0 → 1.4.0

package/README.md

@@ -34,6 +34,7 @@ const doc = Ream.parse(bytes);            // docx or xlsx — sniffed
 const pdf = await doc.convert('pdf');     // async — fetches a font if needed
 const svg = await doc.convert('svg');     // same parse, different target
 const html = await doc.convert('html');   // flowed HTML — needs no fonts at all
+const docx = await doc.convert('docx');   // write WordprocessingML back out
 
 // Hand the bytes to the browser: preview, download, upload, …
 const url = URL.createObjectURL(new Blob([pdf], { type: 'application/pdf' }));
@@ -150,10 +151,11 @@ automatically from the document's `docProps/core.xml`), `attachments`
 
 ### Lower-level APIs
 
-- `docxReader` / `xlsxReader`, `svgWriter`, `htmlWriter` — the `@experimental` reader/writer
-  interfaces of the interlayer, for building custom pipelines (and keeping
-  unused formats out of your bundle); `layoutStyledDocument` produces the
-  frozen page model (`PageItem` pages in a top-left `Pt` frame) they consume.
+- `docxReader` / `xlsxReader`, `svgWriter`, `htmlWriter`, `docxWriter` — the `@experimental`
+  reader/writer interfaces of the interlayer, for building custom pipelines (and
+  keeping unused formats out of your bundle); `layoutStyledDocument` produces the
+  frozen page model (`PageItem` pages in a top-left `Pt` frame) the page-based
+  writers consume (`docxWriter` works from the flow model, before layout).
 - `renderStyledPdf` drives the layout engine directly; the typed document
   model is on the `reamkit/document-model` subpath.
 
@@ -170,7 +172,8 @@ Liang hyphenation, OpenType ligatures/kerning + Arabic cursive joining,
 BiDi (UAX #9), hyperlinks (PDF link annotations + HTML anchors,
 scheme-allowlisted), tagged PDF, PDF/A-1/2/3 (a/b/u), PDF/UA-1, AES-256
 encryption, digital signatures (PKCS#7/ECDSA/PAdES/RFC 3161), SVG page
-preview, flowed HTML export. Reads OOXML Transitional and Strict.
+preview, flowed HTML export, and **docx output** (write WordprocessingML back
+out, incl. docx → docx). Reads OOXML Transitional and Strict.
 
 See `handoff.md` for the full feature matrix and known limitations.
 

package/dist/esm/core/converter/facade.d.ts

@@ -5,8 +5,8 @@ import { FontProvider } from '../fonts/provider.js';
 import { Loss, LossReport } from '../ir/index.js';
 import { FontBytesByVariant } from '../font/index.js';
 export interface ConvertOptions extends ConvertDocxOptions {
-    /** Target: 'pdf' (default), 'svg' (page-stack preview) or 'html' (flowed). */
-    readonly to?: 'pdf' | 'svg' | 'html';
+    /** Target: 'pdf' (default), 'svg' (page-stack preview), 'html' or 'docx' (flowed). */
+    readonly to?: 'pdf' | 'svg' | 'html' | 'docx';
     /**
      * Strict mode (handoff v1 §5): throw ConversionLossError on the first
      * recorded loss instead of returning it in the report.

package/dist/esm/core/converter/facade.js

@@ -6,6 +6,7 @@ import { docxReader } from "../../word/docx-reader.js";
 import { xlsxReader } from "../../excel/xlsx-reader.js";
 import { chainProviders } from "../fonts/provider.js";
 import { flowRenderOptions } from "./project.js";
+import { writeDocx } from "../../word/docx-writer.js";
 import { writeHtml } from "../../html/html-writer.js";
 import { writeSvg } from "../../svg/svg-writer.js";
 import { convertDocxToPdf } from "../../word/docx-to-pdf.js";
@@ -20,6 +21,17 @@ function createConverter(opts = {}) {
 		const reader = detect(bytes);
 		if (!reader) throw new Error("Unrecognized input format (no registered reader sniffs these bytes)");
 		const losses = [];
+		if (to === "docx") {
+			const { doc: flow, losses: readLosses } = reader.read(bytes);
+			losses.push(...readLosses);
+			const out = writeDocx(flow);
+			losses.push(...out.losses);
+			if (strict && losses.length > 0) throw new ConversionLossError(losses[0]);
+			return {
+				bytes: out.bytes,
+				losses
+			};
+		}
 		if (to === "html") {
 			const { doc: flow, losses: readLosses } = reader.read(bytes);
 			losses.push(...readLosses);

package/dist/esm/core/converter/ream.d.ts

@@ -6,7 +6,7 @@ import { Loss } from '../ir/index.js';
 import { DocumentReader } from '../ir/adapters.js';
 import { FlowDoc } from '../ir/flow.js';
 import { SignatureOptions, StyledRenderOptions } from '../../pdf/index.js';
-export type ReamTarget = 'pdf' | 'svg' | 'html';
+export type ReamTarget = 'pdf' | 'svg' | 'html' | 'docx';
 export interface ReamParseOptions {
     readonly readers?: ReadonlyArray<DocumentReader>;
 }

package/dist/esm/core/converter/ream.js

@@ -6,6 +6,7 @@ import { signPdf } from "../../pdf/signature.js";
 import { renderStyledPdf, renderStyledPdfEncrypted } from "../../pdf/styled-page-renderer.js";
 import "../../pdf/index.js";
 import { flowRenderOptions } from "./project.js";
+import { writeDocx } from "../../word/docx-writer.js";
 import { writeHtml } from "../../html/html-writer.js";
 import { writeSvg } from "../../svg/svg-writer.js";
 import { resolveDocxAutoFonts } from "../../word/docx-to-pdf.js";
@@ -46,6 +47,15 @@ var Ream = class Ream {
 				losses
 			};
 		}
+		if (to === "docx") {
+			const docx = writeDocx(this.flow);
+			losses.push(...docx.losses);
+			this.enforceStrict(options, losses);
+			return {
+				bytes: docx.bytes,
+				losses
+			};
+		}
 		const { fonts, registriesByFamily } = await this.resolveFonts(options, losses);
 		const registry = FontRegistry.fromBytes(fonts);
 		if (to === "svg") {

package/dist/esm/core/opc/index.d.ts

@@ -4,3 +4,5 @@ export { REL_OFFICE_DOCUMENT, REL_CORE_PROPERTIES, REL_EXTENDED_PROPERTIES, } fr
 export { parseCoreProperties } from './core-properties.js';
 export type { CoreProperties } from './core-properties.js';
 export { isOoxmlRel } from './relationship-types.js';
+export { buildOpcPackage, relsPathFor } from './opc-writer.js';
+export type { OpcPart, OpcPartRelationships, OpcWriteOptions } from './opc-writer.js';

package/dist/esm/core/opc/index.js

@@ -1,3 +1,4 @@
 import "./relationship-types.js";
 import "./package.js";
 import "./core-properties.js";
+import "./opc-writer.js";

package/dist/esm/core/opc/opc-writer.d.ts

@@ -0,0 +1,28 @@
+import { Relationship } from './relationships.js';
+export interface OpcPart {
+    /** Package path, e.g. 'word/document.xml'. No leading slash. */
+    readonly path: string;
+    readonly data: Uint8Array;
+    /** Content type for the [Content_Types].xml Override (XML parts). */
+    readonly contentType: string;
+}
+export interface OpcPartRelationships {
+    /** The owning part, e.g. 'word/document.xml' (or '' for the package root). */
+    readonly sourcePart: string;
+    readonly relationships: ReadonlyArray<Relationship>;
+}
+export interface OpcWriteOptions {
+    readonly parts: ReadonlyArray<OpcPart>;
+    /** Package-level relationships (_rels/.rels). */
+    readonly rootRelationships: ReadonlyArray<Relationship>;
+    /** Per-part relationships (word/_rels/<part>.rels). */
+    readonly partRelationships?: ReadonlyArray<OpcPartRelationships>;
+    /**
+     * Default content types by lowercase extension, for parts not given an
+     * Override (typically binaries: png, jpeg…). `rels` and `xml` are always
+     * present and need not be repeated.
+     */
+    readonly defaultsByExtension?: Readonly<Record<string, string>>;
+}
+export declare function buildOpcPackage(options: OpcWriteOptions): Uint8Array;
+export declare function relsPathFor(partPath: string): string;

package/dist/esm/core/opc/opc-writer.js

@@ -0,0 +1,60 @@
+import { zipSync } from "fflate";
+//#region src/core/opc/opc-writer.ts
+var encoder = new TextEncoder();
+var RELS_NS = "http://schemas.openxmlformats.org/package/2006/relationships";
+var CT_NS = "http://schemas.openxmlformats.org/package/2006/content-types";
+var FIXED_MTIME = Date.UTC(1980, 0, 1, 0, 0, 0);
+function buildOpcPackage(options) {
+	const entries = {};
+	const add = (path, data) => {
+		entries[path] = [data, { mtime: FIXED_MTIME }];
+	};
+	add("[Content_Types].xml", encoder.encode(contentTypesXml(options)));
+	add("_rels/.rels", encoder.encode(relationshipsXml(options.rootRelationships)));
+	for (const part of options.parts) add(part.path, part.data);
+	for (const pr of options.partRelationships ?? []) {
+		if (pr.relationships.length === 0) continue;
+		add(relsPathFor(pr.sourcePart), encoder.encode(relationshipsXml(pr.relationships)));
+	}
+	return zipSync(entries);
+}
+function relsPathFor(partPath) {
+	const slash = partPath.lastIndexOf("/");
+	const dir = slash >= 0 ? partPath.slice(0, slash) : "";
+	const name = slash >= 0 ? partPath.slice(slash + 1) : partPath;
+	return dir ? `${dir}/_rels/${name}.rels` : `_rels/${name}.rels`;
+}
+function contentTypesXml(options) {
+	const defaults = {
+		rels: "application/vnd.openxmlformats-package.relationships+xml",
+		xml: "application/xml",
+		...options.defaultsByExtension ?? {}
+	};
+	const lines = ["<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>", `<Types xmlns="${CT_NS}">`];
+	for (const ext of Object.keys(defaults).sort()) lines.push(`<Default Extension="${ext}" ContentType="${escapeAttr(defaults[ext])}"/>`);
+	for (const part of options.parts) {
+		const ext = extensionOf(part.path);
+		if (ext !== void 0 && defaults[ext] === part.contentType) continue;
+		lines.push(`<Override PartName="/${escapeAttr(part.path)}" ContentType="${escapeAttr(part.contentType)}"/>`);
+	}
+	lines.push("</Types>");
+	return lines.join("");
+}
+function relationshipsXml(rels) {
+	const lines = ["<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>", `<Relationships xmlns="${RELS_NS}">`];
+	for (const r of rels) {
+		const mode = r.targetMode === "External" ? " TargetMode=\"External\"" : "";
+		lines.push(`<Relationship Id="${escapeAttr(r.id)}" Type="${escapeAttr(r.type)}" Target="${escapeAttr(r.target)}"${mode}/>`);
+	}
+	lines.push("</Relationships>");
+	return lines.join("");
+}
+function extensionOf(path) {
+	const dot = path.lastIndexOf(".");
+	return dot >= 0 ? path.slice(dot + 1).toLowerCase() : void 0;
+}
+function escapeAttr(s) {
+	return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+//#endregion
+export { buildOpcPackage, relsPathFor };

package/dist/esm/index.d.ts

@@ -25,5 +25,6 @@ export type { FontProvider, FontRequest, FontAnswer } from './core/fonts/provide
 export { svgWriter, writeSvg } from './svg/svg-writer.js';
 export type { SvgWriteOptions } from './svg/svg-writer.js';
 export { htmlWriter, writeHtml } from './html/html-writer.js';
+export { docxWriter, writeDocx } from './word/docx-writer.js';
 export { layoutStyledDocument } from './layout/styled-layout.js';
 export type { LaidOutDocument } from './layout/page-doc.js';

package/dist/esm/index.js

@@ -15,8 +15,9 @@ import { createLanguageHyphenator, getHyphenator } from "./core/hyphenation/inde
 import { docxReader, readDocx } from "./word/docx-reader.js";
 import { readXlsx, xlsxReader } from "./excel/xlsx-reader.js";
 import { NO_FONT, callerFontProvider, chainProviders, embeddedDocFontProvider, isEmbeddingRestricted, localFontProvider, readOs2FsType, remoteFontProvider } from "./core/fonts/provider.js";
+import { docxWriter, writeDocx } from "./word/docx-writer.js";
 import { htmlWriter, writeHtml } from "./html/html-writer.js";
 import { svgWriter, writeSvg } from "./svg/svg-writer.js";
 import { createConverter } from "./core/converter/facade.js";
 import { Ream } from "./core/converter/ream.js";
-export { ConversionLossError, FEATURES, FontRegistry, NO_FONT, Ream, ResourceStore, callerFontProvider, chainProviders, createConverter, createHyphenator, createLanguageHyphenator, docxReader, eighthPtToPt, embeddedDocFontProvider, emuToPt, fetchFontSet, formatLoss, getHyphenator, halfPtToPt, htmlWriter, inchToPt, isEmbeddingRestricted, layoutStyledDocument, localFontProvider, mmToPt, parseTtf, pt, pxToPt, readDocx, readOs2FsType, readXlsx, remoteFontProvider, renderStyledPdf, resolveFamilyKey, signPdf, splitPatternBundle, subsetTtf, svgWriter, twipsToPt, writeHtml, writeSvg, xlsxReader };
+export { ConversionLossError, FEATURES, FontRegistry, NO_FONT, Ream, ResourceStore, callerFontProvider, chainProviders, createConverter, createHyphenator, createLanguageHyphenator, docxReader, docxWriter, eighthPtToPt, embeddedDocFontProvider, emuToPt, fetchFontSet, formatLoss, getHyphenator, halfPtToPt, htmlWriter, inchToPt, isEmbeddingRestricted, layoutStyledDocument, localFontProvider, mmToPt, parseTtf, pt, pxToPt, readDocx, readOs2FsType, readXlsx, remoteFontProvider, renderStyledPdf, resolveFamilyKey, signPdf, splitPatternBundle, subsetTtf, svgWriter, twipsToPt, writeDocx, writeHtml, writeSvg, xlsxReader };

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

@@ -1,8 +1,8 @@
 import { twipsToPt } from "../core/ir/units.js";
-import { poAttr, poChildren, poFindByPath, poIntAttr, poIs, poText } from "../core/po-helpers.js";
+import { poAttr, poChildren, poFindByPath, poFindDescendant, poIntAttr, poIs, poText } from "../core/po-helpers.js";
 import { defaultColorResolver } from "../core/drawingml/colors.js";
 import { parseOMath } from "./omml-parser.js";
-import { expandMcChildren, parseDrawing } from "./drawing-parser.js";
+import { expandMcChildren, parseDrawing, parseVmlPicture } from "./drawing-parser.js";
 import { parseRunProperties } from "./run-properties.js";
 import { parseParagraphProperties } from "./paragraph-properties.js";
 import { poElementToFlat } from "./po-to-flat.js";
@@ -178,20 +178,44 @@ function parseBodyElements(children, ctx = DEFAULT_PARSE_CONTEXT) {
 	}
 	return out;
 }
-function tryExtractDrawingFromParagraph(p, ctx) {
-	let drawing;
-	let hasText = false;
-	for (const child of poChildren(p)) {
-		if (!poIs(child, "w:r")) continue;
-		for (const runChild of expandMcChildren(poChildren(child))) if (poIs(runChild, "w:drawing")) {
-			if (!drawing) drawing = runChild;
-		} else if (poIs(runChild, "w:t") && poText(runChild).length > 0) hasText = true;
-		else if (poIs(runChild, "w:tab") || poIs(runChild, "w:br") || poIs(runChild, "w:noBreakHyphen")) hasText = true;
+var COLLAPSE_TRANSPARENT_TAGS = new Set([
+	"w:ins",
+	"w:moveTo",
+	"w:sdt",
+	"w:sdtContent",
+	"w:smartTag"
+]);
+function scanForLoneDrawing(container, acc) {
+	for (const child of expandMcChildren(poChildren(container))) {
+		if (poIs(child, "w:pPr")) continue;
+		if (poIs(child, "w:r")) {
+			for (const rc of expandMcChildren(poChildren(child))) if (poIs(rc, "w:drawing")) {
+				if (!acc.drawing) acc.drawing = rc;
+			} else if (poIs(rc, "w:pict") || poIs(rc, "w:object")) {
+				if (!acc.vml && poFindDescendant(rc, "v:imagedata") !== void 0) acc.vml = rc;
+			} else if (poIs(rc, "w:t") && poText(rc).length > 0) acc.hasOther = true;
+			else if (poIs(rc, "w:tab") || poIs(rc, "w:br") || poIs(rc, "w:noBreakHyphen")) acc.hasOther = true;
+			continue;
+		}
+		if (poIs(child, "m:oMath") || poIs(child, "m:oMathPara")) {
+			acc.hasOther = true;
+			continue;
+		}
+		const tag = elementTag(child);
+		if (tag && COLLAPSE_TRANSPARENT_TAGS.has(tag)) scanForLoneDrawing(child, acc);
+		else if (tag && RUN_CONTAINER_TAGS.has(tag)) acc.hasOther = true;
 	}
-	if (!drawing || hasText) return null;
+}
+function tryExtractDrawingFromParagraph(p, ctx) {
+	const scan = { hasOther: false };
+	scanForLoneDrawing(p, scan);
+	const { drawing, vml } = scan;
+	if (scan.hasOther || !drawing && !vml) return null;
+	const fromVml = drawing === void 0;
 	const parseBody = (children) => parseBodyElements(children, ctx);
-	const content = parseDrawing(drawing, ctx.resolveColor, parseBody);
+	const content = fromVml ? parseVmlPicture(vml) : parseDrawing(drawing, ctx.resolveColor, parseBody);
 	if (!content) return null;
+	if (fromVml && content.kind === "image" && ctx.resolveImage?.(content.imageId) === void 0) return null;
 	const pPrNode = poChildren(p).find((c) => poIs(c, "w:pPr"));
 	const paragraphProperties = pPrNode ? parseParagraphProperties(poElementToFlat(pPrNode)) : {};
 	if (content.kind === "image") {
@@ -435,6 +459,16 @@ function parseRun(r, ctx) {
 					height: content.height
 				};
 			}
+		} else if (poIs(child, "w:pict") || poIs(child, "w:object")) {
+			const content = parseVmlPicture(child);
+			if (content && content.kind === "image") {
+				const resource = ctx.resolveImage?.(content.imageId);
+				if (resource) inlineImage = {
+					resource,
+					width: content.width,
+					height: content.height
+				};
+			}
 		}
 	}
 	return {

package/dist/esm/word/docx-writer.d.ts

@@ -0,0 +1,4 @@
+import { DocumentWriter, WriteResult } from '../core/ir/adapters.js';
+import { FlowDoc } from '../core/ir/flow.js';
+export declare function writeDocx(flow: FlowDoc): WriteResult;
+export declare const docxWriter: DocumentWriter<FlowDoc>;

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

@@ -0,0 +1,602 @@
+import { FEATURES } from "../core/ir/features.js";
+import { detectImageFormat } from "../core/images.js";
+import { EMPTY_STYLE_SHEET, resolveParagraphProperties, resolveRunProperties } from "../core/style-cascade/resolver.js";
+import "../core/style-cascade/index.js";
+import { buildOpcPackage } from "../core/opc/opc-writer.js";
+import "../core/opc/index.js";
+//#region src/word/docx-writer.ts
+var encoder = new TextEncoder();
+var DEFAULT_RUN = resolveRunProperties({}, {}, EMPTY_STYLE_SHEET);
+var DEFAULT_PARA = resolveParagraphProperties({}, EMPTY_STYLE_SHEET);
+var DOC_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml";
+var NUMBERING_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml";
+var REL_OFFICE_DOCUMENT = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument";
+var REL_NUMBERING = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering";
+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 EMU_PER_PT = 12700;
+var RASTER_MEDIA = {
+	png: {
+		ext: "png",
+		contentType: "image/png"
+	},
+	jpeg: {
+		ext: "jpeg",
+		contentType: "image/jpeg"
+	},
+	jpeg2000: {
+		ext: "jp2",
+		contentType: "image/jp2"
+	}
+};
+function mediaInfo(bytes) {
+	const raster = detectImageFormat(bytes);
+	if (raster) return RASTER_MEDIA[raster];
+	const b = (i) => bytes[i] ?? -1;
+	if (b(0) === 71 && b(1) === 73 && b(2) === 70 && b(3) === 56) return {
+		ext: "gif",
+		contentType: "image/gif"
+	};
+	if (b(0) === 66 && b(1) === 77) return {
+		ext: "bmp",
+		contentType: "image/bmp"
+	};
+	if (b(0) === 73 && b(1) === 73 && b(2) === 42 || b(0) === 77 && b(1) === 77) return {
+		ext: "tiff",
+		contentType: "image/tiff"
+	};
+	if (b(0) === 1 && b(1) === 0 && b(2) === 0 && b(3) === 0 && b(40) === 32 && b(41) === 69 && b(42) === 77 && b(43) === 70) return {
+		ext: "emf",
+		contentType: "image/x-emf"
+	};
+	if (b(0) === 215 && b(1) === 205 && b(2) === 198 && b(3) === 154 || b(0) === 1 && b(1) === 0 && b(2) === 9 && b(3) === 0) return {
+		ext: "wmf",
+		contentType: "image/x-wmf"
+	};
+	if (b(0) === 37 && b(1) === 80 && b(2) === 68 && b(3) === 70) return {
+		ext: "pdf",
+		contentType: "application/pdf"
+	};
+}
+var HEADER_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.header+xml";
+var FOOTER_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml";
+var REL_HEADER = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/header";
+var REL_FOOTER = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer";
+function newScope() {
+	return {
+		rels: [],
+		relSeq: 0,
+		relIdByResource: /* @__PURE__ */ new Map()
+	};
+}
+function writeDocx(flow) {
+	const losses = [];
+	const body = [];
+	const state = {
+		resources: flow.resources,
+		mediaParts: [],
+		mediaFileByResource: /* @__PURE__ */ new Map(),
+		bookmarkSeq: 0,
+		drawingSeq: 0
+	};
+	const docScope = newScope();
+	const extraParts = [];
+	const extraPartRels = [];
+	const hfCache = /* @__PURE__ */ new Map();
+	const sections = flow.sections.length > 0 ? flow.sections : flow.section ? [{
+		properties: flow.section,
+		endIndex: flow.body.length
+	}] : [];
+	const sectPrByClosingIndex = /* @__PURE__ */ new Map();
+	let finalSectPr = "";
+	sections.forEach((sec, i) => {
+		const refs = emitHeadersFooters(flow, sec.properties, state, docScope, extraParts, extraPartRels, hfCache, losses);
+		const sp = sectPrXml(sec.properties, refs);
+		if (i === sections.length - 1) finalSectPr = sp;
+		else sectPrByClosingIndex.set(sec.endIndex - 1, sp);
+	});
+	flow.body.forEach((el, idx) => {
+		emitBlock(body, el, losses, state, docScope, sectPrByClosingIndex.get(idx));
+	});
+	if (finalSectPr) body.push(finalSectPr);
+	const documentXml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"><w:body>${body.join("")}</w:body></w:document>`;
+	const numberingPart = flow.body.some((el) => el.kind === "paragraph" && el.paragraph.properties.numbering !== void 0) && flow.numbering ? {
+		path: NUMBERING_PART,
+		data: encoder.encode(numberingXml(flow.numbering)),
+		contentType: NUMBERING_CONTENT_TYPE
+	} : void 0;
+	if (numberingPart) docScope.rels.push({
+		id: `rId${++docScope.relSeq}`,
+		type: REL_NUMBERING,
+		target: "numbering.xml",
+		targetMode: "Internal"
+	});
+	const partRelationships = [...docScope.rels.length > 0 ? [{
+		sourcePart: "word/document.xml",
+		relationships: docScope.rels
+	}] : [], ...extraPartRels];
+	return {
+		bytes: buildOpcPackage({
+			parts: [
+				{
+					path: "word/document.xml",
+					data: encoder.encode(documentXml),
+					contentType: DOC_CONTENT_TYPE
+				},
+				...numberingPart ? [numberingPart] : [],
+				...extraParts,
+				...state.mediaParts
+			],
+			rootRelationships: [{
+				id: "rId1",
+				type: REL_OFFICE_DOCUMENT,
+				target: "word/document.xml",
+				targetMode: "Internal"
+			}],
+			...partRelationships.length > 0 ? { partRelationships } : {}
+		}),
+		losses
+	};
+}
+function emitHeadersFooters(flow, section, state, docScope, extraParts, extraPartRels, hfCache, losses) {
+	const refs = {
+		headers: [],
+		footers: []
+	};
+	if (!section || !flow.headersFooters) return refs;
+	const emitOne = (kind, relationshipId, type) => {
+		const cached = hfCache.get(relationshipId);
+		if (cached !== void 0) return cached;
+		const content = flow.headersFooters.get(relationshipId);
+		if (!content) return void 0;
+		const n = extraParts.filter((p) => p.path.includes(`/${kind}`)).length + 1;
+		const path = `word/${kind}${n}.xml`;
+		const root = kind === "header" ? "w:hdr" : "w:ftr";
+		const scope = newScope();
+		const inner = [];
+		for (const el of content) emitBlock(inner, el, losses, state, scope);
+		const xml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><${root} xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">${inner.join("")}</${root}>`;
+		extraParts.push({
+			path,
+			data: encoder.encode(xml),
+			contentType: kind === "header" ? HEADER_CONTENT_TYPE : FOOTER_CONTENT_TYPE
+		});
+		if (scope.rels.length > 0) extraPartRels.push({
+			sourcePart: path,
+			relationships: scope.rels
+		});
+		const relId = `rId${++docScope.relSeq}`;
+		docScope.rels.push({
+			id: relId,
+			type: kind === "header" ? REL_HEADER : REL_FOOTER,
+			target: `${kind}${n}.xml`,
+			targetMode: "Internal"
+		});
+		hfCache.set(relationshipId, relId);
+		return relId;
+	};
+	for (const h of section.headers) {
+		const relId = emitOne("header", h.relationshipId, h.type);
+		if (relId) refs.headers.push({
+			type: h.type,
+			relId
+		});
+	}
+	for (const f of section.footers) {
+		const relId = emitOne("footer", f.relationshipId, f.type);
+		if (relId) refs.footers.push({
+			type: f.type,
+			relId
+		});
+	}
+	return refs;
+}
+var docxWriter = {
+	id: "docx",
+	consumes: "flow",
+	supports: new Set([FEATURES.text]),
+	write: (doc) => writeDocx(doc)
+};
+function emitBlock(out, el, losses, state, scope, closingSectPr) {
+	if (el.kind === "paragraph") {
+		out.push(paragraphXml(el.paragraph, state, scope, closingSectPr));
+		return;
+	}
+	if (el.kind === "table") {
+		out.push(tableXml(el.table, losses, state, scope));
+		if (closingSectPr) out.push(`<w:p><w:pPr>${closingSectPr}</w:pPr></w:p>`);
+		return;
+	}
+	if (el.kind === "image") {
+		const drawing = drawingXml(el.image.resource, el.image.width, el.image.height, el.image.altText, state, scope);
+		if (drawing) out.push(`<w:p>${pPrWithSect(el.image.paragraphProperties, closingSectPr)}<w:r>${drawing}</w:r></w:p>`);
+		else {
+			losses.push({
+				severity: "dropped",
+				feature: FEATURES.images,
+				detail: "image bytes missing"
+			});
+			if (closingSectPr) out.push(`<w:p><w:pPr>${closingSectPr}</w:pPr></w:p>`);
+		}
+		return;
+	}
+	if (el.kind === "shape") {
+		const drawing = shapeDrawingXml(el.shape, losses, state, scope);
+		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)`
+	});
+}
+function drawingXml(resource, widthPt, heightPt, altText, state, scope) {
+	if (resource === void 0) return "";
+	const relId = mediaRelId(resource, state, scope);
+	if (relId === void 0) return "";
+	const cx = Math.round(widthPt * EMU_PER_PT);
+	const cy = Math.round(heightPt * 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="Image ${id}"${altText ? ` descr="${escapeAttr(altText)}"` : ""}/><a:graphic xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"><a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture"><pic:pic xmlns:pic="http://schemas.openxmlformats.org/drawingml/2006/picture"><pic:nvPicPr><pic:cNvPr id="${id}" name="Image ${id}"/><pic:cNvPicPr/></pic:nvPicPr><pic:blipFill><a:blip r:embed="${relId}"/><a:stretch><a:fillRect/></a:stretch></pic:blipFill><pic:spPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="${cx}" cy="${cy}"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></pic:spPr></pic:pic></a:graphicData></a:graphic></wp:inline></w:drawing>`;
+}
+var WPS_URI = "http://schemas.microsoft.com/office/word/2010/wordprocessingShape";
+function shapeDrawingXml(shape, losses, state, scope) {
+	const cx = Math.round(shape.width * EMU_PER_PT);
+	const cy = Math.round(shape.height * EMU_PER_PT);
+	const id = ++state.drawingSeq;
+	const descr = shape.altText ? ` descr="${escapeAttr(shape.altText)}"` : "";
+	const spPr = `<wps:spPr>${xfrmXml(shape.transform, cx, cy)}${geomXml(shape.geometry)}${fillXml(shape.fill)}${shape.line ? lineXml(shape.line) : ""}</wps:spPr>`;
+	const txbx = shape.text ? txbxXml(shape.text, losses, state, scope) : "";
+	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="Shape ${id}"${descr}/><a:graphic xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"><a:graphicData uri="${WPS_URI}"><wps:wsp xmlns:wps="http://schemas.microsoft.com/office/word/2010/wordprocessingShape"><wps:cNvSpPr/>` + spPr + txbx + bodyPrXml(shape.text) + "</wps:wsp></a:graphicData></a:graphic></wp:inline></w:drawing>";
+}
+function xfrmXml(t, cx, cy) {
+	return `<a:xfrm${t?.rotation60k !== void 0 ? ` rot="${t.rotation60k}"` : ""}${t?.flipH ? " flipH=\"1\"" : ""}${t?.flipV ? " flipV=\"1\"" : ""}><a:off x="0" y="0"/><a:ext cx="${cx}" cy="${cy}"/></a:xfrm>`;
+}
+function geomXml(g) {
+	if (g.kind === "custom" && g.custom) {
+		const cmds = g.custom.commands.map((c) => {
+			switch (c.cmd) {
+				case "move": return `<a:moveTo><a:pt x="${c.x}" y="${c.y}"/></a:moveTo>`;
+				case "line": return `<a:lnTo><a:pt x="${c.x}" y="${c.y}"/></a:lnTo>`;
+				case "cubic": return `<a:cubicBezTo><a:pt x="${c.x1}" y="${c.y1}"/><a:pt x="${c.x2}" y="${c.y2}"/><a:pt x="${c.x}" y="${c.y}"/></a:cubicBezTo>`;
+				case "quad": return `<a:quadBezTo><a:pt x="${c.x1}" y="${c.y1}"/><a:pt x="${c.x}" y="${c.y}"/></a:quadBezTo>`;
+				case "arc": return `<a:arcTo wR="${c.wR}" hR="${c.hR}" stAng="${c.stAng}" swAng="${c.swAng}"/>`;
+				case "close": return "<a:close/>";
+			}
+		}).join("");
+		const { pathWidth: w, pathHeight: h } = g.custom;
+		return `<a:custGeom><a:avLst/><a:gdLst/><a:rect l="0" t="0" r="${w}" b="${h}"/><a:pathLst><a:path w="${w}" h="${h}">${cmds}</a:path></a:pathLst></a:custGeom>`;
+	}
+	const gds = g.adjust && g.adjust.size > 0 ? [...g.adjust].map(([n, v]) => `<a:gd name="${escapeAttr(n)}" fmla="val ${v}"/>`).join("") : "";
+	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/>";
+}
+function lineXml(l) {
+	const w = l.width !== void 0 ? ` w="${Math.round(l.width * EMU_PER_PT)}"` : "";
+	const cap = l.cap === "round" ? " cap=\"rnd\"" : l.cap === "square" ? " cap=\"sq\"" : l.cap === "flat" ? " cap=\"flat\"" : "";
+	const inner = [];
+	if (l.fill === "none") inner.push("<a:noFill/>");
+	else if (l.colorHex) inner.push(`<a:solidFill><a:srgbClr val="${l.colorHex}"/></a:solidFill>`);
+	if (l.dash) inner.push(`<a:prstDash val="${l.dash}"/>`);
+	return `<a:ln${w}${cap}>${inner.join("")}</a:ln>`;
+}
+function txbxXml(text, losses, state, scope) {
+	const inner = [];
+	for (const el of text.content) emitBlock(inner, el, losses, state, scope);
+	return `<wps:txbx><w:txbxContent>${inner.join("")}</w:txbxContent></wps:txbx>`;
+}
+function bodyPrXml(text) {
+	if (!text) return "<wps:bodyPr/>";
+	const ins = (v, name) => v !== void 0 ? ` ${name}="${Math.round(v * EMU_PER_PT)}"` : "";
+	const anchor = text.anchor ? ` anchor="${text.anchor}"` : "";
+	return "<wps:bodyPr" + ins(text.insetLeft, "lIns") + ins(text.insetTop, "tIns") + ins(text.insetRight, "rIns") + ins(text.insetBottom, "bIns") + anchor + "/>";
+}
+function mediaRelId(resource, state, scope) {
+	const existingRel = scope.relIdByResource.get(resource);
+	if (existingRel !== void 0) return existingRel;
+	let target = state.mediaFileByResource.get(resource);
+	if (target === void 0) {
+		const bytes = state.resources.get(resource);
+		if (!bytes) return void 0;
+		const info = mediaInfo(bytes);
+		if (!info) return void 0;
+		target = `media/image${state.mediaParts.length + 1}.${info.ext}`;
+		state.mediaParts.push({
+			path: `word/${target}`,
+			data: bytes,
+			contentType: info.contentType
+		});
+		state.mediaFileByResource.set(resource, target);
+	}
+	const relId = `rId${++scope.relSeq}`;
+	scope.rels.push({
+		id: relId,
+		type: REL_IMAGE,
+		target,
+		targetMode: "Internal"
+	});
+	scope.relIdByResource.set(resource, relId);
+	return relId;
+}
+function tableXml(table, losses, state, scope) {
+	const grid = table.grid.map((w) => `<w:gridCol w:w="${twips(w)}"/>`).join("");
+	const rows = table.rows.map((row) => rowXml(row, losses, state, scope)).join("");
+	return `<w:tbl>${tblPrXml(table.properties)}<w:tblGrid>${grid}</w:tblGrid>${rows}</w:tbl>`;
+}
+function tblPrXml(p) {
+	const out = [];
+	if (p.widthType !== void 0) {
+		const w = p.widthType === "pct" ? Math.round((p.widthFraction ?? 0) * 5e3) : p.widthPt !== void 0 ? twips(p.widthPt) : 0;
+		out.push(`<w:tblW w:w="${w}" w:type="${p.widthType}"/>`);
+	}
+	if (p.alignment && p.alignment !== "left") out.push(`<w:jc w:val="${p.alignment}"/>`);
+	const borders = bordersXml("w:tblBorders", p.borders);
+	if (borders) out.push(borders);
+	const margins = cellMarginsXml("w:tblCellMar", p.defaultCellMargins);
+	if (margins) out.push(margins);
+	return out.length > 0 ? `<w:tblPr>${out.join("")}</w:tblPr>` : "";
+}
+function rowXml(row, losses, state, scope) {
+	const trPr = [];
+	if (row.properties.height !== void 0) {
+		const rule = row.properties.heightRule ?? "atLeast";
+		trPr.push(`<w:trHeight w:val="${twips(row.properties.height)}" w:hRule="${rule}"/>`);
+	}
+	if (row.properties.isHeader) trPr.push("<w:tblHeader/>");
+	if (row.properties.cantSplit) trPr.push("<w:cantSplit/>");
+	return `<w:tr>${trPr.length > 0 ? `<w:trPr>${trPr.join("")}</w:trPr>` : ""}${row.cells.map((cell) => cellXml(cell, losses, state, scope)).join("")}</w:tr>`;
+}
+function cellXml(cell, losses, state, scope) {
+	const content = [];
+	for (const child of cell.content) emitBlock(content, child, losses, state, scope);
+	if (content.length === 0) content.push("<w:p/>");
+	return `<w:tc>${tcPrXml(cell.properties)}${content.join("")}</w:tc>`;
+}
+function tcPrXml(p) {
+	const out = [];
+	if (p.width !== void 0) out.push(`<w:tcW w:w="${twips(p.width)}" w:type="dxa"/>`);
+	if (p.colSpan !== void 0 && p.colSpan > 1) out.push(`<w:gridSpan w:val="${p.colSpan}"/>`);
+	if (p.merge !== void 0) out.push(p.merge === "start" ? "<w:vMerge w:val=\"restart\"/>" : "<w:vMerge w:val=\"continue\"/>");
+	const borders = bordersXml("w:tcBorders", p.borders);
+	if (borders) out.push(borders);
+	const margins = cellMarginsXml("w:tcMar", p.margins);
+	if (margins) out.push(margins);
+	if (p.shading) out.push(`<w:shd w:val="clear" w:color="auto" w:fill="${p.shading.colorHex}"/>`);
+	return out.length > 0 ? `<w:tcPr>${out.join("")}</w:tcPr>` : "";
+}
+var BORDER_SIDES = [
+	["top", "w:top"],
+	["left", "w:left"],
+	["bottom", "w:bottom"],
+	["right", "w:right"],
+	["insideH", "w:insideH"],
+	["insideV", "w:insideV"]
+];
+function bordersXml(tag, borders) {
+	if (!borders) return "";
+	const sides = BORDER_SIDES.map(([key, el]) => {
+		const b = borders[key];
+		if (!b) return "";
+		const sz = b.width !== void 0 ? ` w:sz="${Math.round(b.width * 8)}"` : "";
+		const color = b.colorHex !== void 0 ? ` w:color="${b.colorHex}"` : "";
+		return `<${el} w:val="${b.style}"${sz}${color}/>`;
+	}).join("");
+	return sides ? `<${tag}>${sides}</${tag}>` : "";
+}
+function cellMarginsXml(tag, margins) {
+	if (!margins) return "";
+	const inner = [
+		["top", "w:top"],
+		["left", "w:left"],
+		["bottom", "w:bottom"],
+		["right", "w:right"]
+	].map(([key, el]) => {
+		const v = margins[key];
+		return v !== void 0 ? `<${el} w:w="${twips(v)}" w:type="dxa"/>` : "";
+	}).join("");
+	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 inner = [];
+	let i = 0;
+	while (i < visible.length) {
+		const run = visible[i];
+		const key = run.href ?? run.anchor;
+		if (key === void 0) {
+			inner.push(runXml(run, state, scope));
+			i++;
+			continue;
+		}
+		let j = i + 1;
+		while (j < visible.length && (visible[j].href ?? visible[j].anchor) === key) j++;
+		const group = visible.slice(i, j).map((r) => runXml(r, state, scope)).join("");
+		inner.push(hyperlinkXml(run, group === "" ? "<w:r/>" : group, state, scope));
+		i = j;
+	}
+	const bookmarks = (p.bookmarks ?? []).map((name) => {
+		const id = state.bookmarkSeq++;
+		return `<w:bookmarkStart w:id="${id}" w:name="${escapeAttr(name)}"/><w:bookmarkEnd w:id="${id}"/>`;
+	}).join("");
+	const pPrInner = pPrBody(p.properties) + (closingSectPr ?? "");
+	return `<w:p>${pPrInner !== "" ? `<w:pPr>${pPrInner}</w:pPr>` : ""}${bookmarks}${inner.join("")}</w:p>`;
+}
+function hyperlinkXml(run, inner, _state, scope) {
+	if (run.href !== void 0) {
+		const id = `rId${++scope.relSeq}`;
+		scope.rels.push({
+			id,
+			type: REL_HYPERLINK,
+			target: run.href,
+			targetMode: "External"
+		});
+		return `<w:hyperlink r:id="${id}">${inner}</w:hyperlink>`;
+	}
+	return `<w:hyperlink w:anchor="${escapeAttr(run.anchor)}">${inner}</w:hyperlink>`;
+}
+function runXml(run, state, scope) {
+	const rPr = rPrXml(run.properties);
+	if (run.inlineImage !== void 0) {
+		const img = run.inlineImage;
+		const drawing = drawingXml(img.resource, img.width, img.height, void 0, state, scope);
+		if (drawing) return `<w:r>${rPr}${drawing}</w:r>`;
+		if (run.text === "" && !run.pageBreak) return "";
+	}
+	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>`;
+}
+function rPrXml(r) {
+	const out = [];
+	if (r.bold !== DEFAULT_RUN.bold) out.push(toggle("w:b", r.bold));
+	if (r.italic !== DEFAULT_RUN.italic) out.push(toggle("w:i", r.italic));
+	if (r.strike !== DEFAULT_RUN.strike) out.push(toggle("w:strike", r.strike));
+	if (r.underline !== DEFAULT_RUN.underline) out.push(`<w:u w:val="${r.underline}"/>`);
+	const fonts = rFontsXml(r.fontFamily);
+	if (fonts) out.push(fonts);
+	if (r.fontSizePt !== DEFAULT_RUN.fontSizePt) out.push(`<w:sz w:val="${Math.round(r.fontSizePt * 2)}"/>`);
+	if (r.colorHex !== DEFAULT_RUN.colorHex) out.push(`<w:color w:val="${r.colorHex}"/>`);
+	if (r.verticalAlign !== DEFAULT_RUN.verticalAlign) out.push(`<w:vertAlign w:val="${r.verticalAlign}"/>`);
+	if (r.rtl !== DEFAULT_RUN.rtl) out.push(toggle("w:rtl", r.rtl));
+	if (r.lang !== void 0) out.push(`<w:lang w:val="${escapeAttr(r.lang)}"/>`);
+	return out.length > 0 ? `<w:rPr>${out.join("")}</w:rPr>` : "";
+}
+function pPrBody(p) {
+	const out = [];
+	if (p.numbering) out.push(`<w:numPr><w:ilvl w:val="${p.numbering.ilvl}"/><w:numId w:val="${escapeAttr(p.numbering.numId)}"/></w:numPr>`);
+	if (p.outlineLevel !== void 0) out.push(`<w:outlineLvl w:val="${p.outlineLevel}"/>`);
+	if (p.pageBreakBefore) out.push("<w:pageBreakBefore/>");
+	if (p.bidi !== DEFAULT_PARA.bidi) out.push(toggle("w:bidi", p.bidi));
+	const ind = indXml(p);
+	if (ind) out.push(ind);
+	const spacing = spacingXml(p);
+	if (spacing) out.push(spacing);
+	if (p.alignment !== DEFAULT_PARA.alignment) out.push(`<w:jc w:val="${p.alignment}"/>`);
+	return out.join("");
+}
+function pPrWithSect(p, closingSectPr) {
+	const inner = pPrBody(p) + (closingSectPr ?? "");
+	return inner !== "" ? `<w:pPr>${inner}</w:pPr>` : "";
+}
+function indXml(p) {
+	const attrs = [];
+	if (p.indentLeft !== DEFAULT_PARA.indentLeft) attrs.push(`w:left="${twips(p.indentLeft)}"`);
+	if (p.indentRight !== DEFAULT_PARA.indentRight) attrs.push(`w:right="${twips(p.indentRight)}"`);
+	if (p.indentFirstLine !== DEFAULT_PARA.indentFirstLine) if (p.indentFirstLine < 0) attrs.push(`w:hanging="${twips(-p.indentFirstLine)}"`);
+	else attrs.push(`w:firstLine="${twips(p.indentFirstLine)}"`);
+	return attrs.length > 0 ? `<w:ind ${attrs.join(" ")}/>` : "";
+}
+function spacingXml(p) {
+	const attrs = [];
+	if (p.spacingBefore !== DEFAULT_PARA.spacingBefore) attrs.push(`w:before="${twips(p.spacingBefore)}"`);
+	if (p.spacingAfter !== DEFAULT_PARA.spacingAfter) attrs.push(`w:after="${twips(p.spacingAfter)}"`);
+	if ((p.spacingLineRule !== DEFAULT_PARA.spacingLineRule || p.spacingLine !== DEFAULT_PARA.spacingLine) && p.spacingLine > 0) {
+		const lineVal = p.spacingLineRule === "auto" ? Math.round(p.spacingLine * 12) : twips(p.spacingLine);
+		attrs.push(`w:line="${lineVal}"`, `w:lineRule="${p.spacingLineRule}"`);
+	}
+	return attrs.length > 0 ? `<w:spacing ${attrs.join(" ")}/>` : "";
+}
+function rFontsXml(fonts) {
+	const d = DEFAULT_RUN.fontFamily;
+	const attrs = [];
+	if (fonts.ascii && fonts.ascii !== d.ascii) attrs.push(`w:ascii="${escapeAttr(fonts.ascii)}"`);
+	if (fonts.hAnsi && fonts.hAnsi !== d.hAnsi) attrs.push(`w:hAnsi="${escapeAttr(fonts.hAnsi)}"`);
+	if (fonts.cs && fonts.cs !== d.cs) attrs.push(`w:cs="${escapeAttr(fonts.cs)}"`);
+	return attrs.length > 0 ? `<w:rFonts ${attrs.join(" ")}/>` : "";
+}
+function toggle(tag, on) {
+	return on ? `<${tag}/>` : `<${tag} w:val="false"/>`;
+}
+function numberingXml(numbering) {
+	const out = ["<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>", "<w:numbering xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\">"];
+	for (const abstractNum of numbering.abstractNums.values()) {
+		out.push(`<w:abstractNum w:abstractNumId="${escapeAttr(abstractNum.id)}">`);
+		for (const level of [...abstractNum.levels.values()].sort((a, b) => a.ilvl - b.ilvl)) out.push(levelXml(level));
+		out.push("</w:abstractNum>");
+	}
+	for (const inst of numbering.numInstances.values()) out.push(`<w:num w:numId="${escapeAttr(inst.numId)}"><w:abstractNumId w:val="${escapeAttr(inst.abstractNumId)}"/></w:num>`);
+	out.push("</w:numbering>");
+	return out.join("");
+}
+function levelXml(level) {
+	const inner = [
+		`<w:start w:val="${level.start}"/>`,
+		`<w:numFmt w:val="${level.format}"/>`,
+		`<w:lvlText w:val="${escapeAttr(level.lvlText)}"/>`
+	];
+	const pPr = rawParaPrXml(level.paragraphProperties);
+	if (pPr) inner.push(pPr);
+	const rPr = rawRunPrXml(level.runProperties);
+	if (rPr) inner.push(rPr);
+	return `<w:lvl w:ilvl="${level.ilvl}">${inner.join("")}</w:lvl>`;
+}
+function rawParaPrXml(p) {
+	const attrs = [];
+	if (p.indentLeft !== void 0) attrs.push(`w:left="${twips(p.indentLeft)}"`);
+	if (p.indentRight !== void 0) attrs.push(`w:right="${twips(p.indentRight)}"`);
+	if (p.indentFirstLine !== void 0) if (p.indentFirstLine < 0) attrs.push(`w:hanging="${twips(-p.indentFirstLine)}"`);
+	else attrs.push(`w:firstLine="${twips(p.indentFirstLine)}"`);
+	const ind = attrs.length > 0 ? `<w:ind ${attrs.join(" ")}/>` : "";
+	const jc = p.alignment !== void 0 ? `<w:jc w:val="${p.alignment}"/>` : "";
+	return ind || jc ? `<w:pPr>${jc}${ind}</w:pPr>` : "";
+}
+function rawRunPrXml(r) {
+	const out = [];
+	if (r.bold !== void 0) out.push(toggle("w:b", r.bold));
+	if (r.italic !== void 0) out.push(toggle("w:i", r.italic));
+	if (r.strike !== void 0) out.push(toggle("w:strike", r.strike));
+	if (r.underline !== void 0) out.push(`<w:u w:val="${r.underline}"/>`);
+	const fonts = r.fontFamily ? rawRFontsXml(r.fontFamily) : "";
+	if (fonts) out.push(fonts);
+	if (r.fontSizePt !== void 0) out.push(`<w:sz w:val="${Math.round(r.fontSizePt * 2)}"/>`);
+	if (r.colorHex !== void 0) out.push(`<w:color w:val="${r.colorHex}"/>`);
+	if (r.verticalAlign !== void 0) out.push(`<w:vertAlign w:val="${r.verticalAlign}"/>`);
+	return out.length > 0 ? `<w:rPr>${out.join("")}</w:rPr>` : "";
+}
+function rawRFontsXml(fonts) {
+	const attrs = [];
+	if (fonts.ascii) attrs.push(`w:ascii="${escapeAttr(fonts.ascii)}"`);
+	if (fonts.hAnsi) attrs.push(`w:hAnsi="${escapeAttr(fonts.hAnsi)}"`);
+	if (fonts.cs) attrs.push(`w:cs="${escapeAttr(fonts.cs)}"`);
+	return attrs.length > 0 ? `<w:rFonts ${attrs.join(" ")}/>` : "";
+}
+function sectPrXml(s, hf) {
+	const parts = [];
+	for (const h of hf.headers) parts.push(`<w:headerReference w:type="${h.type}" r:id="${h.relId}"/>`);
+	for (const f of hf.footers) parts.push(`<w:footerReference w:type="${f.type}" r:id="${f.relId}"/>`);
+	if (s.pageSize) {
+		const orient = s.pageSize.orientation === "landscape" ? " w:orient=\"landscape\"" : "";
+		parts.push(`<w:pgSz w:w="${twips(s.pageSize.width)}" w:h="${twips(s.pageSize.height)}"${orient}/>`);
+	}
+	if (s.margins) {
+		const m = s.margins;
+		const header = m.header !== void 0 ? ` w:header="${twips(m.header)}"` : "";
+		const footer = m.footer !== void 0 ? ` w:footer="${twips(m.footer)}"` : "";
+		parts.push(`<w:pgMar w:top="${twips(m.top)}" w:right="${twips(m.right)}" w:bottom="${twips(m.bottom)}" w:left="${twips(m.left)}"${header}${footer}/>`);
+	}
+	if (s.columns) parts.push(colsXml(s.columns));
+	if (s.titlePg) parts.push("<w:titlePg/>");
+	if (parts.length === 0) return "";
+	return `<w:sectPr>${parts.join("")}</w:sectPr>`;
+}
+function colsXml(cols) {
+	if (cols.explicit && cols.explicit.length > 0) {
+		const inner = cols.explicit.map((c) => `<w:col w:w="${twips(c.widthPt)}" w:space="${twips(c.spacePt)}"/>`).join("");
+		return `<w:cols w:num="${cols.explicit.length}" w:equalWidth="0">${inner}</w:cols>`;
+	}
+	return `<w:cols w:num="${cols.count}" w:space="${twips(cols.spacePt)}"/>`;
+}
+var twips = (pt) => Math.round(pt * 20);
+function escapeXml(s) {
+	return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeAttr(s) {
+	return escapeXml(s).replace(/"/g, "&quot;");
+}
+//#endregion
+export { docxWriter, writeDocx };

package/dist/esm/word/drawing-parser.d.ts

@@ -35,3 +35,4 @@ export type DrawingContent = {
 export declare function resolveMc(altContent: PoNode): ReadonlyArray<PoNode>;
 export declare function expandMcChildren(children: ReadonlyArray<PoNode>): Array<PoNode>;
 export declare function parseDrawing(drawing: PoNode, resolveColor: ColorResolver, parseBody?: ParseBody): DrawingContent | null;
+export declare function parseVmlPicture(node: PoNode): DrawingContent | null;

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

@@ -1,4 +1,4 @@
-import { emuToPt } from "../core/ir/units.js";
+import { emuToPt, pt } from "../core/ir/units.js";
 import { poAttr, poChildren, poFindDescendant, poIntAttr, poIs, poTag, poText } from "../core/po-helpers.js";
 import { resolveColorNode } from "../core/drawingml/colors.js";
 //#region src/word/drawing-parser.ts
@@ -115,6 +115,41 @@ function parseDrawing(drawing, resolveColor, parseBody) {
 	};
 	return null;
 }
+function parseVmlPicture(node) {
+	const imagedata = poFindDescendant(node, "v:imagedata");
+	if (!imagedata) return null;
+	const imageId = poAttr(imagedata, "id");
+	if (imageId === void 0) return null;
+	const shape = poFindDescendant(node, "v:shape") ?? poFindDescendant(node, "v:rect") ?? poFindDescendant(node, "v:oval");
+	const width = vmlStyleLength(shape, "width");
+	const height = vmlStyleLength(shape, "height");
+	if (width === void 0 || height === void 0) return null;
+	const altText = (shape ? poAttr(shape, "alt") : void 0)?.trim() || poAttr(imagedata, "title")?.trim() || void 0;
+	return {
+		kind: "image",
+		imageId,
+		width,
+		height,
+		...altText ? { altText } : {}
+	};
+}
+var VML_UNIT_TO_PT = {
+	pt: 1,
+	in: 72,
+	px: .75,
+	cm: 72 / 2.54,
+	mm: 72 / 25.4,
+	pc: 12
+};
+function vmlStyleLength(shape, prop) {
+	const style = shape ? poAttr(shape, "style") : void 0;
+	if (style === void 0) return void 0;
+	const m = new RegExp(`(?:^|;)\\s*${prop}\\s*:\\s*(-?[0-9.]+)(pt|in|px|cm|mm|pc)?`, "i").exec(style);
+	if (!m) return void 0;
+	const value = Number.parseFloat(m[1]);
+	if (!Number.isFinite(value) || value <= 0) return void 0;
+	return pt(value * (VML_UNIT_TO_PT[(m[2] ?? "px").toLowerCase()] ?? 1));
+}
 function parseWsp(graphicData, extentCx, extentCy, resolveColor, parseBody) {
 	const wsp = expandMcChildren(poChildren(graphicData)).find((c) => poIs(c, "wps:wsp"));
 	if (!wsp) return null;
@@ -395,4 +430,4 @@ function colorFromGradient(grad, resolveColor) {
 	return (toHex(r) + toHex(g) + toHex(b)).toUpperCase();
 }
 //#endregion
-export { expandMcChildren, parseDrawing };
+export { expandMcChildren, parseDrawing, parseVmlPicture };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "reamkit",
-  "version": "1.3.0",
-  "description": "Ream — DOCX/XLSX to PDF (and SVG), built from scratch on the ECMA-376 and ISO 32000 specifications. Parse once, convert anywhere.",
+  "version": "1.4.0",
+  "description": "Ream — DOCX/XLSX to PDF, SVG, HTML and back to DOCX, built from scratch on the ECMA-376 and ISO 32000 specifications. Parse once, convert anywhere.",
   "license": "MIT",
   "author": "Alex Krassavin <info@reamkit.dev>",
   "repository": {
@@ -66,7 +66,8 @@
     "corpus:build": "tsx scripts/corpus/build-corpus.ts",
     "corpus:fetch": "tsx scripts/corpus/fetch-corpus.ts",
     "corpus:sandbox:build": "docker build -t docgen-losandbox:latest scripts/corpus/sandbox/",
-    "corpus": "tsx scripts/corpus/run.ts"
+    "corpus": "tsx scripts/corpus/run.ts",
+    "corpus:roundtrip": "tsx scripts/corpus/roundtrip.ts"
   },
   "dependencies": {
     "fast-xml-parser": "5.7.0",