@stll/folio-core 0.7.0 → 0.9.0

package/dist/docx/ensureParaIds.js

@@ -0,0 +1,423 @@
+import { isXmlNameBoundary } from "./selectiveXmlPatch.js";
+import { deterministicHexId } from "../utils/hexId.js";
+import { TaggedError } from "better-result";
+import JSZip from "jszip";
+//#region src/docx/ensureParaIds.ts
+/**
+* Headless `w14:paraId` normalization for a `.docx` buffer.
+*
+* Word 2010+ stamps every paragraph with a `w14:paraId`, but Google Docs
+* exports, LibreOffice, python-docx, and docx4j generally do not. Paragraphs
+* without one are invisible to everything that anchors on paraId (block ids,
+* comment threads, AI-edit targeting) and fall back to positional `seq-NNNN`
+* ids that renumber after structural edits. Hosts call {@link ensureParaIds}
+* once at ingest so every stored version has full id coverage before any
+* snapshot or external anchor is created.
+*
+* IDs remain stable in folio and identity-preserving DOCX round-trips.
+* Microsoft Word can establish a new `w14:docId` and replace all paragraph
+* IDs on its first save of a non-Word-produced package; callers that ingest
+* such an externally edited version must normalize it again and cannot assume
+* the pre-save IDs still match.
+*
+* The pass patches part XML in place (string splices, no model round-trip),
+* so documents carrying features folio's parser does not model come back
+* with those features byte-identical. Contract:
+*
+* - Parts covered: `word/document.xml`, `word/header*.xml`, `word/footer*.xml`,
+*   `word/footnotes.xml`, `word/endnotes.xml`. Paragraphs nested in table
+*   cells and in `mc:Choice` text boxes are plain `<w:p>` elements inside
+*   those parts and are covered by the same scan. The comments part mints its
+*   own deterministic paraIds at save time (see `commentSerializer`) and is
+*   left untouched; its ids still count toward uniqueness.
+* - Paragraphs inside `mc:Fallback` are never modified: Word regenerates the
+*   fallback branch (duplicating the `mc:Choice` ids) on save, so stamping or
+*   deduplicating there would churn on every Word round-trip.
+* - Existing ids are preserved. Only three cases get a fresh id: a missing
+*   `paraId`, the reserved all-zero value (Word reads `00000000` as "no id"),
+*   and a duplicate of an id already seen earlier in the scan (first
+*   occurrence keeps it — the same rule `ParaIdAllocatorExtension` applies in
+*   the editor). `w14:textId` is written alongside a newly minted `paraId`
+*   (same value) and never touched otherwise; it is a text-revision marker,
+*   not identity.
+* - Fresh ids are deterministic (`deterministicHexId` over document content,
+*   part path, and paragraph ordinal), so the pass is a pure function of the
+*   input bytes: retrying an ingest produces identical output.
+* - Each patched part's root element gets `xmlns:w14` / `xmlns:mc`
+*   declarations and a `mc:Ignorable` listing `w14` when missing — non-Word
+*   producers declare neither, and absent `mc:Ignorable` handling is what
+*   makes pre-2010 consumers choke on the new attributes.
+* - Idempotent: a document that already has full coverage is returned as the
+*   original bytes, untouched (`alreadyComplete: true`).
+* - Digitally signed packages are returned untouched when already complete.
+*   When normalization would rewrite the package, it fails unless the caller
+*   explicitly allows signature invalidation after warning the user.
+*/
+/** A malformed or unsupported package prevented paragraph-ID normalization. */
+var EnsureParaIdsError = class extends TaggedError("EnsureParaIdsError")() {};
+const W14_NAMESPACE_URI = "http://schemas.microsoft.com/office/word/2010/wordml";
+const MC_NAMESPACE_URI = "http://schemas.openxmlformats.org/markup-compatibility/2006";
+const MC_IGNORABLE_W14 = "w14";
+const DIGITAL_SIGNATURE_PART_PREFIX = "_xmlsignatures/";
+/** Word reads an all-zero `w14:paraId` as "no id assigned". */
+const RESERVED_ZERO_ID_PATTERN = /^0*$/u;
+const DOCUMENT_PART = "word/document.xml";
+const TARGET_PART_PATTERNS = [
+	/^word\/document\.xml$/u,
+	/^word\/header\d*\.xml$/u,
+	/^word\/footer\d*\.xml$/u,
+	/^word\/footnotes\.xml$/u,
+	/^word\/endnotes\.xml$/u
+];
+const PARAGRAPH_OPEN = "<w:p";
+const FALLBACK_OPEN = "<mc:Fallback";
+const FALLBACK_CLOSE = "</mc:Fallback>";
+const OPAQUE_XML_REGIONS = [
+	{
+		open: "<!--",
+		close: "-->"
+	},
+	{
+		open: "<![CDATA[",
+		close: "]]>"
+	},
+	{
+		open: "<?",
+		close: "?>"
+	}
+];
+/**
+* The parser accepts the `w:` fallback prefix for paraId, and comment parts
+* link replies via `w15:paraId` — all three count toward uniqueness.
+*/
+const ANY_PARA_ID_PATTERN = /\bw(?:14|15)?:paraId=(?<quote>["'])(?<id>[\s\S]*?)\k<quote>/gu;
+const OPEN_TAG_PARA_ID_PATTERN = /\sw(?:14)?:paraId=(?<quote>["'])(?<id>[\s\S]*?)\k<quote>/u;
+const OPEN_TAG_TEXT_ID_PATTERN = /\sw(?:14)?:textId=(?<quote>["'])(?<id>[\s\S]*?)\k<quote>/u;
+const XMLNS_W14_PATTERN = /\sxmlns:w14=(?<quote>["'])(?<value>[\s\S]*?)\k<quote>/u;
+const XMLNS_MC_PATTERN = /\sxmlns:mc=(?<quote>["'])(?<value>[\s\S]*?)\k<quote>/u;
+const MC_IGNORABLE_PATTERN = /\smc:Ignorable=(?<quote>["'])(?<value>[\s\S]*?)\k<quote>/u;
+const applySplices = (xml, edits) => {
+	const ordered = [...edits].sort((a, b) => b.start - a.start);
+	let result = xml;
+	for (const { start, end, text } of ordered) result = result.slice(0, start) + text + result.slice(end);
+	return result;
+};
+const createEnsureParaIdsError = (message, cause) => new EnsureParaIdsError({
+	message,
+	...cause === void 0 ? {} : { cause }
+});
+const skipOpaqueXmlRegion = (xml, start, partPath) => {
+	for (const { open, close } of OPAQUE_XML_REGIONS) {
+		if (!xml.startsWith(open, start)) continue;
+		const closeStart = xml.indexOf(close, start + open.length);
+		if (closeStart === -1) throw createEnsureParaIdsError(`Unterminated ${open} region in ${partPath}`);
+		return closeStart + close.length;
+	}
+	return null;
+};
+const attributeValueRange = (match, absoluteOffset, group) => {
+	const quote = match.groups["quote"];
+	const value = match.groups[group];
+	const start = absoluteOffset + match.index + match[0].indexOf(quote) + 1;
+	return {
+		start,
+		end: start + value.length
+	};
+};
+const collectExistingParaIds = (xml, into) => {
+	for (const match of xml.matchAll(ANY_PARA_ID_PATTERN)) {
+		const id = match.groups["id"];
+		if (id.length > 0) into.add(id.toUpperCase());
+	}
+};
+const collectFallbackParaIds = (xml, partPath, into) => {
+	let fallbackDepth = 0;
+	let pos = 0;
+	while (pos < xml.length) {
+		const tagStart = xml.indexOf("<", pos);
+		if (tagStart === -1) return;
+		const opaqueEnd = skipOpaqueXmlRegion(xml, tagStart, partPath);
+		if (opaqueEnd !== null) {
+			pos = opaqueEnd;
+			continue;
+		}
+		if (xml.startsWith(FALLBACK_OPEN, tagStart) && isXmlNameBoundary(xml[tagStart + 12])) {
+			const tagEnd = xml.indexOf(">", tagStart);
+			if (tagEnd === -1) throw createEnsureParaIdsError(`Unterminated <mc:Fallback> tag in ${partPath}`);
+			if (xml[tagEnd - 1] !== "/") fallbackDepth += 1;
+			pos = tagEnd + 1;
+			continue;
+		}
+		if (xml.startsWith(FALLBACK_CLOSE, tagStart)) {
+			fallbackDepth = Math.max(0, fallbackDepth - 1);
+			pos = tagStart + 14;
+			continue;
+		}
+		if (fallbackDepth === 0 || !xml.startsWith(PARAGRAPH_OPEN, tagStart) || !isXmlNameBoundary(xml[tagStart + 4])) {
+			pos = tagStart + 1;
+			continue;
+		}
+		const tagEnd = xml.indexOf(">", tagStart);
+		if (tagEnd === -1) throw createEnsureParaIdsError(`Unterminated <w:p> tag in ${partPath}`);
+		const id = OPEN_TAG_PARA_ID_PATTERN.exec(xml.slice(tagStart, tagEnd + 1))?.groups?.["id"];
+		if (id) into.add(id.toUpperCase());
+		pos = tagEnd + 1;
+	}
+};
+/**
+* Deterministic fresh id for the paragraph at `ordinal` in `partPath`,
+* salted past collisions with any id anywhere in the document.
+*/
+const mintParaId = (context, partPath, ordinal) => {
+	const seed = `${context.docKey}:${partPath}:${ordinal}`;
+	let id = deterministicHexId(seed);
+	for (let salt = 1; context.taken.has(id); salt += 1) id = deterministicHexId(`${seed}:${salt}`);
+	context.taken.add(id);
+	return id;
+};
+/**
+* One forward scan over a part: every `<w:p>` open tag outside `mc:Fallback`
+* either keeps its paraId (valid, first occurrence) or gets a splice edit
+* minting / replacing one. `seen` spans parts so the first-occurrence rule is
+* document-wide across the scan order.
+*/
+const scanPart = (xml, partPath, context, seen) => {
+	const edits = [];
+	let assigned = 0;
+	let deduplicated = 0;
+	let ordinal = 0;
+	let fallbackDepth = 0;
+	let pos = 0;
+	while (pos < xml.length) {
+		const tagStart = xml.indexOf("<", pos);
+		if (tagStart === -1) break;
+		const opaqueEnd = skipOpaqueXmlRegion(xml, tagStart, partPath);
+		if (opaqueEnd !== null) {
+			pos = opaqueEnd;
+			continue;
+		}
+		if (xml.startsWith(FALLBACK_OPEN, tagStart) && isXmlNameBoundary(xml[tagStart + 12])) {
+			const tagEnd = xml.indexOf(">", tagStart);
+			if (tagEnd === -1) throw createEnsureParaIdsError(`Unterminated <mc:Fallback> tag in ${partPath}`);
+			if (xml[tagEnd - 1] !== "/") fallbackDepth += 1;
+			pos = tagEnd + 1;
+			continue;
+		}
+		if (xml.startsWith(FALLBACK_CLOSE, tagStart)) {
+			fallbackDepth = Math.max(0, fallbackDepth - 1);
+			pos = tagStart + 14;
+			continue;
+		}
+		if (!xml.startsWith(PARAGRAPH_OPEN, tagStart) || !isXmlNameBoundary(xml[tagStart + 4])) {
+			pos = tagStart + 1;
+			continue;
+		}
+		const tagEnd = xml.indexOf(">", tagStart);
+		if (tagEnd === -1) throw createEnsureParaIdsError(`Unterminated <w:p> tag in ${partPath}`);
+		pos = tagEnd + 1;
+		if (fallbackDepth > 0) continue;
+		ordinal += 1;
+		const openTag = xml.slice(tagStart, tagEnd + 1);
+		const paraIdMatch = OPEN_TAG_PARA_ID_PATTERN.exec(openTag);
+		if (!paraIdMatch) {
+			const id = mintParaId(context, partPath, ordinal);
+			const insertAt = tagStart + 4;
+			const textIdMatch = OPEN_TAG_TEXT_ID_PATTERN.exec(openTag);
+			if (textIdMatch) {
+				edits.push({
+					start: insertAt,
+					end: insertAt,
+					text: ` w14:paraId="${id}"`
+				});
+				const range = attributeValueRange(textIdMatch, tagStart, "id");
+				edits.push({
+					...range,
+					text: id
+				});
+			} else edits.push({
+				start: insertAt,
+				end: insertAt,
+				text: ` w14:paraId="${id}" w14:textId="${id}"`
+			});
+			assigned += 1;
+			seen.add(id);
+			continue;
+		}
+		const value = paraIdMatch.groups["id"].toUpperCase();
+		const unassigned = RESERVED_ZERO_ID_PATTERN.test(value);
+		if (!unassigned && !seen.has(value)) {
+			seen.add(value);
+			continue;
+		}
+		const id = mintParaId(context, partPath, ordinal);
+		edits.push({
+			...attributeValueRange(paraIdMatch, tagStart, "id"),
+			text: id
+		});
+		const textIdMatch = OPEN_TAG_TEXT_ID_PATTERN.exec(openTag);
+		if (textIdMatch) edits.push({
+			...attributeValueRange(textIdMatch, tagStart, "id"),
+			text: id
+		});
+		else {
+			const insertAt = tagStart + 4;
+			edits.push({
+				start: insertAt,
+				end: insertAt,
+				text: ` w14:textId="${id}"`
+			});
+		}
+		if (unassigned) assigned += 1;
+		else deduplicated += 1;
+		seen.add(id);
+	}
+	return {
+		edits,
+		assigned,
+		deduplicated
+	};
+};
+/**
+* Splice edits ensuring the part's root element declares `xmlns:w14` /
+* `xmlns:mc` and lists `w14` in `mc:Ignorable`, so consumers that predate the
+* 2010 extensions skip the new attributes instead of rejecting the part.
+*/
+const ensureRootNamespaces = (xml, partPath) => {
+	let pos = 0;
+	let rootStart = -1;
+	while (pos < xml.length) {
+		const lt = xml.indexOf("<", pos);
+		if (lt === -1) break;
+		const opaqueEnd = skipOpaqueXmlRegion(xml, lt, partPath);
+		if (opaqueEnd !== null) {
+			pos = opaqueEnd;
+			continue;
+		}
+		if (xml[lt + 1] === "!") {
+			const skipTo = xml.indexOf(">", lt);
+			if (skipTo === -1) throw createEnsureParaIdsError(`Unterminated prolog in ${partPath}`);
+			pos = skipTo + 1;
+			continue;
+		}
+		rootStart = lt;
+		break;
+	}
+	if (rootStart === -1) throw createEnsureParaIdsError(`No root element in ${partPath}`);
+	const rootEnd = xml.indexOf(">", rootStart);
+	if (rootEnd === -1) throw createEnsureParaIdsError(`Unterminated root element in ${partPath}`);
+	const rootTag = xml.slice(rootStart, rootEnd + 1);
+	const edits = [];
+	const declarations = [];
+	const mcNamespace = XMLNS_MC_PATTERN.exec(rootTag);
+	if (mcNamespace) {
+		if (mcNamespace.groups["value"] !== MC_NAMESPACE_URI) throw createEnsureParaIdsError(`xmlns:mc has an unexpected namespace URI in ${partPath}`);
+	} else declarations.push(` xmlns:mc="${MC_NAMESPACE_URI}"`);
+	const w14Namespace = XMLNS_W14_PATTERN.exec(rootTag);
+	if (w14Namespace) {
+		if (w14Namespace.groups["value"] !== W14_NAMESPACE_URI) throw createEnsureParaIdsError(`xmlns:w14 has an unexpected namespace URI in ${partPath}`);
+	} else declarations.push(` xmlns:w14="${W14_NAMESPACE_URI}"`);
+	const ignorable = MC_IGNORABLE_PATTERN.exec(rootTag);
+	if (ignorable) {
+		const tokens = ignorable.groups["value"].split(/\s+/u).filter((token) => token.length > 0);
+		if (!tokens.includes(MC_IGNORABLE_W14)) {
+			const { end } = attributeValueRange(ignorable, rootStart, "value");
+			const text = tokens.length === 0 ? MC_IGNORABLE_W14 : ` ${MC_IGNORABLE_W14}`;
+			edits.push({
+				start: end,
+				end,
+				text
+			});
+		}
+	} else declarations.push(` mc:Ignorable="${MC_IGNORABLE_W14}"`);
+	if (declarations.length > 0) {
+		let nameEnd = rootStart + 1;
+		while (nameEnd < xml.length && !isXmlNameBoundary(xml[nameEnd])) nameEnd += 1;
+		edits.push({
+			start: nameEnd,
+			end: nameEnd,
+			text: declarations.join("")
+		});
+	}
+	return edits;
+};
+/** OPC part names are case-insensitive; compare lowercased. */
+const isTargetPart = (path) => TARGET_PART_PATTERNS.some((pattern) => pattern.test(path.toLowerCase()));
+const toUint8Array = (docx) => docx instanceof Uint8Array ? docx : new Uint8Array(docx);
+const hasDigitalSignatureParts = (zip) => Object.values(zip.files).some(({ dir, name }) => !dir && name.toLowerCase().startsWith(DIGITAL_SIGNATURE_PART_PREFIX));
+/**
+* Backfill `w14:paraId` on every paragraph of a `.docx` buffer. See the
+* module doc for the exact contract. Throws {@link EnsureParaIdsError} when
+* the buffer is not a WordprocessingML package or a part is malformed.
+*/
+const ensureParaIdsInternal = async (docx, options) => {
+	const zip = await JSZip.loadAsync(docx);
+	const xmlPartNames = [];
+	zip.forEach((relativePath, entry) => {
+		const lower = relativePath.toLowerCase();
+		if (!entry.dir && lower.startsWith("word/") && lower.endsWith(".xml")) xmlPartNames.push(relativePath);
+	});
+	const documentPartName = xmlPartNames.find((name) => name.toLowerCase() === DOCUMENT_PART);
+	if (documentPartName === void 0) throw createEnsureParaIdsError("word/document.xml not found: not a WordprocessingML package");
+	const partTexts = /* @__PURE__ */ new Map();
+	for (const name of xmlPartNames) {
+		const entry = zip.file(name);
+		if (entry) partTexts.set(name, await entry.async("text"));
+	}
+	const taken = /* @__PURE__ */ new Set();
+	for (const text of partTexts.values()) collectExistingParaIds(text, taken);
+	const context = {
+		taken,
+		docKey: deterministicHexId(partTexts.get(documentPartName))
+	};
+	const targetParts = [documentPartName, ...xmlPartNames.filter((name) => name !== documentPartName && isTargetPart(name)).sort((a, b) => a.localeCompare(b))];
+	const seen = /* @__PURE__ */ new Set();
+	for (const [partPath, xml] of partTexts) if (isTargetPart(partPath)) collectFallbackParaIds(xml, partPath, seen);
+	else collectExistingParaIds(xml, seen);
+	const updates = /* @__PURE__ */ new Map();
+	let assigned = 0;
+	let deduplicated = 0;
+	for (const partPath of targetParts) {
+		const xml = partTexts.get(partPath);
+		const scan = scanPart(xml, partPath, context, seen);
+		if (scan.edits.length === 0) continue;
+		assigned += scan.assigned;
+		deduplicated += scan.deduplicated;
+		updates.set(partPath, applySplices(xml, [...scan.edits, ...ensureRootNamespaces(xml, partPath)]));
+	}
+	if (updates.size === 0) return {
+		docx: toUint8Array(docx),
+		assigned: 0,
+		deduplicated: 0,
+		alreadyComplete: true
+	};
+	if (hasDigitalSignatureParts(zip) && options.allowSignedPackageMutation !== true) throw createEnsureParaIdsError("Refusing to normalize a digitally signed package because rewriting OOXML invalidates its signatures. Warn the user and pass allowSignedPackageMutation only if invalidation is acceptable.");
+	for (const [partPath, content] of updates) zip.file(partPath, content, {
+		compression: "DEFLATE",
+		compressionOptions: { level: 6 }
+	});
+	return {
+		docx: await zip.generateAsync({
+			type: "uint8array",
+			compression: "DEFLATE",
+			compressionOptions: { level: 6 }
+		}),
+		assigned,
+		deduplicated,
+		alreadyComplete: false
+	};
+};
+/**
+* Backfill `w14:paraId` on every paragraph of a `.docx` buffer. All package,
+* XML, and compression failures are surfaced as {@link EnsureParaIdsError}.
+*/
+const ensureParaIds = async (docx, options = {}) => {
+	try {
+		return await ensureParaIdsInternal(docx, options);
+	} catch (error) {
+		if (error instanceof EnsureParaIdsError) throw error;
+		const message = error instanceof Error ? error.message : String(error);
+		throw createEnsureParaIdsError(`Failed to normalize paragraph IDs: ${message}`, error);
+	}
+};
+//#endregion
+export { EnsureParaIdsError, ensureParaIds };

package/dist/docx/fontTableParser.d.ts

@@ -0,0 +1,6 @@
+import { document_d_exports } from "../types/document.js";
+
+//#region src/docx/fontTableParser.d.ts
+declare const parseFontTable: (xml: string | null | undefined) => document_d_exports.FontTable | undefined;
+//#endregion
+export { parseFontTable };

package/dist/docx/fontTableParser.js

@@ -0,0 +1,72 @@
+import { findChild, findChildren, getAttribute, parseXmlDocument } from "./xmlParser.js";
+//#region src/docx/fontTableParser.ts
+const FONT_FAMILIES = [
+	"decorative",
+	"modern",
+	"roman",
+	"script",
+	"swiss",
+	"auto"
+];
+const FONT_PITCHES = [
+	"default",
+	"fixed",
+	"variable"
+];
+const parseFontTable = (xml) => {
+	if (!xml) return;
+	const root = parseXmlDocument(xml);
+	if (!root) return;
+	const fonts = [];
+	for (const element of findChildren(root, "w", "font")) {
+		const font = parseFont(element);
+		if (font) fonts.push(font);
+	}
+	return fonts.length > 0 ? { fonts } : void 0;
+};
+const parseFont = (element) => {
+	const name = getAttribute(element, "w", "name");
+	if (!name) return;
+	const font = { name };
+	assignValue(font, "altName", childValue(element, "altName"));
+	assignValue(font, "panose1", childValue(element, "panose1"));
+	assignValue(font, "charset", childValue(element, "charset"));
+	const family = childValue(element, "family");
+	if (family && isFontFamily(family)) font.family = family;
+	const pitch = childValue(element, "pitch");
+	if (pitch && isFontPitch(pitch)) font.pitch = pitch;
+	const sig = findChild(element, "w", "sig");
+	if (sig) {
+		const parsed = {};
+		assignSignatureValue(parsed, "usb0", getAttribute(sig, "w", "usb0") ?? void 0);
+		assignSignatureValue(parsed, "usb1", getAttribute(sig, "w", "usb1") ?? void 0);
+		assignSignatureValue(parsed, "usb2", getAttribute(sig, "w", "usb2") ?? void 0);
+		assignSignatureValue(parsed, "usb3", getAttribute(sig, "w", "usb3") ?? void 0);
+		assignSignatureValue(parsed, "csb0", getAttribute(sig, "w", "csb0") ?? void 0);
+		assignSignatureValue(parsed, "csb1", getAttribute(sig, "w", "csb1") ?? void 0);
+		if (Object.values(parsed).some((value) => value !== void 0)) font.sig = parsed;
+	}
+	assignValue(font, "embedRegular", relationshipId(element, "embedRegular"));
+	assignValue(font, "embedBold", relationshipId(element, "embedBold"));
+	assignValue(font, "embedItalic", relationshipId(element, "embedItalic"));
+	assignValue(font, "embedBoldItalic", relationshipId(element, "embedBoldItalic"));
+	return font;
+};
+const childValue = (element, name) => {
+	const child = findChild(element, "w", name);
+	return child ? getAttribute(child, "w", "val") ?? void 0 : void 0;
+};
+const relationshipId = (element, name) => {
+	const child = findChild(element, "w", name);
+	return child ? getAttribute(child, "r", "id") ?? void 0 : void 0;
+};
+const assignValue = (font, key, value) => {
+	if (value !== void 0) font[key] = value;
+};
+const assignSignatureValue = (signature, key, value) => {
+	if (value !== void 0) signature[key] = value;
+};
+const isFontFamily = (value) => FONT_FAMILIES.some((family) => family === value);
+const isFontPitch = (value) => FONT_PITCHES.some((pitch) => pitch === value);
+//#endregion
+export { parseFontTable };

package/dist/docx/groupDrawingParser.js

@@ -37,7 +37,10 @@ const colorFrom = (parent, fallback) => {
 		const value = getAttribute(parent, "w", "val");
 		if (value && HEX_COLOR.test(value)) return value.toUpperCase();
 	}
-	const value = getAttribute(findChildByLocalName(findChildByLocalName(parent, "solidFill"), "srgbClr"), null, "val");
+	if (findChildByLocalName(parent, "noFill")) return "none";
+	const srgb = findChildByLocalName(findChildByLocalName(parent, "solidFill"), "srgbClr");
+	const referencedSrgb = findChildByLocalName(parent, "srgbClr");
+	const value = getAttribute(srgb ?? referencedSrgb, null, "val");
 	if (value && HEX_COLOR.test(value)) return value.toUpperCase();
 	return fallback;
 };
@@ -80,9 +83,11 @@ const renderGeometry = (wsp) => {
 	const { x, y, width, height } = childTransform(wsp);
 	if (width <= 0 || height <= 0) return "";
 	const spPr = findChildByLocalName(wsp, "spPr");
+	const style = findChildByLocalName(wsp, "style");
+	const styleStroke = colorFrom(findChildByLocalName(style, "lnRef"), "none");
 	const fill = colorFrom(spPr, "none");
 	const line = findChildByLocalName(spPr, "ln");
-	const stroke = colorFrom(line, "none");
+	const stroke = colorFrom(line, styleStroke);
 	const strokeWidth = line ? parseNumericAttribute(line, null, "w") ?? DEFAULT_LINE_WIDTH_EMU : 0;
 	const paths = findAllDeep(findChildByLocalName(spPr, "custGeom"), "a", "path");
 	if (paths.length === 0) return `<rect x="${x}" y="${y}" width="${width}" height="${height}" fill="${fill === "none" ? "none" : `#${fill}`}" stroke="${stroke === "none" ? "none" : `#${stroke}`}" stroke-width="${strokeWidth}"/>`;

package/dist/docx/headerFooterParser.js

@@ -1,8 +1,8 @@
 import { collectXmlnsDeclarations, parseXml } from "./xmlParser.js";
 import { parseWatermark } from "./watermarkParser.js";
 import { parseFooterReference, parseFooterReferences, parseHeaderReference, parseHeaderReferences } from "./headerFooterRefParser.js";
-import { assignHeaderFooterVerbatimXml } from "./headerFooterVerbatim.js";
 import { parseBlockContent } from "./blockContentParser.js";
+import { assignHeaderFooterVerbatimXml } from "./headerFooterVerbatim.js";
 //#region src/docx/headerFooterParser.ts
 /**
 * Parse a header XML file (word/header*.xml)

package/dist/docx/normalizeBaseDirection.js

@@ -1,5 +1,5 @@
-import { detectBaseDirection } from "../utils/baseDirection.js";
 import { createStyleResolver } from "../prosemirror/styles/styleResolver.js";
+import { detectBaseDirection } from "../utils/baseDirection.js";
 //#region src/docx/normalizeBaseDirection.ts
 const runText = (run) => {
 	let text = "";

package/dist/docx/numberingParser.js

@@ -603,7 +603,9 @@ function computeListRendering(numPr, numbering) {
 	const markerFont = level.rPr?.fontFamily?.ascii || level.rPr?.fontFamily?.hAnsi;
 	if (markerFont) rendering.markerFontFamily = markerFont;
 	if (level.rPr?.fontSize) rendering.markerFontSize = level.rPr.fontSize / 2;
+	if (level.rPr?.bold !== void 0) rendering.markerBold = level.rPr.bold;
 	if (level.rPr?.allCaps) rendering.markerAllCaps = true;
+	if (level.lvlJc) rendering.markerAlignment = level.lvlJc;
 	if (level.suffix) rendering.markerSuffix = level.suffix;
 	if (instance?.abstractNumId !== void 0) rendering.abstractNumId = instance.abstractNumId;
 	if (overrideForLevel?.startOverride !== void 0) rendering.startOverride = overrideForLevel.startOverride;

package/dist/docx/paragraphParser.js

@@ -110,10 +110,18 @@ function parseTabStops(tabs) {
 function parseFrameProperties(framePr) {
 	if (!framePr) return;
 	const frame = {};
+	const dropCap = getAttribute(framePr, "w", "dropCap");
+	if (dropCap === "none" || dropCap === "drop" || dropCap === "margin") frame.dropCap = dropCap;
+	const lines = parseNumericAttribute(framePr, "w", "lines");
+	if (lines !== void 0) frame.lines = lines;
 	const w = parseNumericAttribute(framePr, "w", "w");
 	if (w !== void 0) frame.width = w;
 	const h = parseNumericAttribute(framePr, "w", "h");
 	if (h !== void 0) frame.height = h;
+	const hSpace = parseNumericAttribute(framePr, "w", "hSpace");
+	if (hSpace !== void 0) frame.hSpace = hSpace;
+	const vSpace = parseNumericAttribute(framePr, "w", "vSpace");
+	if (vSpace !== void 0) frame.vSpace = vSpace;
 	const hAnchor = getAttribute(framePr, "w", "hAnchor");
 	if (hAnchor === "text" || hAnchor === "margin" || hAnchor === "page") frame.hAnchor = hAnchor;
 	const vAnchor = getAttribute(framePr, "w", "vAnchor");
@@ -156,12 +164,18 @@ function collectFirstParagraphPropertyChildren(pPr) {
 			case "keepNext":
 				children.keepNext ??= child;
 				break;
+			case "kinsoku":
+				children.kinsoku ??= child;
+				break;
 			case "numPr":
 				children.numPr ??= child;
 				break;
 			case "outlineLvl":
 				children.outlineLvl ??= child;
 				break;
+			case "overflowPunct":
+				children.overflowPunct ??= child;
+				break;
 			case "pageBreakBefore":
 				children.pageBreakBefore ??= child;
 				break;
@@ -218,6 +232,10 @@ function parseParagraphProperties(pPr, theme, styles) {
 	if (!pPr) return;
 	const formatting = {};
 	const propertyChildren = collectFirstParagraphPropertyChildren(pPr);
+	const kinsoku = propertyChildren.kinsoku;
+	if (kinsoku) formatting.kinsoku = parseBooleanElement(kinsoku);
+	const overflowPunct = propertyChildren.overflowPunct;
+	if (overflowPunct) formatting.overflowPunctuation = parseBooleanElement(overflowPunct);
 	const jc = propertyChildren.jc;
 	if (jc) {
 		const val = narrowEnum(getAttribute(jc, "w", "val"), ParagraphAlignmentSchema);
@@ -517,7 +535,7 @@ function isTrackedChangeWrapperChild(content) {
 	return content.type === "run" || content.type === "hyperlink";
 }
 function isInlineSdtContent(content) {
-	return content.type === "run" || content.type === "hyperlink" || content.type === "simpleField" || content.type === "complexField" || content.type === "inlineSdt" || content.type === "mathEquation";
+	return content.type === "run" || content.type === "hyperlink" || content.type === "simpleField" || content.type === "complexField" || content.type === "inlineSdt" || content.type === "insertion" || content.type === "deletion" || content.type === "mathEquation";
 }
 function pushTrackedChangeWrapper({ contents, type, info, content, preserveEmpty = false }) {
 	if (content.length === 0 && !preserveEmpty) return;
@@ -973,7 +991,9 @@ function parseParagraph(node, styles, theme, numbering, rels = null, media = nul
 				const markerFont = level.rPr?.fontFamily?.ascii || level.rPr?.fontFamily?.hAnsi;
 				if (markerFont) listRendering.markerFontFamily = markerFont;
 				if (level.rPr?.fontSize) listRendering.markerFontSize = level.rPr.fontSize / 2;
+				if (level.rPr?.bold !== void 0) listRendering.markerBold = level.rPr.bold;
 				if (level.rPr?.allCaps) listRendering.markerAllCaps = true;
+				if (level.lvlJc) listRendering.markerAlignment = level.lvlJc;
 				if (level.suffix) listRendering.markerSuffix = level.suffix;
 				let implicitChildLevelAdvances = 0;
 				const foldedMarkerSuffix = [];