reamkit 0.1.0-alpha.0

package/dist/esm/ooxml/wordproc/document-parser.d.ts

@@ -0,0 +1,9 @@
+import { BodyElement, Section, SectionProperties } from '../../document-model/index.js';
+import { ColorResolver } from '../drawingml/colors.js';
+import { PoNode } from './po-helpers.js';
+export declare function parseDocument(documentXml: Uint8Array, resolveColor?: ColorResolver): 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, resolveColor?: ColorResolver): Array<BodyElement>;
+export declare function parseBodyElements(children: ReadonlyArray<PoNode>, resolveColor?: ColorResolver): Array<BodyElement>;

package/dist/esm/ooxml/wordproc/document-parser.js

@@ -0,0 +1,274 @@
+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 { 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
+var decoder = new TextDecoder("utf-8");
+var parser = new XMLParser({
+	ignoreAttributes: false,
+	attributeNamePrefix: "@_",
+	preserveOrder: true,
+	parseAttributeValue: false,
+	parseTagValue: false,
+	trimValues: false
+});
+var RUN_CONTAINER_TAGS = new Set([
+	"w:hyperlink",
+	"w:sdt",
+	"w:sdtContent",
+	"w:smartTag",
+	"w:fldSimple",
+	"w:ins",
+	"w:moveTo"
+]);
+function parseDocument(documentXml, resolveColor = defaultColorResolver) {
+	const xml = decoder.decode(documentXml);
+	const body = poFindByPath(parser.parse(xml), ["w:document", "w:body"]);
+	if (!body) return [];
+	return parseBodyElements(poChildren(body), resolveColor);
+}
+var HF_TYPES = new Set([
+	"default",
+	"first",
+	"even"
+]);
+var EMPTY_SECTION = {
+	headers: [],
+	footers: []
+};
+function parseSections(documentXml) {
+	const xml = decoder.decode(documentXml);
+	const body = poFindByPath(parser.parse(xml), ["w:document", "w:body"]);
+	if (!body) return [];
+	const children = poChildren(body);
+	const sections = [];
+	let bodyIdx = 0;
+	for (const child of children) {
+		if (poIs(child, "w:sectPr")) {
+			sections.push({
+				properties: parseSectPrNode(child),
+				endIndex: bodyIdx
+			});
+			continue;
+		}
+		if (poIs(child, "w:p")) {
+			const pPrNode = poChildren(child).find((c) => poIs(c, "w:pPr"));
+			const sectPrInPPr = pPrNode ? poChildren(pPrNode).find((c) => poIs(c, "w:sectPr")) : void 0;
+			bodyIdx++;
+			if (sectPrInPPr) sections.push({
+				properties: parseSectPrNode(sectPrInPPr),
+				endIndex: bodyIdx
+			});
+		} else if (poIs(child, "w:tbl")) bodyIdx++;
+	}
+	if (sections.length === 0 || sections[sections.length - 1].endIndex < bodyIdx) sections.push({
+		properties: EMPTY_SECTION,
+		endIndex: bodyIdx
+	});
+	return sections;
+}
+function parseSectPrNode(sectPr) {
+	let pageSize;
+	let margins;
+	let titlePg = false;
+	const headers = [];
+	const footers = [];
+	for (const child of poChildren(sectPr)) if (poIs(child, "w:pgSz")) {
+		const w = poIntAttr(child, "w");
+		const h = poIntAttr(child, "h");
+		const orientRaw = poAttr(child, "orient");
+		if (w !== void 0 && h !== void 0) pageSize = {
+			widthTwips: w,
+			heightTwips: h,
+			...orientRaw === "portrait" || orientRaw === "landscape" ? { orientation: orientRaw } : {}
+		};
+	} else if (poIs(child, "w:pgMar")) {
+		const top = poIntAttr(child, "top");
+		const right = poIntAttr(child, "right");
+		const bottom = poIntAttr(child, "bottom");
+		const left = poIntAttr(child, "left");
+		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 } : {}
+		};
+	} else if (poIs(child, "w:headerReference")) pushHeaderFooter(child, headers);
+	else if (poIs(child, "w:footerReference")) pushHeaderFooter(child, footers);
+	else if (poIs(child, "w:titlePg")) {
+		const val = poAttr(child, "val");
+		titlePg = val === void 0 || val === "" || val !== "0" && val !== "false";
+	}
+	return {
+		...pageSize ? { pageSize } : {},
+		...margins ? { margins } : {},
+		headers,
+		footers,
+		...titlePg ? { titlePg: true } : {}
+	};
+}
+function pushHeaderFooter(node, list) {
+	const rId = poAttr(node, "id");
+	if (!rId) return;
+	const typeRaw = poAttr(node, "type") ?? "default";
+	const type = HF_TYPES.has(typeRaw) ? typeRaw : "default";
+	list.push({
+		type,
+		relationshipId: rId
+	});
+}
+function parseHeaderFooter(xml, resolveColor = defaultColorResolver) {
+	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);
+}
+function parseBodyElements(children, resolveColor = defaultColorResolver) {
+	const out = [];
+	for (const child of children) if (poIs(child, "w:p")) {
+		const drawing = tryExtractDrawingFromParagraph(child, resolveColor);
+		out.push(drawing ?? {
+			kind: "paragraph",
+			paragraph: parseParagraph(child)
+		});
+	} else if (poIs(child, "w:tbl")) out.push({
+		kind: "table",
+		table: parseTable(child)
+	});
+	return out;
+}
+function tryExtractDrawingFromParagraph(p, resolveColor) {
+	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;
+	}
+	if (!drawing || hasText) return null;
+	const parseBody = (children) => parseBodyElements(children, resolveColor);
+	const content = parseDrawing(drawing, 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 === "chart") return {
+		kind: "chart",
+		chart: {
+			chartRelId: content.chartRelId,
+			widthEmu: content.widthEmu,
+			heightEmu: content.heightEmu,
+			paragraphProperties,
+			...content.altText ? { altText: content.altText } : {}
+		}
+	};
+	return {
+		kind: "shape",
+		shape: {
+			...content.data,
+			paragraphProperties,
+			...content.altText ? { altText: content.altText } : {}
+		}
+	};
+}
+function parseParagraph(p) {
+	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"));
+	if (mathPara && properties.alignment === void 0) {
+		const paraPr = poChildren(mathPara).find((c) => poIs(c, "m:oMathParaPr"));
+		const jcVal = poAttr(paraPr ? poChildren(paraPr).find((c) => poIs(c, "m:jc")) : void 0, "val");
+		const alignment = jcVal === "left" ? "left" : jcVal === "right" ? "right" : "center";
+		properties = {
+			...properties,
+			alignment
+		};
+	}
+	const runs = [];
+	collectRuns(p, runs);
+	return {
+		properties,
+		runs
+	};
+}
+function collectRuns(container, out) {
+	for (const child of poChildren(container)) {
+		if (poIs(child, "w:pPr")) continue;
+		if (poIs(child, "w:r")) {
+			out.push(parseRun(child));
+			continue;
+		}
+		if (poIs(child, "m:oMath")) {
+			out.push({
+				text: "",
+				properties: {},
+				math: parseOMath(child)
+			});
+			continue;
+		}
+		if (poIs(child, "m:oMathPara")) {
+			for (const om of poChildren(child)) if (poIs(om, "m:oMath")) out.push({
+				text: "",
+				properties: {},
+				math: parseOMath(om)
+			});
+			continue;
+		}
+		const tag = elementTag(child);
+		if (tag && RUN_CONTAINER_TAGS.has(tag)) collectRuns(child, out);
+	}
+}
+function parseRun(r) {
+	const rPr = poChildren(r).find((c) => poIs(c, "w:rPr"));
+	const properties = parseRunProperties(rPr ? poElementToFlat(rPr) : void 0);
+	let text = "";
+	let pageBreak = false;
+	let inlineImage;
+	for (const child of expandMcChildren(poChildren(r))) {
+		if (poIs(child, "w:rPr")) continue;
+		if (poIs(child, "w:t")) text += poText(child);
+		else if (poIs(child, "w:tab")) text += "	";
+		else if (poIs(child, "w:br")) if (poAttr(child, "type") === "page") pageBreak = true;
+		else text += "\n";
+		else if (poIs(child, "w:noBreakHyphen")) text += "‑";
+		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
+			};
+		}
+	}
+	return {
+		text,
+		properties,
+		...inlineImage ? { inlineImage } : {},
+		...pageBreak ? { pageBreak: true } : {}
+	};
+}
+function elementTag(node) {
+	for (const key of Object.keys(node)) if (key !== ":@" && key !== "#text") return key;
+}
+//#endregion
+export { EMPTY_SECTION, parseBodyElements, parseDocument, parseHeaderFooter, parseSections };

