reamkit 0.1.0-alpha.0 → 1.0.0

package/dist/esm/pdf/text-page-renderer.d.ts

@@ -1,4 +1,4 @@
-import { ParsedTtf } from '../font/index.js';
+import { ParsedTtf } from '../core/font/index.js';
 export type FontInput = ParsedTtf | {
     readonly bytes: Uint8Array;
 };

package/dist/esm/svg/svg-writer.d.ts

@@ -0,0 +1,8 @@
+import { DocumentWriter, WriteResult } from '../core/ir/adapters.js';
+import { LaidOutDocument } from '../pdf/styled-page-renderer.js';
+export interface SvgWriteOptions {
+    /** Gap between stacked pages, in px/pt (default 12). */
+    readonly pageGap?: number;
+}
+export declare function writeSvg(laid: LaidOutDocument, opts?: SvgWriteOptions): WriteResult;
+export declare const svgWriter: DocumentWriter<LaidOutDocument>;

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

@@ -0,0 +1,138 @@
+import { FEATURES } from "../core/ir/features.js";
+import { paintPlan } from "../pdf/styled-page-renderer.js";
+//#region src/svg/svg-writer.ts
+var PAGE_GAP = 12;
+function writeSvg(laid, opts = {}) {
+	const gap = opts.pageGap ?? PAGE_GAP;
+	const losses = [];
+	const width = Math.max(1, ...laid.pages.map((p) => p.width));
+	const height = laid.pages.reduce((s, p) => s + p.height, 0) + gap * Math.max(0, laid.pages.length - 1);
+	const parts = [];
+	parts.push(`<svg xmlns="http://www.w3.org/2000/svg" width="${fmt(width)}" height="${fmt(height)}" viewBox="0 0 ${fmt(width)} ${fmt(height)}">`);
+	let yOffset = 0;
+	laid.pages.forEach((page, i) => {
+		parts.push(`<g transform="translate(0 ${fmt(yOffset)})" data-page="${i + 1}">`);
+		parts.push(`<rect x="0" y="0" width="${fmt(page.width)}" height="${fmt(page.height)}" fill="#ffffff" stroke="#cccccc"/>`);
+		emitPage(parts, page, laid, losses);
+		parts.push("</g>");
+		yOffset += page.height + gap;
+	});
+	parts.push("</svg>");
+	return {
+		bytes: new TextEncoder().encode(parts.join("\n")),
+		losses
+	};
+}
+var svgWriter = {
+	id: "svg",
+	consumes: "page",
+	supports: new Set([
+		FEATURES.text,
+		FEATURES.tables,
+		FEATURES.images,
+		FEATURES.shapes
+	]),
+	write: (doc, opts) => writeSvg(doc, opts ?? {})
+};
+function emitPage(out, page, laid, losses) {
+	const H = page.height;
+	const plan = paintPlan(page.commands);
+	for (const f of plan.fills) out.push(`<rect x="${fmt(f.x)}" y="${fmt(H - f.y - f.height)}" width="${fmt(f.width)}" height="${fmt(f.height)}" fill="#${f.fillColorHex}"/>`);
+	for (const img of plan.images) {
+		const href = imageHref(img.imageResourceName, laid);
+		if (!href) continue;
+		out.push(`<image x="${fmt(img.x)}" y="${fmt(H - img.y - img.height)}" width="${fmt(img.width)}" height="${fmt(img.height)}" href="${href}" preserveAspectRatio="none"/>`);
+	}
+	for (const b of plan.borders) {
+		const x2 = b.x + b.width;
+		const yTop = H - b.y - b.height;
+		const yBottom = H - b.y;
+		const [ax, ay, bx, by] = b.side === "top" ? [
+			b.x,
+			yTop,
+			x2,
+			yTop
+		] : b.side === "bottom" ? [
+			b.x,
+			yBottom,
+			x2,
+			yBottom
+		] : b.side === "left" ? [
+			b.x,
+			yTop,
+			b.x,
+			yBottom
+		] : [
+			x2,
+			yTop,
+			x2,
+			yBottom
+		];
+		out.push(`<line x1="${fmt(ax)}" y1="${fmt(ay)}" x2="${fmt(bx)}" y2="${fmt(by)}" stroke="#${b.borderColorHex}" stroke-width="${fmt(b.borderSizePt)}"/>`);
+	}
+	for (const sh of plan.shapes) emitShape(out, sh.shape, H);
+	for (const t of plan.lines) emitTextLine(out, t, H, losses);
+}
+function emitTextLine(out, item, pageHeight, losses) {
+	const y = pageHeight - item.baselineY;
+	let x = item.originX;
+	for (const tok of item.line.tokens) {
+		if (tok.kind === "image") {
+			x += tok.widthPt;
+			continue;
+		}
+		if (tok.kind === "math") {
+			losses.push({
+				severity: "dropped",
+				feature: FEATURES.math,
+				detail: "inline math box not rendered by the SVG writer (v0)"
+			});
+			x += tok.widthPt;
+			continue;
+		}
+		if (tok.text.trim().length > 0) out.push(`<text x="${fmt(x)}" y="${fmt(y)}" font-family="sans-serif" font-size="${fmt(tok.fontSizePt)}" fill="#${tok.resolvedRun.colorHex}">${escapeXml(tok.text)}</text>`);
+		x += tok.widthPt;
+	}
+}
+function emitShape(out, shape, pageHeight) {
+	const [a, b, c, d, e, f] = shape.transform;
+	const transform = `matrix(${fmt(a)} ${fmt(-b)} ${fmt(-c)} ${fmt(d)} ${fmt(e)} ${fmt(pageHeight - f)})`;
+	const fill = shape.fillColorHex ? `#${shape.fillColorHex}` : "none";
+	const stroke = shape.stroke ? ` stroke="#${shape.stroke.colorHex}" stroke-width="${fmt(shape.stroke.widthPt)}"` : "";
+	for (const path of shape.paths) {
+		const d2 = pathData(path.segments);
+		const rule = path.fillRule === "evenodd" ? " fill-rule=\"evenodd\"" : "";
+		out.push(`<path d="${d2}" fill="${fill}"${rule}${stroke} transform="${transform}"/>`);
+	}
+}
+function pathData(segments) {
+	const parts = [];
+	for (const s of segments) if (s.op === "move") parts.push(`M ${fmt(s.x)} ${fmt(-s.y)}`);
+	else if (s.op === "line") parts.push(`L ${fmt(s.x)} ${fmt(-s.y)}`);
+	else if (s.op === "cubic") parts.push(`C ${fmt(s.x1)} ${fmt(-s.y1)} ${fmt(s.x2)} ${fmt(-s.y2)} ${fmt(s.x)} ${fmt(-s.y)}`);
+	else parts.push("Z");
+	return parts.join(" ");
+}
+function imageHref(resourceName, laid) {
+	if (!resourceName) return void 0;
+	for (const [resourceId, res] of laid.imageResources) {
+		if (res.resourceName !== resourceName) continue;
+		const bytes = laid.resources.get(resourceId);
+		if (!bytes) return void 0;
+		return `data:${res.prepared.mimeType};base64,${toBase64(bytes)}`;
+	}
+}
+function toBase64(bytes) {
+	let bin = "";
+	for (const b of bytes) bin += String.fromCharCode(b);
+	return btoa(bin);
+}
+function escapeXml(s) {
+	return s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;");
+}
+function fmt(n) {
+	const r = Math.round(n * 100) / 100;
+	return Object.is(r, -0) ? "0" : String(r);
+}
+//#endregion
+export { svgWriter, writeSvg };

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

