@stll/folio-core 0.0.1-placeholder.0 → 0.1.0

package/dist/docx/paragraphParser.js

@@ -0,0 +1,1132 @@
+import { elementToXml, findChild, findChildren, getAttribute, getChildElements, mergeXmlnsDeclarations, parseBooleanElement, parseNumericAttribute } from "./xmlParser.js";
+import { parseBookmarkEnd as parseBookmarkEnd$1, parseBookmarkStart as parseBookmarkStart$1 } from "./bookmarkParser.js";
+import { BorderStyleSchema, FrameWrapSchema, FrameXAlignSchema, FrameYAlignSchema, LineSpacingRuleSchema, ParagraphAlignmentSchema, ShadingPatternSchema, TabLeaderSchema, TabStopAlignmentSchema, ThemeColorSlotSchema, narrowEnum } from "./parserEnums.js";
+import { parseRun, parseRunProperties } from "./runParser.js";
+import { parseFieldType } from "./fieldParser.js";
+import { parseHyperlink as parseHyperlink$1 } from "./hyperlinkParser.js";
+import { consolidateParagraphContent } from "./runConsolidator.js";
+import { parseSdtProperties } from "./sdtProperties.js";
+import { parseSectionProperties } from "./sectionParser.js";
+//#region src/docx/paragraphParser.ts
+/**
+* Extract plain text from a math element (recursive text content extraction)
+*/
+function extractPlainText(runs) {
+	let out = "";
+	for (const run of runs) for (const c of run.content) if (c.type === "text") out += c.text;
+	return out;
+}
+function extractMathText(el) {
+	let text = "";
+	if (el.type === "text" && typeof el.text === "string") return el.text;
+	if (el.elements) for (const child of el.elements) if ((child.name?.replace(/^.*:/u, "") ?? "") === "t" && child.elements) {
+		for (const t of child.elements) if (t.type === "text" && typeof t.text === "string") text += t.text;
+	} else text += extractMathText(child);
+	return text;
+}
+/**
+* Parse color value from attributes
+*/
+function parseColorValue(rgb, themeColor, themeTint, themeShade) {
+	const color = {};
+	if (rgb && rgb !== "auto") color.rgb = rgb;
+	else if (rgb === "auto") color.auto = true;
+	const validatedThemeColor = narrowEnum(themeColor, ThemeColorSlotSchema);
+	if (validatedThemeColor) color.themeColor = validatedThemeColor;
+	if (themeTint) color.themeTint = themeTint;
+	if (themeShade) color.themeShade = themeShade;
+	return color;
+}
+/**
+* Parse shading properties (w:shd)
+*/
+function parseShadingProperties(shd) {
+	if (!shd) return;
+	const props = {};
+	const color = getAttribute(shd, "w", "color");
+	if (color && color !== "auto") props.color = { rgb: color };
+	const fill = getAttribute(shd, "w", "fill");
+	if (fill && fill !== "auto") props.fill = { rgb: fill };
+	const validatedThemeFill = narrowEnum(getAttribute(shd, "w", "themeFill"), ThemeColorSlotSchema);
+	if (validatedThemeFill) {
+		props.fill = props.fill || {};
+		props.fill.themeColor = validatedThemeFill;
+	}
+	const themeFillTint = getAttribute(shd, "w", "themeFillTint");
+	if (themeFillTint && props.fill) props.fill.themeTint = themeFillTint;
+	const themeFillShade = getAttribute(shd, "w", "themeFillShade");
+	if (themeFillShade && props.fill) props.fill.themeShade = themeFillShade;
+	const pattern = narrowEnum(getAttribute(shd, "w", "val"), ShadingPatternSchema);
+	if (pattern) props.pattern = pattern;
+	return Object.keys(props).length > 0 ? props : void 0;
+}
+/**
+* Parse border specification (w:top, w:bottom, w:left, w:right, etc.)
+*/
+function parseBorderSpec(border) {
+	if (!border) return;
+	const rawStyle = getAttribute(border, "w", "val");
+	if (!rawStyle) return;
+	const spec = { style: narrowEnum(rawStyle, BorderStyleSchema) ?? rawStyle };
+	const colorVal = getAttribute(border, "w", "color");
+	const themeColor = getAttribute(border, "w", "themeColor");
+	if (colorVal || themeColor) spec.color = parseColorValue(colorVal, themeColor, getAttribute(border, "w", "themeTint"), getAttribute(border, "w", "themeShade"));
+	const sz = parseNumericAttribute(border, "w", "sz");
+	if (sz !== void 0) spec.size = sz;
+	const space = parseNumericAttribute(border, "w", "space");
+	if (space !== void 0) spec.space = space;
+	const shadowAttr = getAttribute(border, "w", "shadow");
+	if (shadowAttr) spec.shadow = shadowAttr === "1" || shadowAttr === "true";
+	const frame = getAttribute(border, "w", "frame");
+	if (frame) spec.frame = frame === "1" || frame === "true";
+	return spec;
+}
+/**
+* Parse tab stops (w:tabs)
+*/
+function parseTabStops(tabs) {
+	if (!tabs) return;
+	const tabElements = findChildren(tabs, "w", "tab");
+	if (tabElements.length === 0) return;
+	const result = [];
+	for (const tab of tabElements) {
+		const pos = parseNumericAttribute(tab, "w", "pos");
+		const alignment = narrowEnum(getAttribute(tab, "w", "val"), TabStopAlignmentSchema);
+		if (pos !== void 0 && alignment) {
+			const tabStop = {
+				position: pos,
+				alignment
+			};
+			const leader = narrowEnum(getAttribute(tab, "w", "leader"), TabLeaderSchema);
+			if (leader) tabStop.leader = leader;
+			result.push(tabStop);
+		}
+	}
+	return result.length > 0 ? result : void 0;
+}
+/**
+* Parse frame properties (w:framePr)
+*/
+function parseFrameProperties(framePr) {
+	if (!framePr) return;
+	const frame = {};
+	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 hAnchor = getAttribute(framePr, "w", "hAnchor");
+	if (hAnchor === "text" || hAnchor === "margin" || hAnchor === "page") frame.hAnchor = hAnchor;
+	const vAnchor = getAttribute(framePr, "w", "vAnchor");
+	if (vAnchor === "text" || vAnchor === "margin" || vAnchor === "page") frame.vAnchor = vAnchor;
+	const x = parseNumericAttribute(framePr, "w", "x");
+	if (x !== void 0) frame.x = x;
+	const y = parseNumericAttribute(framePr, "w", "y");
+	if (y !== void 0) frame.y = y;
+	const xAlign = narrowEnum(getAttribute(framePr, "w", "xAlign"), FrameXAlignSchema);
+	if (xAlign) frame.xAlign = xAlign;
+	const yAlign = narrowEnum(getAttribute(framePr, "w", "yAlign"), FrameYAlignSchema);
+	if (yAlign) frame.yAlign = yAlign;
+	const wrap = narrowEnum(getAttribute(framePr, "w", "wrap"), FrameWrapSchema);
+	if (wrap) frame.wrap = wrap;
+	return Object.keys(frame).length > 0 ? frame : void 0;
+}
+function collectFirstParagraphPropertyChildren(pPr) {
+	const children = {};
+	for (const child of pPr.elements ?? []) {
+		if (child.type !== "element") continue;
+		switch (getLocalName(child.name)) {
+			case "bidi":
+				children.bidi ??= child;
+				break;
+			case "contextualSpacing":
+				children.contextualSpacing ??= child;
+				break;
+			case "framePr":
+				children.framePr ??= child;
+				break;
+			case "ind":
+				children.ind ??= child;
+				break;
+			case "jc":
+				children.jc ??= child;
+				break;
+			case "keepLines":
+				children.keepLines ??= child;
+				break;
+			case "keepNext":
+				children.keepNext ??= child;
+				break;
+			case "numPr":
+				children.numPr ??= child;
+				break;
+			case "outlineLvl":
+				children.outlineLvl ??= child;
+				break;
+			case "pageBreakBefore":
+				children.pageBreakBefore ??= child;
+				break;
+			case "pBdr":
+				children.pBdr ??= child;
+				break;
+			case "pStyle":
+				children.pStyle ??= child;
+				break;
+			case "rPr":
+				children.rPr ??= child;
+				break;
+			case "shd":
+				children.shd ??= child;
+				break;
+			case "spacing":
+				children.spacing ??= child;
+				break;
+			case "suppressAutoHyphens":
+				children.suppressAutoHyphens ??= child;
+				break;
+			case "suppressLineNumbers":
+				children.suppressLineNumbers ??= child;
+				break;
+			case "tabs":
+				children.tabs ??= child;
+				break;
+			case "widowControl":
+				children.widowControl ??= child;
+				break;
+		}
+	}
+	return children;
+}
+/**
+* Parse paragraph formatting properties (w:pPr)
+*
+* Handles ALL pPr properties:
+* - w:jc (alignment: left, center, right, both/justify)
+* - w:spacing (before, after, line, lineRule)
+* - w:ind (left, right, firstLine, hanging)
+* - w:pBdr (paragraph borders: top, bottom, left, right, between)
+* - w:shd (paragraph shading/background)
+* - w:tabs (tab stops with positions and types)
+* - w:keepNext, w:keepLines, w:widowControl, w:pageBreakBefore
+* - w:bidi (right-to-left)
+* - w:numPr (list info)
+* - w:pStyle (style reference)
+* - w:outlineLvl (outline level)
+* - w:framePr (frame properties)
+* - w:rPr (default run properties)
+*/
+function parseParagraphProperties(pPr, theme, styles) {
+	if (!pPr) return;
+	const formatting = {};
+	const propertyChildren = collectFirstParagraphPropertyChildren(pPr);
+	const jc = propertyChildren.jc;
+	if (jc) {
+		const val = narrowEnum(getAttribute(jc, "w", "val"), ParagraphAlignmentSchema);
+		if (val) formatting.alignment = val;
+	}
+	const bidi = propertyChildren.bidi;
+	if (bidi) formatting.bidi = parseBooleanElement(bidi);
+	const spacing = propertyChildren.spacing;
+	if (spacing) {
+		const before = parseNumericAttribute(spacing, "w", "before");
+		if (before !== void 0) formatting.spaceBefore = before;
+		const after = parseNumericAttribute(spacing, "w", "after");
+		if (after !== void 0) formatting.spaceAfter = after;
+		const line = parseNumericAttribute(spacing, "w", "line");
+		if (line !== void 0) formatting.lineSpacing = line;
+		const spacingExplicit = {};
+		if (before !== void 0) spacingExplicit.before = true;
+		if (after !== void 0) spacingExplicit.after = true;
+		if (spacingExplicit.before || spacingExplicit.after) formatting.spacingExplicit = spacingExplicit;
+		const lineRule = narrowEnum(getAttribute(spacing, "w", "lineRule"), LineSpacingRuleSchema);
+		if (lineRule) formatting.lineSpacingRule = lineRule;
+		const beforeAuto = getAttribute(spacing, "w", "beforeAutospacing");
+		if (beforeAuto) formatting.beforeAutospacing = beforeAuto === "1" || beforeAuto === "true";
+		const afterAuto = getAttribute(spacing, "w", "afterAutospacing");
+		if (afterAuto) formatting.afterAutospacing = afterAuto === "1" || afterAuto === "true";
+	}
+	const ind = propertyChildren.ind;
+	if (ind) {
+		const left = parseNumericAttribute(ind, "w", "left");
+		if (left !== void 0) formatting.indentLeft = left;
+		const right = parseNumericAttribute(ind, "w", "right");
+		if (right !== void 0) formatting.indentRight = right;
+		const firstLine = parseNumericAttribute(ind, "w", "firstLine");
+		if (firstLine !== void 0) formatting.indentFirstLine = firstLine;
+		const hanging = parseNumericAttribute(ind, "w", "hanging");
+		if (hanging !== void 0) {
+			formatting.indentFirstLine = -hanging;
+			formatting.hangingIndent = true;
+		}
+		const start = parseNumericAttribute(ind, "w", "start");
+		if (start !== void 0 && formatting.indentLeft === void 0) formatting.indentLeft = start;
+		const end = parseNumericAttribute(ind, "w", "end");
+		if (end !== void 0 && formatting.indentRight === void 0) formatting.indentRight = end;
+	}
+	const pBdr = propertyChildren.pBdr;
+	if (pBdr) {
+		const borders = {};
+		const top = parseBorderSpec(findChild(pBdr, "w", "top"));
+		if (top) borders.top = top;
+		const bottom = parseBorderSpec(findChild(pBdr, "w", "bottom"));
+		if (bottom) borders.bottom = bottom;
+		const left = parseBorderSpec(findChild(pBdr, "w", "left"));
+		if (left) borders.left = left;
+		const right = parseBorderSpec(findChild(pBdr, "w", "right"));
+		if (right) borders.right = right;
+		const between = parseBorderSpec(findChild(pBdr, "w", "between"));
+		if (between) borders.between = between;
+		const bar = parseBorderSpec(findChild(pBdr, "w", "bar"));
+		if (bar) borders.bar = bar;
+		if (Object.keys(borders).length > 0) formatting.borders = borders;
+	}
+	const shd = propertyChildren.shd;
+	if (shd) {
+		const shadingResult = parseShadingProperties(shd);
+		if (shadingResult !== void 0) formatting.shading = shadingResult;
+	}
+	const tabs = propertyChildren.tabs;
+	if (tabs) {
+		const tabsResult = parseTabStops(tabs);
+		if (tabsResult !== void 0) formatting.tabs = tabsResult;
+	}
+	const keepNext = propertyChildren.keepNext;
+	if (keepNext) formatting.keepNext = parseBooleanElement(keepNext);
+	const keepLines = propertyChildren.keepLines;
+	if (keepLines) formatting.keepLines = parseBooleanElement(keepLines);
+	const widowControl = propertyChildren.widowControl;
+	if (widowControl) formatting.widowControl = parseBooleanElement(widowControl);
+	const pageBreakBefore = propertyChildren.pageBreakBefore;
+	if (pageBreakBefore) formatting.pageBreakBefore = parseBooleanElement(pageBreakBefore);
+	const contextualSpacing = propertyChildren.contextualSpacing;
+	if (contextualSpacing) formatting.contextualSpacing = parseBooleanElement(contextualSpacing);
+	const numPr = propertyChildren.numPr;
+	if (numPr) {
+		const numIdEl = findChild(numPr, "w", "numId");
+		const ilvlEl = findChild(numPr, "w", "ilvl");
+		if (numIdEl || ilvlEl) {
+			formatting.numPr = {};
+			if (numIdEl) {
+				const val = parseNumericAttribute(numIdEl, "w", "val");
+				if (val !== void 0) formatting.numPr.numId = val;
+			}
+			if (ilvlEl) {
+				const val = parseNumericAttribute(ilvlEl, "w", "val");
+				if (val !== void 0) formatting.numPr.ilvl = val;
+			}
+		}
+	}
+	const outlineLvl = propertyChildren.outlineLvl;
+	if (outlineLvl) {
+		const val = parseNumericAttribute(outlineLvl, "w", "val");
+		if (val !== void 0) formatting.outlineLevel = val;
+	}
+	const pStyle = propertyChildren.pStyle;
+	if (pStyle) {
+		const val = getAttribute(pStyle, "w", "val");
+		if (val) formatting.styleId = val;
+	}
+	const framePr = propertyChildren.framePr;
+	if (framePr) {
+		const frameResult = parseFrameProperties(framePr);
+		if (frameResult !== void 0) formatting.frame = frameResult;
+	}
+	const suppressLineNumbers = propertyChildren.suppressLineNumbers;
+	if (suppressLineNumbers) formatting.suppressLineNumbers = parseBooleanElement(suppressLineNumbers);
+	const suppressAutoHyphens = propertyChildren.suppressAutoHyphens;
+	if (suppressAutoHyphens) formatting.suppressAutoHyphens = parseBooleanElement(suppressAutoHyphens);
+	const rPr = propertyChildren.rPr;
+	if (rPr) {
+		const runPropsResult = parseRunProperties(rPr, theme, styles);
+		if (runPropsResult !== void 0) formatting.runProperties = runPropsResult;
+		const specVanish = findChild(rPr, "w", "specVanish");
+		if (specVanish && parseBooleanElement(specVanish)) formatting.runInWithNext = true;
+	}
+	return Object.keys(formatting).length > 0 ? formatting : void 0;
+}
+/**
+* Get the local name of an element (without namespace prefix)
+*/
+function getLocalName(name) {
+	if (!name) return "";
+	const colonIndex = name.indexOf(":");
+	return colonIndex !== -1 ? name.slice(colonIndex + 1) : name;
+}
+function paragraphStartsWithRenderedPageBreak(node) {
+	const inlineWrappers = /* @__PURE__ */ new Set([
+		"hyperlink",
+		"smartTag",
+		"sdt",
+		"sdtContent",
+		"fldSimple",
+		"customXml",
+		"ins",
+		"del",
+		"moveFrom",
+		"moveTo"
+	]);
+	const nonContentMarkers = /* @__PURE__ */ new Set([
+		"pPr",
+		"proofErr",
+		"bookmarkStart",
+		"bookmarkEnd",
+		"commentRangeStart",
+		"commentRangeEnd",
+		"commentReference",
+		"permStart",
+		"permEnd",
+		"rsidR"
+	]);
+	const visibleRunContent = /* @__PURE__ */ new Set([
+		"t",
+		"tab",
+		"br",
+		"cr",
+		"sym",
+		"drawing",
+		"pict",
+		"object",
+		"softHyphen",
+		"noBreakHyphen",
+		"fldChar",
+		"instrText",
+		"pgNum",
+		"separator",
+		"continuationSeparator",
+		"footnoteRef",
+		"endnoteRef",
+		"footnoteReference",
+		"endnoteReference",
+		"ptab",
+		"monthShort",
+		"monthLong",
+		"yearShort",
+		"yearLong",
+		"dayShort",
+		"dayLong"
+	]);
+	let sawRenderedPageBreak = false;
+	const visit = (element) => {
+		for (const child of getChildElements(element)) {
+			const childName = getLocalName(child.name);
+			if (nonContentMarkers.has(childName)) continue;
+			if (childName === "lastRenderedPageBreak") {
+				sawRenderedPageBreak = true;
+				continue;
+			}
+			if (childName === "r") {
+				for (const runChild of getChildElements(child)) {
+					const runChildName = getLocalName(runChild.name);
+					if (runChildName === "rPr") continue;
+					if (runChildName === "lastRenderedPageBreak") {
+						sawRenderedPageBreak = true;
+						continue;
+					}
+					if (runChildName === "br" && getAttribute(runChild, "w", "type") === "page") return "forced";
+					if (visibleRunContent.has(runChildName)) return "visible";
+				}
+				continue;
+			}
+			if (inlineWrappers.has(childName)) {
+				const result = visit(child);
+				if (result !== "continue") return result;
+				continue;
+			}
+			return "continue";
+		}
+		return "continue";
+	};
+	const outcome = visit(node);
+	if (outcome === "forced") return true;
+	return outcome === "visible" && sawRenderedPageBreak;
+}
+function replaceLocalName(name, localName) {
+	if (!name) return `w:${localName}`;
+	const colonIndex = name.indexOf(":");
+	if (colonIndex === -1) return localName;
+	return `${name.slice(0, colonIndex + 1)}${localName}`;
+}
+function normalizeDeletionContentElement(node) {
+	if (node.type !== "element") return node;
+	const localName = getLocalName(node.name);
+	let mappedName = node.name;
+	if (localName === "delText") mappedName = replaceLocalName(node.name, "t");
+	else if (localName === "delInstrText") mappedName = replaceLocalName(node.name, "instrText");
+	const result = { ...node };
+	if (mappedName !== void 0) result.name = mappedName;
+	if (node.elements) result.elements = node.elements.map(normalizeDeletionContentElement);
+	return result;
+}
+function parseTrackedChangeInfo(node) {
+	const rawId = getAttribute(node, "w", "id");
+	const parsedId = rawId ? Number.parseInt(rawId, 10) : 0;
+	const rawAuthor = getAttribute(node, "w", "author");
+	const rawDate = getAttribute(node, "w", "date");
+	const author = rawAuthor?.trim() ?? "";
+	const date = rawDate?.trim() ?? "";
+	const info = {
+		id: Number.isInteger(parsedId) && parsedId >= 0 ? parsedId : 0,
+		author: author.length > 0 ? author : "Unknown"
+	};
+	if (date.length > 0) info.date = date;
+	return info;
+}
+function parsePropertyChangeInfo(node) {
+	const base = parseTrackedChangeInfo(node);
+	const rsid = (getAttribute(node, "w", "rsid") ?? "").trim();
+	return rsid.length > 0 ? {
+		...base,
+		rsid
+	} : base;
+}
+function parseParagraphPropertyChanges(pPr, theme, styles, currentFormatting) {
+	if (!pPr) return;
+	const changes = findChildren(pPr, "w", "pPrChange").map((changeElement) => {
+		const previousFormatting = parseParagraphProperties(findChild(changeElement, "w", "pPr"), theme, styles ?? void 0);
+		const change = {
+			type: "paragraphPropertyChange",
+			info: parsePropertyChangeInfo(changeElement)
+		};
+		if (previousFormatting !== void 0) change.previousFormatting = previousFormatting;
+		if (currentFormatting !== void 0) change.currentFormatting = currentFormatting;
+		return change;
+	}).filter((change) => change.previousFormatting || change.currentFormatting);
+	return changes.length > 0 ? changes : void 0;
+}
+/**
+* Parse `<w:pPr><w:rPr><w:ins/>` or `<w:del/>` — the OOXML paragraph-mark
+* tracked-change marker (ECMA-376 §17.13.5). Returns the first marker
+* encountered, or undefined when none is present. `ins` and `del` are
+* mutually exclusive in valid documents.
+*/
+function parseParagraphMarkChange(pPr) {
+	if (!pPr) return;
+	const rPr = findChild(pPr, "w", "rPr");
+	if (!rPr) return;
+	const ins = findChild(rPr, "w", "ins");
+	if (ins) return {
+		kind: "ins",
+		info: parseTrackedChangeInfo(ins)
+	};
+	const del = findChild(rPr, "w", "del");
+	if (del) return {
+		kind: "del",
+		info: parseTrackedChangeInfo(del)
+	};
+}
+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";
+}
+function pushTrackedChangeWrapper({ contents, type, info, content, preserveEmpty = false }) {
+	if (content.length === 0 && !preserveEmpty) return;
+	if (type === "insertion") {
+		contents.push({
+			type: "insertion",
+			info,
+			content: [...content]
+		});
+		return;
+	}
+	if (type === "deletion") {
+		contents.push({
+			type: "deletion",
+			info,
+			content: [...content]
+		});
+		return;
+	}
+	if (type === "moveFrom") {
+		contents.push({
+			type: "moveFrom",
+			info,
+			content: [...content]
+		});
+		return;
+	}
+	contents.push({
+		type: "moveTo",
+		info,
+		content: [...content]
+	});
+}
+function pushTrackedChangeSegments({ contents, type, info, parsedContent }) {
+	if (!parsedContent.some(isTrackedChangeWrapperChild)) {
+		pushTrackedChangeWrapper({
+			contents,
+			type,
+			info,
+			content: [],
+			preserveEmpty: true
+		});
+		contents.push(...parsedContent);
+		return;
+	}
+	const segment = [];
+	for (const content of parsedContent) {
+		if (isTrackedChangeWrapperChild(content)) {
+			segment.push(content);
+			continue;
+		}
+		pushTrackedChangeWrapper({
+			contents,
+			type,
+			info,
+			content: segment
+		});
+		segment.length = 0;
+		contents.push(content);
+	}
+	pushTrackedChangeWrapper({
+		contents,
+		type,
+		info,
+		content: segment
+	});
+}
+function pushInlineSdtSegments({ contents, properties, parsedContent }) {
+	if (!parsedContent.some(isInlineSdtContent)) {
+		contents.push({
+			type: "inlineSdt",
+			properties,
+			content: []
+		});
+		contents.push(...parsedContent);
+		return;
+	}
+	const segment = [];
+	const pushSegment = () => {
+		if (segment.length === 0) return;
+		contents.push({
+			type: "inlineSdt",
+			properties,
+			content: [...segment]
+		});
+		segment.length = 0;
+	};
+	for (const content of parsedContent) {
+		if (isInlineSdtContent(content)) {
+			segment.push(content);
+			continue;
+		}
+		pushSegment();
+		contents.push(content);
+	}
+	pushSegment();
+}
+/**
+* Parse hyperlink element (w:hyperlink)
+*
+* Delegates to hyperlinkParser module which resolves URLs via relationships.
+*/
+function parseHyperlink(node, rels, styles, theme, media, rootXmlns = {}) {
+	return parseHyperlink$1(node, rels, styles, theme, media, rootXmlns);
+}
+/**
+* Parse bookmark start (w:bookmarkStart)
+* Delegates to bookmarkParser module.
+*/
+function parseBookmarkStart(node) {
+	return parseBookmarkStart$1(node);
+}
+/**
+* Parse bookmark end (w:bookmarkEnd)
+* Delegates to bookmarkParser module.
+*/
+function parseBookmarkEnd(node) {
+	return parseBookmarkEnd$1(node);
+}
+/**
+* Parse simple field (w:fldSimple)
+*/
+function parseSimpleField(node, styles, theme, rels, media, rootXmlns = {}) {
+	const instruction = getAttribute(node, "w", "instr") ?? "";
+	const field = {
+		type: "simpleField",
+		instruction,
+		fieldType: parseFieldType(instruction),
+		content: []
+	};
+	const fldLock = getAttribute(node, "w", "fldLock");
+	if (fldLock === "1" || fldLock === "true") field.fldLock = true;
+	const dirty = getAttribute(node, "w", "dirty");
+	if (dirty === "1" || dirty === "true") field.dirty = true;
+	const inScopeXmlns = mergeXmlnsDeclarations(rootXmlns, node);
+	const children = getChildElements(node);
+	for (const child of children) if (getLocalName(child.name) === "r") field.content.push(parseRun(child, styles, theme, rels, media, inScopeXmlns));
+	return field;
+}
+/**
+* Parse all content within a paragraph
+*
+* Returns the parsed content and any complex fields that span multiple runs
+*/
+function parseParagraphContents(paraElement, styles, theme, _numbering, rels, media, trackedContext = "default", rootXmlns = {}) {
+	const contents = [];
+	const children = getChildElements(paraElement);
+	const inScopeXmlns = mergeXmlnsDeclarations(rootXmlns, paraElement);
+	let inComplexField = false;
+	let complexFieldInstr = "";
+	let complexFieldCodeRuns = [];
+	let complexFieldResultRuns = [];
+	let afterSeparator = false;
+	let complexFieldLock = false;
+	let complexFieldDirty = false;
+	let complexFieldFormatting;
+	for (const child of children) {
+		const localName = getLocalName(child.name);
+		switch (localName) {
+			case "r": {
+				const runElement = trackedContext === "deletion" ? normalizeDeletionContentElement(child) : child;
+				const run = parseRun(runElement, styles, theme, rels, media, inScopeXmlns);
+				const commentReferenceId = getCommentReferenceId(runElement);
+				let hasFieldBegin = false;
+				let hasFieldSeparate = false;
+				let hasFieldEnd = false;
+				let endOriginalValue;
+				let instrText = "";
+				for (const content of run.content) if (content.type === "fieldChar") if (content.charType === "begin") {
+					hasFieldBegin = true;
+					if (content.fldLock) complexFieldLock = true;
+					if (content.dirty) complexFieldDirty = true;
+				} else if (content.charType === "separate") hasFieldSeparate = true;
+				else {
+					hasFieldEnd = true;
+					if (content.originalValue !== void 0) endOriginalValue = content.originalValue;
+				}
+				else if (content.type === "instrText") instrText += content.text;
+				if (hasFieldBegin) {
+					if (inComplexField && afterSeparator) {
+						contents.push(...complexFieldResultRuns);
+						inComplexField = false;
+					}
+					inComplexField = true;
+					afterSeparator = false;
+					complexFieldInstr = "";
+					complexFieldCodeRuns = [];
+					complexFieldResultRuns = [];
+					complexFieldLock = false;
+					complexFieldDirty = false;
+					complexFieldFormatting = run.formatting;
+				}
+				if (inComplexField) {
+					if (instrText) complexFieldInstr += instrText;
+					if ((!complexFieldFormatting || Object.keys(complexFieldFormatting).length === 0) && run.formatting && Object.keys(run.formatting).length > 0) complexFieldFormatting = run.formatting;
+					if (hasFieldSeparate) afterSeparator = true;
+					if (afterSeparator && !hasFieldEnd) {
+						if (!hasFieldSeparate) complexFieldResultRuns.push(run);
+					} else if (!afterSeparator && !hasFieldBegin) complexFieldCodeRuns.push(run);
+					if (hasFieldEnd) {
+						let resultRuns = complexFieldResultRuns;
+						if (resultRuns.length === 0 && !afterSeparator && endOriginalValue !== void 0) resultRuns = [{
+							type: "run",
+							content: [{
+								type: "text",
+								text: endOriginalValue
+							}]
+						}];
+						const complexField = {
+							type: "complexField",
+							instruction: complexFieldInstr.trim(),
+							fieldType: parseFieldType(complexFieldInstr),
+							fieldCode: complexFieldCodeRuns,
+							fieldResult: resultRuns
+						};
+						if (complexFieldLock) complexField.fldLock = true;
+						if (complexFieldDirty) complexField.dirty = true;
+						if (complexFieldFormatting) complexField.formatting = complexFieldFormatting;
+						contents.push(complexField);
+						if (commentReferenceId !== null) contents.push({
+							type: "commentReference",
+							id: commentReferenceId
+						});
+						inComplexField = false;
+					}
+				} else if (commentReferenceId !== null) {
+					if (run.content.length > 0) contents.push(run);
+					contents.push({
+						type: "commentReference",
+						id: commentReferenceId
+					});
+				} else contents.push(run);
+				break;
+			}
+			case "hyperlink":
+				contents.push(parseHyperlink(child, rels, styles, theme, media, inScopeXmlns));
+				break;
+			case "bookmarkStart":
+				contents.push(parseBookmarkStart(child));
+				break;
+			case "bookmarkEnd":
+				contents.push(parseBookmarkEnd(child));
+				break;
+			case "fldSimple":
+				contents.push(parseSimpleField(child, styles, theme, rels, media, inScopeXmlns));
+				break;
+			case "pPr": break;
+			case "proofErr":
+			case "permStart":
+			case "permEnd":
+			case "customXml": break;
+			case "sdt": {
+				const sdtPr = findChild(child, "w", "sdtPr");
+				const sdtEndPr = findChild(child, "w", "sdtEndPr");
+				const sdtContentEl = findChild(child, "w", "sdtContent");
+				if (sdtContentEl) {
+					const sdtParsed = parseParagraphContents(sdtContentEl, styles, theme, null, rels, media, trackedContext, mergeXmlnsDeclarations(inScopeXmlns, child));
+					pushInlineSdtSegments({
+						contents,
+						properties: parseSdtProperties(sdtPr, sdtEndPr),
+						parsedContent: sdtParsed
+					});
+				}
+				break;
+			}
+			case "ins":
+				pushTrackedChangeSegments({
+					contents,
+					type: "insertion",
+					info: parseTrackedChangeInfo(child),
+					parsedContent: parseParagraphContents(child, styles, theme, null, rels, media, "default", inScopeXmlns)
+				});
+				break;
+			case "del":
+				pushTrackedChangeSegments({
+					contents,
+					type: "deletion",
+					info: parseTrackedChangeInfo(child),
+					parsedContent: parseParagraphContents(child, styles, theme, null, rels, media, "deletion", inScopeXmlns)
+				});
+				break;
+			case "moveFrom":
+				pushTrackedChangeSegments({
+					contents,
+					type: "moveFrom",
+					info: parseTrackedChangeInfo(child),
+					parsedContent: parseParagraphContents(child, styles, theme, null, rels, media, "deletion", inScopeXmlns)
+				});
+				break;
+			case "moveTo":
+				pushTrackedChangeSegments({
+					contents,
+					type: "moveTo",
+					info: parseTrackedChangeInfo(child),
+					parsedContent: parseParagraphContents(child, styles, theme, null, rels, media, "default", inScopeXmlns)
+				});
+				break;
+			case "smartTag": break;
+			case "moveFromRangeStart": {
+				const id = Number.parseInt(getAttribute(child, "w", "id") ?? "0", 10);
+				const name = getAttribute(child, "w", "name") ?? "";
+				contents.push({
+					type: "moveFromRangeStart",
+					id,
+					name
+				});
+				break;
+			}
+			case "moveFromRangeEnd": {
+				const id = Number.parseInt(getAttribute(child, "w", "id") ?? "0", 10);
+				contents.push({
+					type: "moveFromRangeEnd",
+					id
+				});
+				break;
+			}
+			case "moveToRangeStart": {
+				const id = Number.parseInt(getAttribute(child, "w", "id") ?? "0", 10);
+				const name = getAttribute(child, "w", "name") ?? "";
+				contents.push({
+					type: "moveToRangeStart",
+					id,
+					name
+				});
+				break;
+			}
+			case "moveToRangeEnd": {
+				const id = Number.parseInt(getAttribute(child, "w", "id") ?? "0", 10);
+				contents.push({
+					type: "moveToRangeEnd",
+					id
+				});
+				break;
+			}
+			case "commentRangeStart": {
+				const commentId = Number.parseInt(getAttribute(child, "w", "id") ?? "0", 10);
+				contents.push({
+					type: "commentRangeStart",
+					id: commentId
+				});
+				break;
+			}
+			case "commentRangeEnd": {
+				const commentId = Number.parseInt(getAttribute(child, "w", "id") ?? "0", 10);
+				contents.push({
+					type: "commentRangeEnd",
+					id: commentId
+				});
+				break;
+			}
+			case "oMath":
+			case "oMathPara": {
+				const isBlock = localName === "oMathPara";
+				const ommlXml = elementToXml(child);
+				const plainText = extractMathText(child);
+				const mathEq = {
+					type: "mathEquation",
+					display: isBlock ? "block" : "inline",
+					ommlXml
+				};
+				if (plainText) mathEq.plainText = plainText;
+				contents.push(mathEq);
+				break;
+			}
+			default: break;
+		}
+	}
+	if (inComplexField && afterSeparator) contents.push(...complexFieldResultRuns);
+	return contents;
+}
+function getCommentReferenceId(runElement) {
+	const commentReference = findChild(runElement, "w", "commentReference");
+	if (!commentReference) return null;
+	const id = Number.parseInt(getAttribute(commentReference, "w", "id") ?? "", 10);
+	return Number.isFinite(id) ? id : null;
+}
+/**
+* Parse a paragraph element (w:p)
+*
+* @param node - The w:p XML element
+* @param styles - Style map for resolving style references
+* @param theme - Theme for resolving theme colors/fonts
+* @param numbering - Numbering definitions for list info
+* @param rels - Relationship map for resolving hyperlink URLs
+* @param media - Media files map for image data
+* @param options - Parsing options for context-specific body behavior
+* @returns Parsed Paragraph object
+*/
+function parseParagraph(node, styles, theme, numbering, rels = null, media = null, options) {
+	const paragraph = {
+		type: "paragraph",
+		content: []
+	};
+	const paraId = getAttribute(node, "w14", "paraId") ?? getAttribute(node, "w", "paraId");
+	if (paraId) paragraph.paraId = paraId;
+	const textId = getAttribute(node, "w14", "textId") ?? getAttribute(node, "w", "textId");
+	if (textId) paragraph.textId = textId;
+	if (!options?.inHeaderFooter && paragraphStartsWithRenderedPageBreak(node)) paragraph.renderedPageBreakBefore = true;
+	const pPr = findChild(node, "w", "pPr");
+	if (pPr) {
+		const formattingResult = parseParagraphProperties(pPr, theme, styles ?? void 0);
+		if (formattingResult !== void 0) paragraph.formatting = formattingResult;
+		const propertyChangesResult = parseParagraphPropertyChanges(pPr, theme, styles, paragraph.formatting);
+		if (propertyChangesResult !== void 0) paragraph.propertyChanges = propertyChangesResult;
+		const pPrMarkResult = parseParagraphMarkChange(pPr);
+		if (pPrMarkResult !== void 0) paragraph.pPrMark = pPrMarkResult;
+		const sectPr = findChild(pPr, "w", "sectPr");
+		if (sectPr) paragraph.sectionProperties = parseSectionProperties(sectPr);
+	}
+	paragraph.content = consolidateParagraphContent(parseParagraphContents(node, styles, theme, numbering, rels, media, "default", options?.rootXmlns ?? {}));
+	let effectiveNumPr = paragraph.formatting?.numPr;
+	let numPrFromStyle = false;
+	if (!effectiveNumPr && paragraph.formatting?.styleId && styles) {
+		const style = styles.get(paragraph.formatting.styleId);
+		if (style?.pPr?.numPr) {
+			effectiveNumPr = style.pPr.numPr;
+			numPrFromStyle = true;
+			paragraph.formatting.numPr = effectiveNumPr;
+			paragraph.formatting.numPrFromStyle = effectiveNumPr;
+		}
+	}
+	if (effectiveNumPr && numbering) {
+		const { numId, ilvl = 0 } = effectiveNumPr;
+		if (numId !== void 0 && numId !== 0) {
+			const level = numbering.getLevel(numId, ilvl);
+			if (level) {
+				const levelNumFmts = [];
+				for (let levelIndex = 0; levelIndex <= ilvl; levelIndex += 1) levelNumFmts.push(level.isLgl ? "decimal" : numbering.getLevel(numId, levelIndex)?.numFmt ?? "decimal");
+				const listRendering = {
+					level: ilvl,
+					numId,
+					marker: level.lvlText,
+					isBullet: level.numFmt === "bullet",
+					levelNumFmts
+				};
+				const instance = numbering.getInstance(numId);
+				const overrideForLevel = instance?.levelOverrides?.find((override) => override.ilvl === ilvl);
+				if (instance?.abstractNumId !== void 0) listRendering.abstractNumId = instance.abstractNumId;
+				if (overrideForLevel?.startOverride !== void 0) listRendering.startOverride = overrideForLevel.startOverride;
+				if (level.isLgl) listRendering.isLegal = true;
+				listRendering.numFmt = level.isLgl ? "decimal" : level.numFmt;
+				if (level.rPr?.hidden) listRendering.markerHidden = true;
+				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?.allCaps) listRendering.markerAllCaps = true;
+				if (level.suffix) listRendering.markerSuffix = level.suffix;
+				let implicitChildLevelAdvances = 0;
+				const foldedMarkerSuffix = [];
+				const filteredContent = [];
+				let dropNextTab = false;
+				const isMetadataContent = (content) => content.type === "bookmarkStart" || content.type === "bookmarkEnd" || content.type === "commentRangeStart" || content.type === "commentRangeEnd" || content.type === "commentReference";
+				for (const content of paragraph.content) {
+					if (dropNextTab && isMetadataContent(content)) {
+						filteredContent.push(content);
+						continue;
+					}
+					if (dropNextTab) {
+						dropNextTab = false;
+						if (content.type === "run" && content.content.length === 1 && content.content[0]?.type === "tab") continue;
+					}
+					if (content.type === "complexField") {
+						if (content.fieldType === "LISTNUM" || content.instruction.trim().toUpperCase().startsWith("LISTNUM")) {
+							implicitChildLevelAdvances += 1;
+							const cached = extractPlainText(content.fieldResult);
+							if (cached) foldedMarkerSuffix.push(cached);
+							dropNextTab = true;
+							continue;
+						}
+					}
+					filteredContent.push(content);
+				}
+				if (foldedMarkerSuffix.length > 0) {
+					paragraph.content = filteredContent;
+					listRendering.marker = `${listRendering.marker}\t${foldedMarkerSuffix.join(" ")}`;
+					const nextLevel = numbering.getLevel(numId, ilvl + 1);
+					if (nextLevel?.pPr?.hangingIndent === true && nextLevel.pPr.indentFirstLine !== void 0) {
+						const hangingTwips = -nextLevel.pPr.indentFirstLine;
+						if (hangingTwips > 0) listRendering.markerSecondSlotOffsetTwips = hangingTwips;
+					}
+				}
+				if (implicitChildLevelAdvances > 0) listRendering.implicitChildLevelAdvances = implicitChildLevelAdvances;
+				paragraph.listRendering = listRendering;
+				const chainInd = numPrFromStyle ? styleChainInd(paragraph.formatting?.styleId, styles) : {
+					left: false,
+					firstLine: false
+				};
+				if (level.pPr) {
+					if (!paragraph.formatting) paragraph.formatting = {};
+					const directInd = pPr ? findChild(pPr, "w", "ind") : null;
+					const hasDirectLeft = directInd !== null && (getAttribute(directInd, "w", "left") !== null || getAttribute(directInd, "w", "start") !== null);
+					const directFirstLine = directInd ? parseNumericAttribute(directInd, "w", "firstLine") : void 0;
+					const directHanging = directInd ? parseNumericAttribute(directInd, "w", "hanging") : void 0;
+					const hasDirectFirstLineOrHanging = directFirstLine !== void 0 && directFirstLine !== 0 || directHanging !== void 0 && directHanging !== 0;
+					if (!hasDirectLeft && !chainInd.left && level.pPr.indentLeft !== void 0) paragraph.formatting.indentLeft = level.pPr.indentLeft;
+					if (!hasDirectFirstLineOrHanging && !chainInd.firstLine) {
+						if (level.pPr.indentFirstLine !== void 0) paragraph.formatting.indentFirstLine = level.pPr.indentFirstLine;
+						if (level.pPr.hangingIndent !== void 0) paragraph.formatting.hangingIndent = level.pPr.hangingIndent;
+					}
+				}
+			}
+		}
+	}
+	return paragraph;
+}
+/**
+* Which indent groups the basedOn chain defines: `left` (w:ind left) and
+* `firstLine` (w:ind firstLine/hanging). Walks from the given style up the
+* chain; cycles are guarded. Grouping matches listAttrsFromResolvedStyle.
+*/
+function styleChainInd(styleId, styles) {
+	const result = {
+		left: false,
+		firstLine: false
+	};
+	if (!styleId || !styles) return result;
+	const seen = /* @__PURE__ */ new Set();
+	let current = styleId;
+	while (current && !seen.has(current)) {
+		seen.add(current);
+		const style = styles.get(current);
+		if (!style) break;
+		const p = style.pPr;
+		if (p) {
+			result.left ||= p.indentLeft !== void 0;
+			result.firstLine ||= p.indentFirstLine !== void 0 || p.hangingIndent !== void 0;
+		}
+		if (result.left && result.firstLine) break;
+		current = style.basedOn;
+	}
+	return result;
+}
+/**
+* Get plain text from a paragraph
+*
+* @param paragraph - Parsed Paragraph object
+* @returns Concatenated text content
+*/
+function getParagraphText(paragraph) {
+	let text = "";
+	for (const content of paragraph.content) if (content.type === "run") {
+		for (const runContent of content.content) if (runContent.type === "text") text += runContent.text;
+		else if (runContent.type === "tab") text += "	";
+		else if (runContent.type === "break") if (runContent.breakType === "page") text += "\f";
+		else text += "\n";
+	} else if (content.type === "hyperlink") {
+		for (const child of content.children) if (child.type === "run") {
+			for (const runContent of child.content) if (runContent.type === "text") text += runContent.text;
+		}
+	} else if (content.type === "simpleField") {
+		for (const child of content.content) if (child.type === "run") {
+			for (const runContent of child.content) if (runContent.type === "text") text += runContent.text;
+		}
+	} else if (content.type === "complexField") {
+		for (const run of content.fieldResult) for (const runContent of run.content) if (runContent.type === "text") text += runContent.text;
+	}
+	return text;
+}
+/**
+* Check if a paragraph is empty (no visible content)
+*
+* @param paragraph - Parsed Paragraph object
+* @returns true if paragraph has no visible content
+*/
+function isEmptyParagraph(paragraph) {
+	return getParagraphText(paragraph).trim() === "" && !paragraph.content.some((c) => c.type === "run" && c.content.some((rc) => rc.type === "drawing" || rc.type === "shape"));
+}
+/**
+* Check if a paragraph is a list item
+*
+* @param paragraph - Parsed Paragraph object
+* @returns true if paragraph has numbering properties
+*/
+function isListItem(paragraph) {
+	return paragraph.formatting?.numPr !== void 0 && paragraph.formatting.numPr.numId !== void 0 && paragraph.formatting.numPr.numId !== 0;
+}
+/**
+* Get the list level of a paragraph (0-8)
+*
+* @param paragraph - Parsed Paragraph object
+* @returns List level or undefined if not a list item
+*/
+function getListLevel(paragraph) {
+	if (!isListItem(paragraph)) return;
+	return paragraph.formatting?.numPr?.ilvl ?? 0;
+}
+/**
+* Check if paragraph has a specific style
+*
+* @param paragraph - Parsed Paragraph object
+* @param styleId - Style ID to check for
+* @returns true if paragraph has the specified style
+*/
+function hasStyle(paragraph, styleId) {
+	return paragraph.formatting?.styleId === styleId;
+}
+/**
+* Check if paragraph starts with a template variable {{...}}
+*
+* @param paragraph - Parsed Paragraph object
+* @returns The variable name or null
+*/
+function getTemplateVariable(paragraph) {
+	const text = getParagraphText(paragraph);
+	const start = text.indexOf("{{");
+	if (start === -1) return null;
+	const end = text.indexOf("}}", start + 2);
+	if (end === -1 || end === start + 2) return null;
+	return text.slice(start + 2, end);
+}
+//#endregion
+export { getListLevel, getParagraphText, getTemplateVariable, hasStyle, isEmptyParagraph, isListItem, parseParagraph, parseParagraphProperties };