package/dist/esm/ooxml/wordproc/drawing-parser.d.ts

@@ -0,0 +1,33 @@
+import { BodyElement, ShapeFill, ShapeGeometry, ShapeLine, ShapeTextBody, ShapeTransform } from '../../document-model/index.js';
+import { ColorResolver } from '../drawingml/colors.js';
+import { PoNode } from './po-helpers.js';
+export interface ShapeData {
+    readonly widthEmu: number;
+    readonly heightEmu: number;
+    readonly geometry: ShapeGeometry;
+    readonly fill: ShapeFill;
+    readonly line?: ShapeLine;
+    readonly transform?: ShapeTransform;
+    readonly text?: ShapeTextBody;
+}
+export type ParseBody = (children: ReadonlyArray<PoNode>) => Array<BodyElement>;
+export type DrawingContent = {
+    readonly kind: 'image';
+    readonly imageId: string;
+    readonly widthEmu: number;
+    readonly heightEmu: number;
+    readonly altText?: string;
+} | {
+    readonly kind: 'shape';
+    readonly data: ShapeData;
+    readonly altText?: string;
+} | {
+    readonly kind: 'chart';
+    readonly chartRelId: string;
+    readonly widthEmu: number;
+    readonly heightEmu: number;
+    readonly altText?: string;
+};
+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;

