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

package/dist/docx/styleParser.js

@@ -0,0 +1,905 @@
+import { findChild, findChildren, getAttribute, getLocalName, parseBooleanElement, parseNumericAttribute, parseXmlDocument } from "./xmlParser.js";
+import { BorderStyleSchema, ConditionalStyleTypeSchema, EmphasisMarkSchema, FontThemeSchema, HighlightColorSchema, LineSpacingRuleSchema, ParagraphAlignmentSchema, ShadingPatternSchema, StyleTypeSchema, TabLeaderSchema, TabStopAlignmentSchema, TableCellTextDirectionSchema, TableRowHeightRuleSchema, TableWidthTypeSchema, TextEffectSchema, ThemeColorSlotSchema, UnderlineStyleSchema, narrowEnum } from "./parserEnums.js";
+import { resolveThemeFontRef } from "./themeParser.js";
+import { mergeTextFormatting } from "../utils/textFormattingMerge.js";
+import { mergeParagraphFormatting } from "../utils/paragraphFormattingMerge.js";
+//#region src/docx/styleParser.ts
+/**
+* Parse text formatting properties (w:rPr)
+*/
+function parseRunProperties(rPr, theme) {
+	if (!rPr) return;
+	const formatting = {};
+	const b = findChild(rPr, "w", "b");
+	if (b) formatting.bold = parseBooleanElement(b);
+	const bCs = findChild(rPr, "w", "bCs");
+	if (bCs) formatting.boldCs = parseBooleanElement(bCs);
+	const i = findChild(rPr, "w", "i");
+	if (i) formatting.italic = parseBooleanElement(i);
+	const iCs = findChild(rPr, "w", "iCs");
+	if (iCs) formatting.italicCs = parseBooleanElement(iCs);
+	const u = findChild(rPr, "w", "u");
+	if (u) {
+		const style = narrowEnum(getAttribute(u, "w", "val"), UnderlineStyleSchema);
+		if (style) {
+			formatting.underline = { style };
+			const colorVal = getAttribute(u, "w", "color");
+			const themeColor = getAttribute(u, "w", "themeColor");
+			if (colorVal || themeColor) formatting.underline.color = parseColorValue(colorVal, themeColor, getAttribute(u, "w", "themeTint"), getAttribute(u, "w", "themeShade"));
+		}
+	}
+	const strike = findChild(rPr, "w", "strike");
+	if (strike) formatting.strike = parseBooleanElement(strike);
+	const dstrike = findChild(rPr, "w", "dstrike");
+	if (dstrike) formatting.doubleStrike = parseBooleanElement(dstrike);
+	const vertAlign = findChild(rPr, "w", "vertAlign");
+	if (vertAlign) {
+		const val = getAttribute(vertAlign, "w", "val");
+		if (val === "superscript" || val === "subscript" || val === "baseline") formatting.vertAlign = val;
+	}
+	const smallCaps = findChild(rPr, "w", "smallCaps");
+	if (smallCaps) formatting.smallCaps = parseBooleanElement(smallCaps);
+	const caps = findChild(rPr, "w", "caps");
+	if (caps) formatting.allCaps = parseBooleanElement(caps);
+	const vanish = findChild(rPr, "w", "vanish");
+	if (vanish) formatting.hidden = parseBooleanElement(vanish);
+	const color = findChild(rPr, "w", "color");
+	if (color) formatting.color = parseColorValue(getAttribute(color, "w", "val"), getAttribute(color, "w", "themeColor"), getAttribute(color, "w", "themeTint"), getAttribute(color, "w", "themeShade"));
+	const highlight = findChild(rPr, "w", "highlight");
+	if (highlight) {
+		const val = narrowEnum(getAttribute(highlight, "w", "val"), HighlightColorSchema);
+		if (val) formatting.highlight = val;
+	}
+	const shd = findChild(rPr, "w", "shd");
+	if (shd) {
+		const shadingResult = parseShadingProperties(shd);
+		if (shadingResult) formatting.shading = shadingResult;
+	}
+	const sz = findChild(rPr, "w", "sz");
+	if (sz) {
+		const val = parseNumericAttribute(sz, "w", "val");
+		if (val !== void 0) formatting.fontSize = val;
+	}
+	const szCs = findChild(rPr, "w", "szCs");
+	if (szCs) {
+		const val = parseNumericAttribute(szCs, "w", "val");
+		if (val !== void 0) formatting.fontSizeCs = val;
+	}
+	const rFonts = findChild(rPr, "w", "rFonts");
+	if (rFonts) {
+		const fontFamily = {};
+		const ascii = getAttribute(rFonts, "w", "ascii");
+		if (ascii) fontFamily.ascii = ascii;
+		const hAnsi = getAttribute(rFonts, "w", "hAnsi");
+		if (hAnsi) fontFamily.hAnsi = hAnsi;
+		const eastAsia = getAttribute(rFonts, "w", "eastAsia");
+		if (eastAsia) fontFamily.eastAsia = eastAsia;
+		const csFont = getAttribute(rFonts, "w", "cs");
+		if (csFont) fontFamily.cs = csFont;
+		const asciiTheme = narrowEnum(getAttribute(rFonts, "w", "asciiTheme"), FontThemeSchema);
+		if (asciiTheme) {
+			fontFamily.asciiTheme = asciiTheme;
+			if (theme && !fontFamily.ascii) {
+				const resolved = resolveThemeFontRef(theme, asciiTheme);
+				if (resolved) fontFamily.ascii = resolved;
+			}
+		}
+		const hAnsiTheme = getAttribute(rFonts, "w", "hAnsiTheme");
+		if (hAnsiTheme) {
+			fontFamily.hAnsiTheme = hAnsiTheme;
+			if (theme && !fontFamily.hAnsi) {
+				const resolved = resolveThemeFontRef(theme, hAnsiTheme);
+				if (resolved) fontFamily.hAnsi = resolved;
+			}
+		}
+		const eastAsiaTheme = getAttribute(rFonts, "w", "eastAsiaTheme");
+		if (eastAsiaTheme) {
+			fontFamily.eastAsiaTheme = eastAsiaTheme;
+			if (theme && !fontFamily.eastAsia) {
+				const resolved = resolveThemeFontRef(theme, eastAsiaTheme);
+				if (resolved) fontFamily.eastAsia = resolved;
+			}
+		}
+		const csTheme = getAttribute(rFonts, "w", "cstheme");
+		if (csTheme) {
+			fontFamily.csTheme = csTheme;
+			if (theme && !fontFamily.cs) {
+				const resolved = resolveThemeFontRef(theme, csTheme);
+				if (resolved) fontFamily.cs = resolved;
+			}
+		}
+		formatting.fontFamily = fontFamily;
+	}
+	const spacing = findChild(rPr, "w", "spacing");
+	if (spacing) {
+		const val = parseNumericAttribute(spacing, "w", "val");
+		if (val !== void 0) formatting.spacing = val;
+	}
+	const position = findChild(rPr, "w", "position");
+	if (position) {
+		const val = parseNumericAttribute(position, "w", "val");
+		if (val !== void 0) formatting.position = val;
+	}
+	const w = findChild(rPr, "w", "w");
+	if (w) {
+		const val = parseNumericAttribute(w, "w", "val");
+		if (val !== void 0) formatting.scale = val;
+	}
+	const kern = findChild(rPr, "w", "kern");
+	if (kern) {
+		const val = parseNumericAttribute(kern, "w", "val");
+		if (val !== void 0) formatting.kerning = val;
+	}
+	const effect = findChild(rPr, "w", "effect");
+	if (effect) {
+		const val = narrowEnum(getAttribute(effect, "w", "val"), TextEffectSchema);
+		if (val) formatting.effect = val;
+	}
+	const em = findChild(rPr, "w", "em");
+	if (em) {
+		const val = narrowEnum(getAttribute(em, "w", "val"), EmphasisMarkSchema);
+		if (val) formatting.emphasisMark = val;
+	}
+	const emboss = findChild(rPr, "w", "emboss");
+	if (emboss) formatting.emboss = parseBooleanElement(emboss);
+	const imprint = findChild(rPr, "w", "imprint");
+	if (imprint) formatting.imprint = parseBooleanElement(imprint);
+	const outline = findChild(rPr, "w", "outline");
+	if (outline) formatting.outline = parseBooleanElement(outline);
+	const shadow = findChild(rPr, "w", "shadow");
+	if (shadow) formatting.shadow = parseBooleanElement(shadow);
+	const rtl = findChild(rPr, "w", "rtl");
+	if (rtl) formatting.rtl = parseBooleanElement(rtl);
+	const cs = findChild(rPr, "w", "cs");
+	if (cs) formatting.cs = parseBooleanElement(cs);
+	const rStyle = findChild(rPr, "w", "rStyle");
+	if (rStyle) {
+		const val = getAttribute(rStyle, "w", "val");
+		if (val) formatting.styleId = val;
+	}
+	return Object.keys(formatting).length > 0 ? formatting : void 0;
+}
+/**
+* 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) {
+		if (!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
+*/
+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 paragraph formatting properties (w:pPr)
+*/
+function parseParagraphProperties(pPr, theme) {
+	if (!pPr) return;
+	const formatting = {};
+	const jc = findChild(pPr, "w", "jc");
+	if (jc) {
+		const val = narrowEnum(getAttribute(jc, "w", "val"), ParagraphAlignmentSchema);
+		if (val) formatting.alignment = val;
+	}
+	const bidi = findChild(pPr, "w", "bidi");
+	if (bidi) formatting.bidi = parseBooleanElement(bidi);
+	const spacing = findChild(pPr, "w", "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 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 = findChild(pPr, "w", "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 pBdr = findChild(pPr, "w", "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 = findChild(pPr, "w", "shd");
+	if (shd) {
+		const shadingResult = parseShadingProperties(shd);
+		if (shadingResult) formatting.shading = shadingResult;
+	}
+	const tabs = findChild(pPr, "w", "tabs");
+	if (tabs) {
+		const tabStops = parseTabStops(tabs);
+		if (tabStops) formatting.tabs = tabStops;
+	}
+	const keepNext = findChild(pPr, "w", "keepNext");
+	if (keepNext) formatting.keepNext = parseBooleanElement(keepNext);
+	const keepLines = findChild(pPr, "w", "keepLines");
+	if (keepLines) formatting.keepLines = parseBooleanElement(keepLines);
+	const widowControl = findChild(pPr, "w", "widowControl");
+	if (widowControl) formatting.widowControl = parseBooleanElement(widowControl);
+	const pageBreakBefore = findChild(pPr, "w", "pageBreakBefore");
+	if (pageBreakBefore) formatting.pageBreakBefore = parseBooleanElement(pageBreakBefore);
+	const contextualSpacing = findChild(pPr, "w", "contextualSpacing");
+	if (contextualSpacing) formatting.contextualSpacing = parseBooleanElement(contextualSpacing);
+	const numPr = findChild(pPr, "w", "numPr");
+	if (numPr) {
+		const numId = findChild(numPr, "w", "numId");
+		const ilvl = findChild(numPr, "w", "ilvl");
+		if (numId || ilvl) {
+			formatting.numPr = {};
+			if (numId) {
+				const val = parseNumericAttribute(numId, "w", "val");
+				if (val !== void 0) formatting.numPr.numId = val;
+			}
+			if (ilvl) {
+				const val = parseNumericAttribute(ilvl, "w", "val");
+				if (val !== void 0) formatting.numPr.ilvl = val;
+			}
+		}
+	}
+	const outlineLvl = findChild(pPr, "w", "outlineLvl");
+	if (outlineLvl) {
+		const val = parseNumericAttribute(outlineLvl, "w", "val");
+		if (val !== void 0) formatting.outlineLevel = val;
+	}
+	const pStyle = findChild(pPr, "w", "pStyle");
+	if (pStyle) {
+		const val = getAttribute(pStyle, "w", "val");
+		if (val) formatting.styleId = val;
+	}
+	const suppressLineNumbers = findChild(pPr, "w", "suppressLineNumbers");
+	if (suppressLineNumbers) formatting.suppressLineNumbers = parseBooleanElement(suppressLineNumbers);
+	const suppressAutoHyphens = findChild(pPr, "w", "suppressAutoHyphens");
+	if (suppressAutoHyphens) formatting.suppressAutoHyphens = parseBooleanElement(suppressAutoHyphens);
+	const rPr = findChild(pPr, "w", "rPr");
+	if (rPr) {
+		const runProps = parseRunProperties(rPr, theme);
+		if (runProps) formatting.runProperties = runProps;
+	}
+	return Object.keys(formatting).length > 0 ? formatting : void 0;
+}
+/**
+* Parse table measurement (width/height with type)
+*/
+function parseTableMeasurement(element) {
+	if (!element) return;
+	const w = parseNumericAttribute(element, "w", "w");
+	const rawType = getAttribute(element, "w", "type");
+	const type = rawType === null ? "dxa" : narrowEnum(rawType, TableWidthTypeSchema);
+	if (w !== void 0 && type) return {
+		value: w,
+		type
+	};
+}
+/**
+* Parse table borders
+*/
+function parseTableBorders(tblBorders) {
+	if (!tblBorders) return;
+	const borders = {};
+	const top = parseBorderSpec(findChild(tblBorders, "w", "top"));
+	if (top) borders.top = top;
+	const bottom = parseBorderSpec(findChild(tblBorders, "w", "bottom"));
+	if (bottom) borders.bottom = bottom;
+	const left = parseBorderSpec(findChild(tblBorders, "w", "left") ?? findChild(tblBorders, "w", "start"));
+	if (left) borders.left = left;
+	const right = parseBorderSpec(findChild(tblBorders, "w", "right") ?? findChild(tblBorders, "w", "end"));
+	if (right) borders.right = right;
+	const insideH = parseBorderSpec(findChild(tblBorders, "w", "insideH"));
+	if (insideH) borders.insideH = insideH;
+	const insideV = parseBorderSpec(findChild(tblBorders, "w", "insideV"));
+	if (insideV) borders.insideV = insideV;
+	return Object.keys(borders).length > 0 ? borders : void 0;
+}
+/**
+* Parse cell margins
+*/
+function parseCellMargins(tblCellMar) {
+	if (!tblCellMar) return;
+	const margins = {};
+	const top = parseTableMeasurement(findChild(tblCellMar, "w", "top"));
+	if (top) margins.top = top;
+	const bottom = parseTableMeasurement(findChild(tblCellMar, "w", "bottom"));
+	if (bottom) margins.bottom = bottom;
+	const left = parseTableMeasurement(findChild(tblCellMar, "w", "left"));
+	if (left) margins.left = left;
+	const right = parseTableMeasurement(findChild(tblCellMar, "w", "right"));
+	if (right) margins.right = right;
+	return Object.keys(margins).length > 0 ? margins : void 0;
+}
+/**
+* Parse table look flags
+*/
+function parseTableLook(tblLook) {
+	if (!tblLook) return;
+	const look = {};
+	const val = getAttribute(tblLook, "w", "val");
+	if (val) {
+		const num = Number.parseInt(val, 16);
+		if (!Number.isNaN(num)) {
+			look.firstRow = (num & 32) !== 0;
+			look.lastRow = (num & 64) !== 0;
+			look.firstColumn = (num & 128) !== 0;
+			look.lastColumn = (num & 256) !== 0;
+			look.noHBand = (num & 512) !== 0;
+			look.noVBand = (num & 1024) !== 0;
+		}
+	}
+	const firstColumn = getAttribute(tblLook, "w", "firstColumn");
+	if (firstColumn) look.firstColumn = firstColumn === "1";
+	const firstRow = getAttribute(tblLook, "w", "firstRow");
+	if (firstRow) look.firstRow = firstRow === "1";
+	const lastColumn = getAttribute(tblLook, "w", "lastColumn");
+	if (lastColumn) look.lastColumn = lastColumn === "1";
+	const lastRow = getAttribute(tblLook, "w", "lastRow");
+	if (lastRow) look.lastRow = lastRow === "1";
+	const noHBand = getAttribute(tblLook, "w", "noHBand");
+	if (noHBand) look.noHBand = noHBand === "1";
+	const noVBand = getAttribute(tblLook, "w", "noVBand");
+	if (noVBand) look.noVBand = noVBand === "1";
+	return Object.keys(look).length > 0 ? look : void 0;
+}
+/**
+* Parse table formatting properties (w:tblPr)
+*/
+function parseTableProperties(tblPr, _theme) {
+	if (!tblPr) return;
+	const formatting = {};
+	const tblW = findChild(tblPr, "w", "tblW");
+	if (tblW) {
+		const widthResult = parseTableMeasurement(tblW);
+		if (widthResult) formatting.width = widthResult;
+	}
+	const jc = findChild(tblPr, "w", "jc");
+	if (jc) {
+		const val = getAttribute(jc, "w", "val");
+		if (val === "left" || val === "center" || val === "right") formatting.justification = val;
+	}
+	const tblCellSpacing = findChild(tblPr, "w", "tblCellSpacing");
+	if (tblCellSpacing) {
+		const cellSpacingResult = parseTableMeasurement(tblCellSpacing);
+		if (cellSpacingResult) formatting.cellSpacing = cellSpacingResult;
+	}
+	const tblInd = findChild(tblPr, "w", "tblInd");
+	if (tblInd) {
+		const indentResult = parseTableMeasurement(tblInd);
+		if (indentResult) formatting.indent = indentResult;
+	}
+	const tblBorders = findChild(tblPr, "w", "tblBorders");
+	if (tblBorders) {
+		const bordersResult = parseTableBorders(tblBorders);
+		if (bordersResult) formatting.borders = bordersResult;
+	}
+	const tblCellMar = findChild(tblPr, "w", "tblCellMar");
+	if (tblCellMar) {
+		const marginsResult = parseCellMargins(tblCellMar);
+		if (marginsResult) formatting.cellMargins = marginsResult;
+	}
+	const tblLayout = findChild(tblPr, "w", "tblLayout");
+	if (tblLayout) {
+		const val = getAttribute(tblLayout, "w", "type");
+		if (val === "fixed" || val === "autofit") formatting.layout = val;
+	}
+	const tblStyle = findChild(tblPr, "w", "tblStyle");
+	if (tblStyle) {
+		const val = getAttribute(tblStyle, "w", "val");
+		if (val) formatting.styleId = val;
+	}
+	const tblLook = findChild(tblPr, "w", "tblLook");
+	if (tblLook) {
+		const lookResult = parseTableLook(tblLook);
+		if (lookResult) formatting.look = lookResult;
+	}
+	const shd = findChild(tblPr, "w", "shd");
+	if (shd) {
+		const shadingResult = parseShadingProperties(shd);
+		if (shadingResult) formatting.shading = shadingResult;
+	}
+	const bidiVisual = findChild(tblPr, "w", "bidiVisual");
+	if (bidiVisual) formatting.bidi = parseBooleanElement(bidiVisual);
+	return Object.keys(formatting).length > 0 ? formatting : void 0;
+}
+/**
+* Parse table row formatting properties (w:trPr)
+*/
+function parseTableRowProperties(trPr) {
+	if (!trPr) return;
+	const formatting = {};
+	const trHeight = findChild(trPr, "w", "trHeight");
+	if (trHeight) {
+		const heightResult = parseTableMeasurement(trHeight);
+		if (heightResult) formatting.height = heightResult;
+		const hRule = narrowEnum(getAttribute(trHeight, "w", "hRule"), TableRowHeightRuleSchema);
+		if (hRule) formatting.heightRule = hRule;
+	}
+	const tblHeader = findChild(trPr, "w", "tblHeader");
+	if (tblHeader) formatting.header = parseBooleanElement(tblHeader);
+	const cantSplit = findChild(trPr, "w", "cantSplit");
+	if (cantSplit) formatting.cantSplit = parseBooleanElement(cantSplit);
+	const jc = findChild(trPr, "w", "jc");
+	if (jc) {
+		const val = getAttribute(jc, "w", "val");
+		if (val === "left" || val === "center" || val === "right") formatting.justification = val;
+	}
+	const hidden = findChild(trPr, "w", "hidden");
+	if (hidden) formatting.hidden = parseBooleanElement(hidden);
+	return Object.keys(formatting).length > 0 ? formatting : void 0;
+}
+/**
+* Parse table cell formatting properties (w:tcPr)
+*/
+function parseTableCellProperties(tcPr, _theme) {
+	if (!tcPr) return;
+	const formatting = {};
+	const tcW = findChild(tcPr, "w", "tcW");
+	if (tcW) {
+		const widthResult = parseTableMeasurement(tcW);
+		if (widthResult) formatting.width = widthResult;
+	}
+	const tcBorders = findChild(tcPr, "w", "tcBorders");
+	if (tcBorders) {
+		const bordersResult = parseTableBorders(tcBorders);
+		if (bordersResult) formatting.borders = bordersResult;
+	}
+	const tcMar = findChild(tcPr, "w", "tcMar");
+	if (tcMar) {
+		const marginsResult = parseCellMargins(tcMar);
+		if (marginsResult) formatting.margins = marginsResult;
+	}
+	const shd = findChild(tcPr, "w", "shd");
+	if (shd) {
+		const shadingResult = parseShadingProperties(shd);
+		if (shadingResult) formatting.shading = shadingResult;
+	}
+	const vAlign = findChild(tcPr, "w", "vAlign");
+	if (vAlign) {
+		const val = getAttribute(vAlign, "w", "val");
+		if (val === "top" || val === "center" || val === "bottom") formatting.verticalAlign = val;
+	}
+	const textDirection = findChild(tcPr, "w", "textDirection");
+	if (textDirection) {
+		const val = narrowEnum(getAttribute(textDirection, "w", "val"), TableCellTextDirectionSchema);
+		if (val) formatting.textDirection = val;
+	}
+	const gridSpan = findChild(tcPr, "w", "gridSpan");
+	if (gridSpan) {
+		const val = parseNumericAttribute(gridSpan, "w", "val");
+		if (val !== void 0) formatting.gridSpan = val;
+	}
+	const vMerge = findChild(tcPr, "w", "vMerge");
+	if (vMerge) formatting.vMerge = getAttribute(vMerge, "w", "val") === "restart" ? "restart" : "continue";
+	const tcFitText = findChild(tcPr, "w", "tcFitText");
+	if (tcFitText) formatting.fitText = parseBooleanElement(tcFitText);
+	const noWrap = findChild(tcPr, "w", "noWrap");
+	if (noWrap) formatting.noWrap = parseBooleanElement(noWrap);
+	const hideMark = findChild(tcPr, "w", "hideMark");
+	if (hideMark) formatting.hideMark = parseBooleanElement(hideMark);
+	return Object.keys(formatting).length > 0 ? formatting : void 0;
+}
+function collectStyleChildren(styleEl) {
+	const children = { tblStylePrs: [] };
+	for (const child of styleEl.elements ?? []) {
+		if (child.type !== "element") continue;
+		switch (getLocalName(child.name || "")) {
+			case "basedOn":
+				children.basedOn ??= child;
+				break;
+			case "hidden":
+				children.hidden ??= child;
+				break;
+			case "link":
+				children.link ??= child;
+				break;
+			case "name":
+				children.name ??= child;
+				break;
+			case "next":
+				children.next ??= child;
+				break;
+			case "personal":
+				children.personal ??= child;
+				break;
+			case "pPr":
+				children.pPr ??= child;
+				break;
+			case "qFormat":
+				children.qFormat ??= child;
+				break;
+			case "rPr":
+				children.rPr ??= child;
+				break;
+			case "semiHidden":
+				children.semiHidden ??= child;
+				break;
+			case "tblPr":
+				children.tblPr ??= child;
+				break;
+			case "tblStylePr":
+				children.tblStylePrs.push(child);
+				break;
+			case "tcPr":
+				children.tcPr ??= child;
+				break;
+			case "trPr":
+				children.trPr ??= child;
+				break;
+			case "uiPriority":
+				children.uiPriority ??= child;
+				break;
+			case "unhideWhenUsed":
+				children.unhideWhenUsed ??= child;
+				break;
+		}
+	}
+	return children;
+}
+/**
+* Parse a single style element (w:style)
+*/
+function parseStyle(styleEl, theme) {
+	const rawType = getAttribute(styleEl, "w", "type");
+	const style = {
+		styleId: getAttribute(styleEl, "w", "styleId") ?? "",
+		type: narrowEnum(rawType, StyleTypeSchema) ?? "paragraph"
+	};
+	const defaultAttr = getAttribute(styleEl, "w", "default");
+	if (defaultAttr) style.default = defaultAttr === "1" || defaultAttr === "true";
+	const children = collectStyleChildren(styleEl);
+	const nameEl = children.name;
+	if (nameEl) {
+		const nameVal = getAttribute(nameEl, "w", "val");
+		if (nameVal) style.name = nameVal;
+	}
+	const basedOn = children.basedOn;
+	if (basedOn) {
+		const basedOnVal = getAttribute(basedOn, "w", "val");
+		if (basedOnVal) style.basedOn = basedOnVal;
+	}
+	const next = children.next;
+	if (next) {
+		const nextVal = getAttribute(next, "w", "val");
+		if (nextVal) style.next = nextVal;
+	}
+	const link = children.link;
+	if (link) {
+		const linkVal = getAttribute(link, "w", "val");
+		if (linkVal) style.link = linkVal;
+	}
+	const uiPriority = children.uiPriority;
+	if (uiPriority) {
+		const val = parseNumericAttribute(uiPriority, "w", "val");
+		if (val !== void 0) style.uiPriority = val;
+	}
+	const hidden = children.hidden;
+	if (hidden) style.hidden = parseBooleanElement(hidden);
+	const semiHidden = children.semiHidden;
+	if (semiHidden) style.semiHidden = parseBooleanElement(semiHidden);
+	const unhideWhenUsed = children.unhideWhenUsed;
+	if (unhideWhenUsed) style.unhideWhenUsed = parseBooleanElement(unhideWhenUsed);
+	const qFormat = children.qFormat;
+	if (qFormat) style.qFormat = parseBooleanElement(qFormat);
+	const personal = children.personal;
+	if (personal) style.personal = parseBooleanElement(personal);
+	const pPr = children.pPr;
+	if (pPr) {
+		const pPrResult = parseParagraphProperties(pPr, theme);
+		if (pPrResult) style.pPr = pPrResult;
+	}
+	const rPr = children.rPr;
+	if (rPr) {
+		const rPrResult = parseRunProperties(rPr, theme);
+		if (rPrResult) style.rPr = rPrResult;
+	}
+	const tblPr = children.tblPr;
+	if (tblPr) {
+		const tblPrResult = parseTableProperties(tblPr, theme);
+		if (tblPrResult) style.tblPr = tblPrResult;
+	}
+	const trPr = children.trPr;
+	if (trPr) {
+		const trPrResult = parseTableRowProperties(trPr);
+		if (trPrResult) style.trPr = trPrResult;
+	}
+	const tcPr = children.tcPr;
+	if (tcPr) {
+		const tcPrResult = parseTableCellProperties(tcPr, theme);
+		if (tcPrResult) style.tcPr = tcPrResult;
+	}
+	const tblStylePrs = children.tblStylePrs;
+	if (tblStylePrs.length > 0) {
+		style.tblStylePr = [];
+		for (const tblStylePr of tblStylePrs) {
+			const conditionalType = narrowEnum(getAttribute(tblStylePr, "w", "type"), ConditionalStyleTypeSchema);
+			if (conditionalType) {
+				const conditionalStyle = { type: conditionalType };
+				const condPPr = findChild(tblStylePr, "w", "pPr");
+				if (condPPr) {
+					const condPPrResult = parseParagraphProperties(condPPr, theme);
+					if (condPPrResult) conditionalStyle.pPr = condPPrResult;
+				}
+				const condRPr = findChild(tblStylePr, "w", "rPr");
+				if (condRPr) {
+					const condRPrResult = parseRunProperties(condRPr, theme);
+					if (condRPrResult) conditionalStyle.rPr = condRPrResult;
+				}
+				const condTblPr = findChild(tblStylePr, "w", "tblPr");
+				if (condTblPr) {
+					const condTblPrResult = parseTableProperties(condTblPr, theme);
+					if (condTblPrResult) conditionalStyle.tblPr = condTblPrResult;
+				}
+				const condTrPr = findChild(tblStylePr, "w", "trPr");
+				if (condTrPr) {
+					const condTrPrResult = parseTableRowProperties(condTrPr);
+					if (condTrPrResult) conditionalStyle.trPr = condTrPrResult;
+				}
+				const condTcPr = findChild(tblStylePr, "w", "tcPr");
+				if (condTcPr) {
+					const condTcPrResult = parseTableCellProperties(condTcPr, theme);
+					if (condTcPrResult) conditionalStyle.tcPr = condTcPrResult;
+				}
+				style.tblStylePr.push(conditionalStyle);
+			}
+		}
+	}
+	return style;
+}
+/**
+* Parse document defaults (w:docDefaults)
+*/
+function parseDocDefaults(docDefaults, theme) {
+	if (!docDefaults) return;
+	const result = {};
+	const rPrDefault = findChild(docDefaults, "w", "rPrDefault");
+	if (rPrDefault) {
+		const rPr = findChild(rPrDefault, "w", "rPr");
+		if (rPr) {
+			const rPrResult = parseRunProperties(rPr, theme);
+			if (rPrResult) result.rPr = rPrResult;
+		}
+	}
+	const pPrDefault = findChild(docDefaults, "w", "pPrDefault");
+	if (pPrDefault) {
+		const pPr = findChild(pPrDefault, "w", "pPr");
+		if (pPr) {
+			const pPrResult = parseParagraphProperties(pPr, theme);
+			if (pPrResult) result.pPr = pPrResult;
+		}
+	}
+	return result;
+}
+/**
+* Resolve style inheritance chain
+*/
+function resolveStyleInheritance(style, styleMap, visited = /* @__PURE__ */ new Set()) {
+	if (visited.has(style.styleId)) return style;
+	visited.add(style.styleId);
+	if (!style.basedOn) return style;
+	const parentStyle = styleMap.get(style.basedOn);
+	if (!parentStyle) return style;
+	const resolvedParent = resolveStyleInheritance(parentStyle, styleMap, visited);
+	const resolved = { ...style };
+	const mergedPPr = mergeParagraphFormatting(resolvedParent.pPr, style.pPr);
+	if (mergedPPr) resolved.pPr = mergedPPr;
+	const mergedRPr = mergeTextFormatting(resolvedParent.rPr, style.rPr);
+	if (mergedRPr) resolved.rPr = mergedRPr;
+	if (style.type === "table") {
+		if (resolvedParent.tblPr || style.tblPr) resolved.tblPr = {
+			...resolvedParent.tblPr,
+			...style.tblPr
+		};
+		if (resolvedParent.trPr || style.trPr) resolved.trPr = {
+			...resolvedParent.trPr,
+			...style.trPr
+		};
+		if (resolvedParent.tcPr || style.tcPr) resolved.tcPr = {
+			...resolvedParent.tcPr,
+			...style.tcPr
+		};
+	}
+	return resolved;
+}
+/**
+* Parse styles.xml content
+*
+* @param stylesXml - XML content of styles.xml
+* @param theme - Parsed theme for resolving theme references
+* @returns StyleMap with resolved inheritance
+*/
+function parseStyles(stylesXml, theme) {
+	const doc = parseXmlDocument(stylesXml);
+	if (!doc) return /* @__PURE__ */ new Map();
+	return parseStylesFromDocument(doc, theme);
+}
+function parseStylesFromDocument(doc, theme) {
+	const styleMap = /* @__PURE__ */ new Map();
+	try {
+		const styleElements = findChildren(doc, "w", "style");
+		for (const styleEl of styleElements) {
+			const style = parseStyle(styleEl, theme);
+			if (style.styleId) styleMap.set(style.styleId, style);
+		}
+		for (const [styleId, style] of styleMap) {
+			const resolved = resolveStyleInheritance(style, styleMap);
+			styleMap.set(styleId, resolved);
+		}
+	} catch {}
+	return styleMap;
+}
+/**
+* Parse complete style definitions including docDefaults
+*
+* @param stylesXml - XML content of styles.xml
+* @param theme - Parsed theme for resolving theme references
+* @returns StyleDefinitions with docDefaults and resolved styles
+*/
+function parseStyleDefinitions(stylesXml, theme, resolvedStyles) {
+	const doc = parseXmlDocument(stylesXml);
+	if (!doc) return { styles: [] };
+	return parseStyleDefinitionsFromDocument(doc, theme, resolvedStyles);
+}
+function parseStyleDefinitionsFromDocument(doc, theme, resolvedStyles) {
+	const result = { styles: [] };
+	try {
+		const parsedDocDefaults = parseDocDefaults(findChild(doc, "w", "docDefaults"), theme);
+		if (parsedDocDefaults) result.docDefaults = parsedDocDefaults;
+		const latentStylesEl = findChild(doc, "w", "latentStyles");
+		if (latentStylesEl) {
+			const latentStyles = {
+				defLockedState: getAttribute(latentStylesEl, "w", "defLockedState") === "1",
+				defSemiHidden: getAttribute(latentStylesEl, "w", "defSemiHidden") === "1",
+				defUnhideWhenUsed: getAttribute(latentStylesEl, "w", "defUnhideWhenUsed") === "1",
+				defQFormat: getAttribute(latentStylesEl, "w", "defQFormat") === "1"
+			};
+			const defUIPriority = parseNumericAttribute(latentStylesEl, "w", "defUIPriority");
+			if (defUIPriority !== void 0) latentStyles.defUIPriority = defUIPriority;
+			const count = parseNumericAttribute(latentStylesEl, "w", "count");
+			if (count !== void 0) latentStyles.count = count;
+			result.latentStyles = latentStyles;
+		}
+		const styleMap = resolvedStyles ?? parseStylesFromDocument(doc, theme);
+		result.styles = Array.from(styleMap.values());
+	} catch {}
+	return result;
+}
+function parseStylesPackage(stylesXml, theme) {
+	const doc = parseXmlDocument(stylesXml);
+	if (!doc) return {
+		styleDefinitions: { styles: [] },
+		styles: /* @__PURE__ */ new Map()
+	};
+	const styles = parseStylesFromDocument(doc, theme);
+	return {
+		styleDefinitions: parseStyleDefinitionsFromDocument(doc, theme, styles),
+		styles
+	};
+}
+/**
+* Get the resolved properties for a style
+*
+* @param styleId - Style ID to look up
+* @param styleMap - Style map from parseStyles
+* @returns Resolved style or undefined
+*/
+function getResolvedStyle(styleId, styleMap) {
+	return styleMap.get(styleId);
+}
+/**
+* Get the default paragraph style
+*/
+function getDefaultParagraphStyle(styleMap) {
+	for (const style of styleMap.values()) if (style.type === "paragraph" && style.default) return style;
+	return styleMap.get("Normal");
+}
+/**
+* Get the default character style
+*/
+function getDefaultCharacterStyle(styleMap) {
+	for (const style of styleMap.values()) if (style.type === "character" && style.default) return style;
+}
+/**
+* Get all styles of a specific type
+*/
+function getStylesByType(styleMap, type) {
+	const result = [];
+	for (const style of styleMap.values()) if (style.type === type) result.push(style);
+	return result;
+}
+//#endregion
+export { getDefaultCharacterStyle, getDefaultParagraphStyle, getResolvedStyle, getStylesByType, parseStyleDefinitions, parseStyles, parseStylesPackage };