@@ -0,0 +1,16 @@
+import { BodyElement, Section, SectionProperties } from '../core/document-model/index.js';
+import { ColorResolver } from '../core/drawingml/colors.js';
+import { ResourceId } from '../core/ir/index.js';
+import { PoNode } from '../core/po-helpers.js';
+export type ImageResolver = (relId: string) => ResourceId | undefined;
+export interface ParseContext {
+    readonly resolveColor: ColorResolver;
+    readonly resolveImage?: ImageResolver;
+}
+export declare const DEFAULT_PARSE_CONTEXT: ParseContext;
+export declare function parseDocument(documentXml: Uint8Array, ctx?: ParseContext): Array<BodyElement>;
+export declare const EMPTY_SECTION: SectionProperties;
+export declare function parseSection(documentXml: Uint8Array): SectionProperties;
+export declare function parseSections(documentXml: Uint8Array): Array<Section>;
+export declare function parseHeaderFooter(xml: Uint8Array, ctx?: ParseContext): Array<BodyElement>;
+export declare function parseBodyElements(children: ReadonlyArray<PoNode>, ctx?: ParseContext): Array<BodyElement>;

package/dist/esm/{ooxml/wordproc → word}/document-parser.js

@@ -1,13 +1,14 @@
-import { poAttr, poChildren, poFindByPath, poIntAttr, poIs, poText } from "./po-helpers.js";
-import { defaultColorResolver } from "../drawingml/colors.js";
-import { parseOMath } from "../math/omml-parser.js";
+import { twipsToPt } from "../core/ir/units.js";
+import { poAttr, poChildren, poFindByPath, 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 { parseRunProperties } from "./run-properties.js";
 import { parseParagraphProperties } from "./paragraph-properties.js";
 import { poElementToFlat } from "./po-to-flat.js";
 import { parseTable } from "./table-parser.js";
 import { XMLParser } from "fast-xml-parser";
-//#region src/ooxml/wordproc/document-parser.ts
+//#region src/word/document-parser.ts
 var decoder = new TextDecoder("utf-8");
 var parser = new XMLParser({
 	ignoreAttributes: false,
@@ -26,11 +27,12 @@ var RUN_CONTAINER_TAGS = new Set([
 	"w:ins",
 	"w:moveTo"
 ]);
-function parseDocument(documentXml, resolveColor = defaultColorResolver) {
+var DEFAULT_PARSE_CONTEXT = { resolveColor: defaultColorResolver };
+function parseDocument(documentXml, ctx = DEFAULT_PARSE_CONTEXT) {
 	const xml = decoder.decode(documentXml);
 	const body = poFindByPath(parser.parse(xml), ["w:document", "w:body"]);
 	if (!body) return [];
-	return parseBodyElements(poChildren(body), resolveColor);
+	return parseBodyElements(poChildren(body), ctx);
 }
 var HF_TYPES = new Set([
 	"default",
@@ -83,8 +85,8 @@ function parseSectPrNode(sectPr) {
 		const h = poIntAttr(child, "h");
 		const orientRaw = poAttr(child, "orient");
 		if (w !== void 0 && h !== void 0) pageSize = {
-			widthTwips: w,
-			heightTwips: h,
+			width: twipsToPt(w),
+			height: twipsToPt(h),
 			...orientRaw === "portrait" || orientRaw === "landscape" ? { orientation: orientRaw } : {}
 		};
 	} else if (poIs(child, "w:pgMar")) {
@@ -95,12 +97,12 @@ function parseSectPrNode(sectPr) {
 		const header = poIntAttr(child, "header");
 		const footer = poIntAttr(child, "footer");
 		margins = {
-			topTwips: top ?? 1440,
-			rightTwips: right ?? 1440,
-			bottomTwips: bottom ?? 1440,
-			leftTwips: left ?? 1440,
-			...header !== void 0 ? { headerTwips: header } : {},
-			...footer !== void 0 ? { footerTwips: footer } : {}
+			top: twipsToPt(top ?? 1440),
+			right: twipsToPt(right ?? 1440),
+			bottom: twipsToPt(bottom ?? 1440),
+			left: twipsToPt(left ?? 1440),
+			...header !== void 0 ? { header: twipsToPt(header) } : {},
+			...footer !== void 0 ? { footer: twipsToPt(footer) } : {}
 		};
 	} else if (poIs(child, "w:headerReference")) pushHeaderFooter(child, headers);
 	else if (poIs(child, "w:footerReference")) pushHeaderFooter(child, footers);
@@ -126,26 +128,26 @@ function pushHeaderFooter(node, list) {
 		relationshipId: rId
 	});
 }
-function parseHeaderFooter(xml, resolveColor = defaultColorResolver) {
+function parseHeaderFooter(xml, ctx = DEFAULT_PARSE_CONTEXT) {
 	const root = parser.parse(decoder.decode(xml)).find((n) => poIs(n, "w:hdr") || poIs(n, "w:ftr"));
 	if (!root) return [];
-	return parseBodyElements(poChildren(root), resolveColor);
+	return parseBodyElements(poChildren(root), ctx);
 }
-function parseBodyElements(children, resolveColor = defaultColorResolver) {
+function parseBodyElements(children, ctx = DEFAULT_PARSE_CONTEXT) {
 	const out = [];
 	for (const child of children) if (poIs(child, "w:p")) {
-		const drawing = tryExtractDrawingFromParagraph(child, resolveColor);
+		const drawing = tryExtractDrawingFromParagraph(child, ctx);
 		out.push(drawing ?? {
 			kind: "paragraph",
-			paragraph: parseParagraph(child)
+			paragraph: parseParagraph(child, ctx)
 		});
 	} else if (poIs(child, "w:tbl")) out.push({
 		kind: "table",
-		table: parseTable(child)
+		table: parseTable(child, ctx)
 	});
 	return out;
 }
-function tryExtractDrawingFromParagraph(p, resolveColor) {
+function tryExtractDrawingFromParagraph(p, ctx) {
 	let drawing;
 	let hasText = false;
 	for (const child of poChildren(p)) {
@@ -156,27 +158,30 @@ function tryExtractDrawingFromParagraph(p, resolveColor) {
 		else if (poIs(runChild, "w:tab") || poIs(runChild, "w:br") || poIs(runChild, "w:noBreakHyphen")) hasText = true;
 	}
 	if (!drawing || hasText) return null;
-	const parseBody = (children) => parseBodyElements(children, resolveColor);
-	const content = parseDrawing(drawing, resolveColor, parseBody);
+	const parseBody = (children) => parseBodyElements(children, ctx);
+	const content = parseDrawing(drawing, ctx.resolveColor, parseBody);
 	if (!content) return null;
 	const pPrNode = poChildren(p).find((c) => poIs(c, "w:pPr"));
 	const paragraphProperties = pPrNode ? parseParagraphProperties(poElementToFlat(pPrNode)) : {};
-	if (content.kind === "image") return {
-		kind: "image",
-		image: {
-			imageId: content.imageId,
-			widthEmu: content.widthEmu,
-			heightEmu: content.heightEmu,
-			paragraphProperties,
-			...content.altText ? { altText: content.altText } : {}
-		}
-	};
+	if (content.kind === "image") {
+		const resource = ctx.resolveImage?.(content.imageId);
+		return {
+			kind: "image",
+			image: {
+				...resource ? { resource } : {},
+				width: content.width,
+				height: content.height,
+				paragraphProperties,
+				...content.altText ? { altText: content.altText } : {}
+			}
+		};
+	}
 	if (content.kind === "chart") return {
 		kind: "chart",
 		chart: {
 			chartRelId: content.chartRelId,
-			widthEmu: content.widthEmu,
-			heightEmu: content.heightEmu,
+			width: content.width,
+			height: content.height,
 			paragraphProperties,
 			...content.altText ? { altText: content.altText } : {}
 		}
@@ -190,7 +195,7 @@ function tryExtractDrawingFromParagraph(p, resolveColor) {
 		}
 	};
 }
-function parseParagraph(p) {
+function parseParagraph(p, ctx) {
 	const pPr = poChildren(p).find((c) => poIs(c, "w:pPr"));
 	let properties = parseParagraphProperties(pPr ? poElementToFlat(pPr) : void 0);
 	const mathPara = poChildren(p).find((c) => poIs(c, "m:oMathPara"));
@@ -204,17 +209,17 @@ function parseParagraph(p) {
 		};
 	}
 	const runs = [];
-	collectRuns(p, runs);
+	collectRuns(p, runs, ctx);
 	return {
 		properties,
 		runs
 	};
 }
-function collectRuns(container, out) {
+function collectRuns(container, out, ctx) {
 	for (const child of poChildren(container)) {
 		if (poIs(child, "w:pPr")) continue;
 		if (poIs(child, "w:r")) {
-			out.push(parseRun(child));
+			out.push(parseRun(child, ctx));
 			continue;
 		}
 		if (poIs(child, "m:oMath")) {
@@ -234,10 +239,10 @@ function collectRuns(container, out) {
 			continue;
 		}
 		const tag = elementTag(child);
-		if (tag && RUN_CONTAINER_TAGS.has(tag)) collectRuns(child, out);
+		if (tag && RUN_CONTAINER_TAGS.has(tag)) collectRuns(child, out, ctx);
 	}
 }
-function parseRun(r) {
+function parseRun(r, ctx) {
 	const rPr = poChildren(r).find((c) => poIs(c, "w:rPr"));
 	const properties = parseRunProperties(rPr ? poElementToFlat(rPr) : void 0);
 	let text = "";
@@ -253,11 +258,14 @@ function parseRun(r) {
 		else if (poIs(child, "w:softHyphen")) text += "­";
 		else if (poIs(child, "w:drawing")) {
 			const content = parseDrawing(child, defaultColorResolver);
-			if (content && content.kind === "image") inlineImage = {
-				imageId: content.imageId,
-				widthEmu: content.widthEmu,
-				heightEmu: content.heightEmu
-			};
+			if (content && content.kind === "image") {
+				const resource = ctx.resolveImage?.(content.imageId);
+				inlineImage = {
+					...resource ? { resource } : {},
+					width: content.width,
+					height: content.height
+				};
+			}
 		}
 	}
 	return {
@@ -271,4 +279,4 @@ function elementTag(node) {
 	for (const key of Object.keys(node)) if (key !== ":@" && key !== "#text") return key;
 }
 //#endregion
-export { EMPTY_SECTION, parseBodyElements, parseDocument, parseHeaderFooter, parseSections };
+export { DEFAULT_PARSE_CONTEXT, EMPTY_SECTION, parseBodyElements, parseDocument, parseHeaderFooter, parseSections };

package/dist/esm/word/docx-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 readDocx(docx: Uint8Array): ReadResult<FlowDoc>;
+export declare const docxReader: DocumentReader<FlowDoc>;

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

@@ -0,0 +1,190 @@
+import { ResourceStore } from "../core/ir/resources.js";
+import { FEATURES } from "../core/ir/features.js";
+import { EMPTY_STYLE_SHEET } from "../core/style-cascade/resolver.js";
+import "../core/style-cascade/index.js";
+import { bytesInclude } from "../core/bytes.js";
+import { DEFAULT_THEME_PALETTE, makeColorResolver } from "../core/drawingml/colors.js";
+import { parseChart } from "../core/drawingml/chart-parser.js";
+import { parseTheme } from "../core/drawingml/theme-parser.js";
+import { OpcPackage } from "../core/opc/package.js";
+import { parseCoreProperties } from "../core/opc/core-properties.js";
+import "../core/opc/index.js";
+import { EMPTY_SECTION, parseDocument, parseHeaderFooter, parseSections } from "./document-parser.js";
+import { parseStyles } from "./styles-parser.js";
+import { loadEmbeddedFonts } from "./font-table.js";
+import { EMPTY_NUMBERING, parseNumbering } from "./numbering-parser.js";
+import { EMPTY_SETTINGS, parseSettings } from "./settings-parser.js";
+import "./index.js";
+//#region src/word/docx-reader.ts
+var STYLES_PART = "word/styles.xml";
+var NUMBERING_PART = "word/numbering.xml";
+var SETTINGS_PART = "word/settings.xml";
+var CORE_PROPS_PART = "docProps/core.xml";
+var MAIN_DOCUMENT_PART = "word/document.xml";
+var REL_IMAGE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image";
+var REL_CHART = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart";
+var REL_THEME = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme";
+var REL_HEADER = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/header";
+var REL_FOOTER = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer";
+var THEME_PART = "word/theme/theme1.xml";
+function readDocx(docx) {
+	const pkg = OpcPackage.open(docx);
+	const main = pkg.getMainDocument();
+	const resolveColor = buildColorResolver(pkg);
+	const resources = new ResourceStore();
+	const ctx = {
+		resolveColor,
+		resolveImage: makeImageResolver(pkg, resources)
+	};
+	const body = parseDocument(main.data, ctx);
+	const rawSections = parseSections(main.data);
+	const stylesData = pkg.getPart(STYLES_PART);
+	const styles = stylesData ? parseStyles(stylesData) : EMPTY_STYLE_SHEET;
+	const numberingData = pkg.getPart(NUMBERING_PART);
+	const numbering = numberingData ? parseNumbering(numberingData) : EMPTY_NUMBERING;
+	const settingsData = pkg.getPart(SETTINGS_PART);
+	const settings = settingsData ? parseSettings(settingsData) : EMPTY_SETTINGS;
+	const sections = rawSections.length > 0 ? rawSections.map((s) => ({
+		...s,
+		properties: settings.evenAndOddHeaders ? {
+			...s.properties,
+			evenAndOddHeaders: true
+		} : s.properties
+	})) : [{
+		properties: settings.evenAndOddHeaders ? {
+			...EMPTY_SECTION,
+			evenAndOddHeaders: true
+		} : EMPTY_SECTION,
+		endIndex: body.length
+	}];
+	const headersFooters = loadHeadersFootersForSections(pkg, sections, ctx, resources);
+	const charts = loadCharts(pkg, resolveColor);
+	const embeddedFonts = loadEmbeddedFonts(pkg);
+	const coreData = pkg.getPart(CORE_PROPS_PART);
+	const info = infoFromCore(coreData ? parseCoreProperties(coreData) : void 0);
+	const language = detectDocxLanguage(stylesData, main.data);
+	return {
+		doc: {
+			kind: "flow",
+			body,
+			sections,
+			styles,
+			numbering,
+			headersFooters,
+			charts,
+			resources,
+			...embeddedFonts.size > 0 ? { embeddedFonts } : {},
+			...info ? { info } : {},
+			...language ? { language } : {}
+		},
+		losses: []
+	};
+}
+var docxReader = {
+	id: "docx",
+	produces: "flow",
+	supports: new Set([
+		FEATURES.text,
+		FEATURES.tables,
+		FEATURES.tablesNested,
+		FEATURES.lists,
+		FEATURES.sections,
+		FEATURES.headersFooters,
+		FEATURES.images,
+		FEATURES.shapes,
+		FEATURES.charts,
+		FEATURES.math,
+		FEATURES.rtl,
+		FEATURES.trackedChanges,
+		FEATURES.fontsEmbedding
+	]),
+	sniff: (bytes) => bytes[0] === 80 && bytes[1] === 75 && bytesInclude(bytes, "word/document.xml"),
+	read: (bytes) => readDocx(bytes)
+};
+function infoFromCore(core) {
+	if (!core) return void 0;
+	return {
+		...core.title ? { title: core.title } : {},
+		...core.creator ? { author: core.creator } : {},
+		...core.subject ? { subject: core.subject } : {},
+		...core.keywords ? { keywords: core.keywords } : {},
+		...core.created ? { creationDate: core.created } : {},
+		...core.modified ? { modificationDate: core.modified } : {}
+	};
+}
+function makeImageResolver(pkg, store, partName = MAIN_DOCUMENT_PART) {
+	const byRelId = /* @__PURE__ */ new Map();
+	for (const rel of pkg.getPartRelationships(partName)) {
+		if (rel.type !== REL_IMAGE) continue;
+		const resolved = pkg.resolveRelatedPart(partName, rel);
+		if (resolved) byRelId.set(rel.id, resolved.data);
+	}
+	const cache = /* @__PURE__ */ new Map();
+	return (relId) => {
+		if (cache.has(relId)) return cache.get(relId);
+		const bytes = byRelId.get(relId);
+		const id = bytes ? store.put(bytes) : void 0;
+		cache.set(relId, id);
+		return id;
+	};
+}
+function loadCharts(pkg, resolveColor) {
+	const out = /* @__PURE__ */ new Map();
+	for (const rel of pkg.getPartRelationships(MAIN_DOCUMENT_PART)) {
+		if (rel.type !== REL_CHART) continue;
+		const resolved = pkg.resolveRelatedPart(MAIN_DOCUMENT_PART, rel);
+		if (!resolved) continue;
+		const chart = parseChart(resolved.data, resolveColor);
+		if (chart) out.set(rel.id, chart);
+	}
+	return out;
+}
+function buildColorResolver(pkg) {
+	const themeData = loadTheme(pkg);
+	if (!themeData) return makeColorResolver(DEFAULT_THEME_PALETTE);
+	const palette = new Map(DEFAULT_THEME_PALETTE);
+	for (const [slot, hex] of parseTheme(themeData)) palette.set(slot, hex);
+	return makeColorResolver(palette);
+}
+function loadTheme(pkg) {
+	for (const rel of pkg.getPartRelationships(MAIN_DOCUMENT_PART)) {
+		if (rel.type !== REL_THEME) continue;
+		const resolved = pkg.resolveRelatedPart(MAIN_DOCUMENT_PART, rel);
+		if (resolved) return resolved.data;
+	}
+	return pkg.getPart(THEME_PART);
+}
+function loadHeadersFootersForSections(pkg, sections, ctx, store) {
+	const wanted = /* @__PURE__ */ new Set();
+	for (const s of sections) {
+		for (const h of s.properties.headers) wanted.add(h.relationshipId);
+		for (const f of s.properties.footers) wanted.add(f.relationshipId);
+	}
+	if (wanted.size === 0) return /* @__PURE__ */ new Map();
+	const rels = pkg.getPartRelationships(MAIN_DOCUMENT_PART);
+	if (rels.length === 0) return /* @__PURE__ */ new Map();
+	const out = /* @__PURE__ */ new Map();
+	for (const rel of rels) {
+		if (!wanted.has(rel.id)) continue;
+		if (rel.type !== REL_HEADER && rel.type !== REL_FOOTER) continue;
+		const resolved = pkg.resolveRelatedPart(MAIN_DOCUMENT_PART, rel);
+		if (!resolved) continue;
+		const hfCtx = {
+			resolveColor: ctx.resolveColor,
+			resolveImage: makeImageResolver(pkg, store, resolved.path)
+		};
+		out.set(rel.id, parseHeaderFooter(resolved.data, hfCtx));
+	}
+	return out;
+}
+function detectDocxLanguage(stylesData, documentData) {
+	const re = /<w:lang\b[^>]*\bw:val="([^"]+)"/;
+	const decoder = new TextDecoder();
+	for (const data of [stylesData, documentData]) {
+		if (!data) continue;
+		const m = re.exec(decoder.decode(data));
+		if (m?.[1]) return m[1];
+	}
+}
+//#endregion
+export { docxReader, readDocx };

package/dist/esm/word/docx-to-pdf.d.ts

@@ -0,0 +1,34 @@
+import { FontBytesByVariant, FontRegistry } from '../core/font/index.js';
+import { FamilyKey, FetchLike } from '../core/fonts/index.js';
+import { SignatureOptions, StyledRenderOptions } from '../pdf/index.js';
+export interface ConvertDocxOptions extends Omit<StyledRenderOptions, 'registry' | 'styles'> {
+    readonly fontBytes?: Uint8Array;
+    readonly fonts?: FontBytesByVariant;
+    readonly fontFamily?: string;
+    readonly fontFetch?: FetchLike;
+    readonly embedSource?: boolean;
+    readonly signature?: SignatureOptions;
+}
+/**
+ * Synchronous one-shot conversion (requires `fonts`/`fontBytes`, no network).
+ *
+ * Internal since 1.0 — see the async variant above.
+ */
+export declare function convertDocxToPdfSync(docx: Uint8Array, options: ConvertDocxOptions): Uint8Array;
+export declare function detectDocxFamilyKeys(docx: Uint8Array): Set<FamilyKey>;
+/**
+ * One-shot .docx → PDF (auto-downloads a substitute font set when the caller
+ * supplies none; zero network with `fonts`/`fontBytes`).
+ *
+ * Internal since 1.0 — the public entry is `Ream.parse(bytes).convert('pdf')`;
+ * the createConverter facade and the test suite drive this directly.
+ */
+export declare function convertDocxToPdf(docx: Uint8Array, options?: ConvertDocxOptions): Promise<Uint8Array>;
+export declare function resolveDocxAutoFonts(docx: Uint8Array, options?: {
+    readonly fontFamily?: string;
+    readonly fontFetch?: FetchLike;
+}): Promise<{
+    fonts: FontBytesByVariant;
+    registriesByFamily?: Map<FamilyKey, FontRegistry>;
+}>;
+export declare function detectDocxFontFamily(docx: Uint8Array): string | undefined;