package/dist/esm/ooxml/wordproc/drawing-parser.js

@@ -0,0 +1,374 @@
+import { poAttr, poChildren, poFindDescendant, poIntAttr, poIs, poTag } from "./po-helpers.js";
+//#region src/ooxml/wordproc/drawing-parser.ts
+var WPS_URI = "http://schemas.microsoft.com/office/word/2010/wordprocessingShape";
+var CHART_URI = "http://schemas.openxmlformats.org/drawingml/2006/chart";
+var UNDERSTOOD_NS = new Set(["wps"]);
+function resolveMc(altContent) {
+	for (const choice of poChildren(altContent)) {
+		if (!poIs(choice, "mc:Choice")) continue;
+		const requires = (poAttr(choice, "Requires") ?? "").split(/\s+/).filter(Boolean);
+		if (requires.length > 0 && requires.every((r) => UNDERSTOOD_NS.has(r))) return poChildren(choice);
+	}
+	const fallback = poChildren(altContent).find((c) => poIs(c, "mc:Fallback"));
+	return fallback ? poChildren(fallback) : [];
+}
+function expandMcChildren(children) {
+	const out = [];
+	for (const c of children) if (poIs(c, "mc:AlternateContent")) out.push(...resolveMc(c));
+	else out.push(c);
+	return out;
+}
+function parseDrawing(drawing, resolveColor, parseBody) {
+	const anchor = poChildren(drawing).find((c) => poIs(c, "wp:inline")) ?? poChildren(drawing).find((c) => poIs(c, "wp:anchor"));
+	if (!anchor) return null;
+	const extent = poFindDescendant(anchor, "wp:extent");
+	const extentCx = extent ? poIntAttr(extent, "cx") : void 0;
+	const extentCy = extent ? poIntAttr(extent, "cy") : void 0;
+	const docPr = poChildren(anchor).find((c) => poIs(c, "wp:docPr"));
+	const descr = docPr ? poAttr(docPr, "descr") : void 0;
+	const title = docPr ? poAttr(docPr, "title") : void 0;
+	const altText = (descr ?? title)?.trim() || void 0;
+	const alt = altText ? { altText } : {};
+	const graphicData = poFindDescendant(anchor, "a:graphicData");
+	const uri = graphicData ? poAttr(graphicData, "uri") : void 0;
+	if (graphicData && uri === WPS_URI) {
+		const data = parseWsp(graphicData, extentCx, extentCy, resolveColor, parseBody);
+		return data ? {
+			kind: "shape",
+			data,
+			...alt
+		} : null;
+	}
+	if (graphicData && uri === CHART_URI) {
+		const cChart = poFindDescendant(graphicData, "c:chart");
+		const chartRelId = cChart ? poAttr(cChart, "id") : void 0;
+		if (chartRelId && extentCx !== void 0 && extentCy !== void 0) return {
+			kind: "chart",
+			chartRelId,
+			widthEmu: extentCx,
+			heightEmu: extentCy,
+			...alt
+		};
+		return null;
+	}
+	const blip = poFindDescendant(anchor, "a:blip");
+	const rId = blip ? poAttr(blip, "embed") : void 0;
+	if (extentCx !== void 0 && extentCy !== void 0 && rId) return {
+		kind: "image",
+		imageId: rId,
+		widthEmu: extentCx,
+		heightEmu: extentCy,
+		...alt
+	};
+	return null;
+}
+function parseWsp(graphicData, extentCx, extentCy, resolveColor, parseBody) {
+	const wsp = expandMcChildren(poChildren(graphicData)).find((c) => poIs(c, "wps:wsp"));
+	if (!wsp) return null;
+	const spPr = poChildren(wsp).find((c) => poIs(c, "wps:spPr"));
+	let geometry = {
+		kind: "preset",
+		preset: "rect",
+		adjust: /* @__PURE__ */ new Map()
+	};
+	let fill = { kind: "none" };
+	let line;
+	let transform;
+	let widthEmu = extentCx;
+	let heightEmu = extentCy;
+	if (spPr) {
+		const xfrm = poChildren(spPr).find((c) => poIs(c, "a:xfrm"));
+		if (xfrm) {
+			transform = parseXfrm(xfrm);
+			if (widthEmu === void 0 || heightEmu === void 0) {
+				const ext = poChildren(xfrm).find((c) => poIs(c, "a:ext"));
+				if (ext) {
+					widthEmu = widthEmu ?? poIntAttr(ext, "cx");
+					heightEmu = heightEmu ?? poIntAttr(ext, "cy");
+				}
+			}
+		}
+		const prst = poChildren(spPr).find((c) => poIs(c, "a:prstGeom"));
+		const cust = poChildren(spPr).find((c) => poIs(c, "a:custGeom"));
+		if (prst) geometry = parsePrstGeom(prst);
+		else if (cust) geometry = parseCustGeom(cust);
+		fill = parseFill(spPr, resolveColor);
+		line = parseLine(spPr, resolveColor);
+	}
+	const text = parseBody ? parseTextBox(wsp, parseBody) : void 0;
+	if (widthEmu === void 0 || heightEmu === void 0) return null;
+	return {
+		widthEmu,
+		heightEmu,
+		geometry,
+		fill,
+		...line ? { line } : {},
+		...transform ? { transform } : {},
+		...text ? { text } : {}
+	};
+}
+function parseTextBox(wsp, parseBody) {
+	const txbx = poChildren(wsp).find((c) => poIs(c, "wps:txbx"));
+	if (!txbx) return void 0;
+	const txContent = poChildren(txbx).find((c) => poIs(c, "w:txbxContent"));
+	if (!txContent) return void 0;
+	const content = parseBody(poChildren(txContent));
+	if (content.length === 0) return void 0;
+	const bodyPr = poChildren(wsp).find((c) => poIs(c, "wps:bodyPr"));
+	const lIns = bodyPr ? poIntAttr(bodyPr, "lIns") : void 0;
+	const tIns = bodyPr ? poIntAttr(bodyPr, "tIns") : void 0;
+	const rIns = bodyPr ? poIntAttr(bodyPr, "rIns") : void 0;
+	const bIns = bodyPr ? poIntAttr(bodyPr, "bIns") : void 0;
+	const a = bodyPr ? poAttr(bodyPr, "anchor") : void 0;
+	const anchor = a === "ctr" ? "ctr" : a === "b" ? "b" : a === "t" ? "t" : void 0;
+	return {
+		content,
+		...lIns !== void 0 ? { insetLeftEmu: lIns } : {},
+		...tIns !== void 0 ? { insetTopEmu: tIns } : {},
+		...rIns !== void 0 ? { insetRightEmu: rIns } : {},
+		...bIns !== void 0 ? { insetBottomEmu: bIns } : {},
+		...anchor ? { anchor } : {}
+	};
+}
+var isTrue = (v) => v === "1" || v === "true" || v === "on";
+function parseXfrm(xfrm) {
+	const rot = poIntAttr(xfrm, "rot");
+	const flipH = isTrue(poAttr(xfrm, "flipH"));
+	const flipV = isTrue(poAttr(xfrm, "flipV"));
+	return {
+		...rot !== void 0 ? { rotation60k: rot } : {},
+		...flipH ? { flipH: true } : {},
+		...flipV ? { flipV: true } : {}
+	};
+}
+function parsePrstGeom(prst) {
+	const preset = poAttr(prst, "prst") ?? "rect";
+	const adjust = /* @__PURE__ */ new Map();
+	const avLst = poChildren(prst).find((c) => poIs(c, "a:avLst"));
+	if (avLst) for (const gd of poChildren(avLst)) {
+		if (!poIs(gd, "a:gd")) continue;
+		const nm = poAttr(gd, "name");
+		const fmla = poAttr(gd, "fmla");
+		if (!nm || !fmla) continue;
+		const m = /^val\s+(-?\d+)/.exec(fmla);
+		if (m) adjust.set(nm, Number(m[1]));
+	}
+	return {
+		kind: "preset",
+		preset,
+		adjust
+	};
+}
+function parseCustGeom(cust) {
+	const pathLst = poChildren(cust).find((c) => poIs(c, "a:pathLst"));
+	const path = pathLst ? poChildren(pathLst).find((c) => poIs(c, "a:path")) : void 0;
+	if (!path) return {
+		kind: "preset",
+		preset: "rect",
+		adjust: /* @__PURE__ */ new Map()
+	};
+	const pathWidth = poIntAttr(path, "w") ?? 0;
+	const pathHeight = poIntAttr(path, "h") ?? 0;
+	const commands = [];
+	for (const node of poChildren(path)) switch (poTag(node)) {
+		case "a:moveTo": {
+			const p = firstPt(node);
+			if (p) commands.push({
+				cmd: "move",
+				x: p.x,
+				y: p.y
+			});
+			break;
+		}
+		case "a:lnTo": {
+			const p = firstPt(node);
+			if (p) commands.push({
+				cmd: "line",
+				x: p.x,
+				y: p.y
+			});
+			break;
+		}
+		case "a:cubicBezTo": {
+			const p = pts(node);
+			if (p.length >= 3) commands.push({
+				cmd: "cubic",
+				x1: p[0].x,
+				y1: p[0].y,
+				x2: p[1].x,
+				y2: p[1].y,
+				x: p[2].x,
+				y: p[2].y
+			});
+			break;
+		}
+		case "a:quadBezTo": {
+			const p = pts(node);
+			if (p.length >= 2) commands.push({
+				cmd: "quad",
+				x1: p[0].x,
+				y1: p[0].y,
+				x: p[1].x,
+				y: p[1].y
+			});
+			break;
+		}
+		case "a:arcTo":
+			commands.push({
+				cmd: "arc",
+				wR: poIntAttr(node, "wR") ?? 0,
+				hR: poIntAttr(node, "hR") ?? 0,
+				stAng: poIntAttr(node, "stAng") ?? 0,
+				swAng: poIntAttr(node, "swAng") ?? 0
+			});
+			break;
+		case "a:close":
+			commands.push({ cmd: "close" });
+			break;
+	}
+	if (pathWidth <= 0 || pathHeight <= 0 || commands.length === 0) return {
+		kind: "preset",
+		preset: "rect",
+		adjust: /* @__PURE__ */ new Map()
+	};
+	return {
+		kind: "custom",
+		custom: {
+			pathWidth,
+			pathHeight,
+			commands
+		}
+	};
+}
+function pts(node) {
+	const out = [];
+	for (const c of poChildren(node)) {
+		if (!poIs(c, "a:pt")) continue;
+		const x = poIntAttr(c, "x");
+		const y = poIntAttr(c, "y");
+		if (x !== void 0 && y !== void 0) out.push({
+			x,
+			y
+		});
+	}
+	return out;
+}
+var firstPt = (node) => pts(node)[0];
+function parseFill(spPr, resolveColor) {
+	for (const child of poChildren(spPr)) {
+		if (poIs(child, "a:noFill")) return { kind: "none" };
+		if (poIs(child, "a:solidFill")) {
+			const hex = colorFromContainer(child, resolveColor);
+			return hex ? {
+				kind: "solid",
+				colorHex: hex
+			} : { kind: "none" };
+		}
+		if (poIs(child, "a:gradFill")) {
+			const hex = colorFromGradient(child, resolveColor);
+			return hex ? {
+				kind: "solid",
+				colorHex: hex
+			} : { kind: "none" };
+		}
+	}
+	return { kind: "none" };
+}
+function parseLine(spPr, resolveColor) {
+	const ln = poChildren(spPr).find((c) => poIs(c, "a:ln"));
+	if (!ln) return void 0;
+	const widthEmu = poIntAttr(ln, "w");
+	const capRaw = poAttr(ln, "cap");
+	const cap = capRaw === "rnd" ? "round" : capRaw === "sq" ? "square" : capRaw === "flat" ? "flat" : void 0;
+	let noFill = false;
+	let colorHex;
+	let dash;
+	for (const c of poChildren(ln)) if (poIs(c, "a:noFill")) noFill = true;
+	else if (poIs(c, "a:solidFill")) colorHex = colorFromContainer(c, resolveColor);
+	else if (poIs(c, "a:prstDash")) dash = normalizeDash(poAttr(c, "val"));
+	return {
+		...widthEmu !== void 0 ? { widthEmu } : {},
+		...colorHex ? { colorHex } : {},
+		...dash ? { dash } : {},
+		...cap ? { cap } : {},
+		...noFill ? { fill: "none" } : {}
+	};
+}
+var DASH_VALUES = new Set([
+	"solid",
+	"dot",
+	"dash",
+	"dashDot",
+	"lgDash",
+	"lgDashDot",
+	"sysDash",
+	"sysDot"
+]);
+function normalizeDash(v) {
+	if (!v) return void 0;
+	if (DASH_VALUES.has(v)) return v;
+	if (v === "lgDashDotDot") return "lgDashDot";
+	if (v === "sysDashDot" || v === "sysDashDotDot") return "sysDash";
+}
+function readColorMods(colorNode) {
+	const mods = [];
+	for (const c of poChildren(colorNode)) for (const kind of [
+		"lumMod",
+		"lumOff",
+		"shade",
+		"tint",
+		"alpha"
+	]) if (poIs(c, `a:${kind}`)) {
+		const v = poIntAttr(c, "val");
+		if (v !== void 0) mods.push({
+			kind,
+			val: v / 1e5
+		});
+	}
+	return mods;
+}
+function resolveColorNode(c, resolveColor) {
+	const isSrgb = poIs(c, "a:srgbClr");
+	if (!isSrgb && !poIs(c, "a:schemeClr")) return void 0;
+	const v = poAttr(c, "val");
+	if (!v) return void 0;
+	const mods = readColorMods(c);
+	const raw = isSrgb ? { srgb: v } : { scheme: v };
+	return resolveColor(mods.length > 0 ? {
+		...raw,
+		mods
+	} : raw);
+}
+function colorFromContainer(parent, resolveColor) {
+	for (const c of poChildren(parent)) {
+		const hex = resolveColorNode(c, resolveColor);
+		if (hex) return hex;
+	}
+}
+function colorFromGradient(grad, resolveColor) {
+	const gsLst = poChildren(grad).find((c) => poIs(c, "a:gsLst"));
+	if (!gsLst) return void 0;
+	let r = 0;
+	let g = 0;
+	let b = 0;
+	let n = 0;
+	for (const gs of poChildren(gsLst)) {
+		if (!poIs(gs, "a:gs")) continue;
+		let hex;
+		for (const c of poChildren(gs)) {
+			hex = resolveColorNode(c, resolveColor);
+			if (hex) break;
+		}
+		if (!hex) continue;
+		const num = parseInt(hex, 16);
+		r += num >> 16 & 255;
+		g += num >> 8 & 255;
+		b += num & 255;
+		n++;
+	}
+	if (n === 0) return void 0;
+	const toHex = (x) => Math.round(x / n).toString(16).padStart(2, "0");
+	return (toHex(r) + toHex(g) + toHex(b)).toUpperCase();
+}
+//#endregion
+export { expandMcChildren, parseDrawing };

package/dist/esm/ooxml/wordproc/font-table.d.ts

@@ -0,0 +1,15 @@
+import { OpcPackage } from '../../opc/index.js';
+import { FontRegistry } from '../../font/index.js';
+type EmbedVariant = 'regular' | 'bold' | 'italic' | 'boldItalic';
+interface EmbedRef {
+    readonly rId: string;
+    readonly fontKey: string;
+}
+interface FontTableEntry {
+    readonly name: string;
+    readonly embeds: Partial<Record<EmbedVariant, EmbedRef>>;
+}
+export declare function deobfuscateEmbeddedFont(data: Uint8Array, fontKey: string): Uint8Array;
+export declare function parseFontTable(data: Uint8Array): Array<FontTableEntry>;
+export declare function loadEmbeddedFonts(pkg: OpcPackage): Map<string, FontRegistry>;
+export {};