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

package/dist/docx/tableParser.js

@@ -0,0 +1,811 @@
+import { findChild, findChildByLocalName, findChildren, getAttribute, getChildElements, mergeXmlnsDeclarations, parseBooleanElement, parseNumericAttribute } from "./xmlParser.js";
+import { parseBookmarkEnd, parseBookmarkStart } from "./bookmarkParser.js";
+import { BorderStyleSchema, FloatingTableXSpecSchema, FloatingTableYSpecSchema, ShadingPatternSchema, TableCellTextDirectionSchema, ThemeColorSlotSchema, narrowEnum } from "./parserEnums.js";
+import { parseParagraph } from "./paragraphParser.js";
+import { appendBookmarkMarkerToLastParagraphInBlocks, appendBookmarkMarkerToLastParagraphInCells, prependBookmarkMarkersToFirstParagraphInBlocks, prependBookmarkMarkersToFirstParagraphInCell } from "./bookmarkPlacement.js";
+//#region src/docx/tableParser.ts
+/**
+* Parse a table measurement (width, height, etc.)
+*
+* @param element - Element with w:w and w:type attributes
+* @returns Parsed measurement or undefined
+*/
+function parseTableMeasurement(element) {
+	if (!element) return;
+	const value = parseNumericAttribute(element, "w", "w") ?? 0;
+	const typeStr = getAttribute(element, "w", "type") ?? "dxa";
+	let type = "dxa";
+	if (typeStr === "auto" || typeStr === "dxa" || typeStr === "nil" || typeStr === "pct") type = typeStr;
+	return {
+		value,
+		type
+	};
+}
+/**
+* Parse width from an element (shorthand for common case)
+*/
+function parseWidth(element) {
+	return parseTableMeasurement(element);
+}
+function parseTrackedChangeInfo(node) {
+	const rawId = getAttribute(node, "w", "id");
+	const parsedId = rawId ? Number.parseInt(rawId, 10) : 0;
+	const author = (getAttribute(node, "w", "author") ?? "").trim();
+	const date = (getAttribute(node, "w", "date") ?? "").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;
+}
+/**
+* Parse a single border specification
+*
+* @param element - Border element (w:top, w:bottom, etc.)
+* @returns Parsed border or undefined
+*/
+function parseBorderSpec(element) {
+	if (!element) return;
+	const rawStyle = getAttribute(element, "w", "val") ?? "none";
+	const border = { style: narrowEnum(rawStyle, BorderStyleSchema) ?? rawStyle };
+	const sz = parseNumericAttribute(element, "w", "sz");
+	if (sz !== void 0) border.size = sz;
+	const space = parseNumericAttribute(element, "w", "space");
+	if (space !== void 0) border.space = space;
+	const color = getAttribute(element, "w", "color");
+	const themeColor = getAttribute(element, "w", "themeColor");
+	const themeTint = getAttribute(element, "w", "themeTint");
+	const themeShade = getAttribute(element, "w", "themeShade");
+	if (color || themeColor || themeTint || themeShade) {
+		const colorVal = {};
+		if (color === "auto") colorVal.auto = true;
+		else if (color !== null) colorVal.rgb = color;
+		const validatedThemeColor = narrowEnum(themeColor, ThemeColorSlotSchema);
+		if (validatedThemeColor) colorVal.themeColor = validatedThemeColor;
+		if (themeTint !== null) colorVal.themeTint = themeTint;
+		if (themeShade !== null) colorVal.themeShade = themeShade;
+		border.color = colorVal;
+	}
+	const shadow = getAttribute(element, "w", "shadow");
+	if (shadow === "1" || shadow === "true") border.shadow = true;
+	const frame = getAttribute(element, "w", "frame");
+	if (frame === "1" || frame === "true") border.frame = true;
+	return border;
+}
+/**
+* Parse table borders (w:tblBorders or w:tcBorders)
+*
+* @param bordersElement - The borders container element
+* @returns Parsed borders or undefined
+*/
+function parseTableBorders(bordersElement) {
+	if (!bordersElement) return;
+	const borders = {};
+	const top = parseBorderSpec(findChild(bordersElement, "w", "top"));
+	if (top) borders.top = top;
+	const bottom = parseBorderSpec(findChild(bordersElement, "w", "bottom"));
+	if (bottom) borders.bottom = bottom;
+	const left = parseBorderSpec(findChild(bordersElement, "w", "left") ?? findChild(bordersElement, "w", "start"));
+	if (left) borders.left = left;
+	const right = parseBorderSpec(findChild(bordersElement, "w", "right") ?? findChild(bordersElement, "w", "end"));
+	if (right) borders.right = right;
+	const insideH = parseBorderSpec(findChild(bordersElement, "w", "insideH"));
+	if (insideH) borders.insideH = insideH;
+	const insideV = parseBorderSpec(findChild(bordersElement, "w", "insideV"));
+	if (insideV) borders.insideV = insideV;
+	if (Object.keys(borders).length === 0) return;
+	return borders;
+}
+/**
+* Parse cell margins (w:tblCellMar or w:tcMar)
+*
+* @param marginsElement - The margins container element
+* @returns Parsed margins or undefined
+*/
+function parseCellMargins(marginsElement) {
+	if (!marginsElement) return;
+	const margins = {};
+	const top = parseWidth(findChild(marginsElement, "w", "top"));
+	if (top) margins.top = top;
+	const bottom = parseWidth(findChild(marginsElement, "w", "bottom"));
+	if (bottom) margins.bottom = bottom;
+	const left = parseWidth(findChild(marginsElement, "w", "left") ?? findChild(marginsElement, "w", "start"));
+	if (left) margins.left = left;
+	const right = parseWidth(findChild(marginsElement, "w", "right") ?? findChild(marginsElement, "w", "end"));
+	if (right) margins.right = right;
+	if (Object.keys(margins).length === 0) return;
+	return margins;
+}
+/**
+* Parse shading properties (w:shd)
+*
+* @param shdElement - The w:shd element
+* @returns Parsed shading or undefined
+*/
+function parseShading(shdElement) {
+	if (!shdElement) return;
+	const shading = {};
+	const fillStr = getAttribute(shdElement, "w", "fill");
+	if (fillStr && fillStr !== "auto") shading.fill = { rgb: fillStr };
+	const themeFill = narrowEnum(getAttribute(shdElement, "w", "themeFill"), ThemeColorSlotSchema);
+	if (themeFill) {
+		shading.fill = { themeColor: themeFill };
+		const themeFillTint = getAttribute(shdElement, "w", "themeFillTint");
+		if (themeFillTint) shading.fill.themeTint = themeFillTint;
+		const themeFillShade = getAttribute(shdElement, "w", "themeFillShade");
+		if (themeFillShade) shading.fill.themeShade = themeFillShade;
+	}
+	const colorStr = getAttribute(shdElement, "w", "color");
+	if (colorStr && colorStr !== "auto") shading.color = { rgb: colorStr };
+	const pattern = narrowEnum(getAttribute(shdElement, "w", "val"), ShadingPatternSchema);
+	if (pattern) shading.pattern = pattern;
+	if (Object.keys(shading).length === 0) return;
+	return shading;
+}
+/**
+* Parse table look flags (w:tblLook)
+*
+* @param lookElement - The w:tblLook element
+* @returns Parsed table look or undefined
+*/
+function parseTableLook(lookElement) {
+	if (!lookElement) return;
+	const look = {};
+	const firstRow = getAttribute(lookElement, "w", "firstRow");
+	if (firstRow === "1" || firstRow === "true") look.firstRow = true;
+	const lastRow = getAttribute(lookElement, "w", "lastRow");
+	if (lastRow === "1" || lastRow === "true") look.lastRow = true;
+	const firstColumn = getAttribute(lookElement, "w", "firstColumn");
+	if (firstColumn === "1" || firstColumn === "true") look.firstColumn = true;
+	const lastColumn = getAttribute(lookElement, "w", "lastColumn");
+	if (lastColumn === "1" || lastColumn === "true") look.lastColumn = true;
+	const noHBand = getAttribute(lookElement, "w", "noHBand");
+	if (noHBand === "1" || noHBand === "true") look.noHBand = true;
+	const noVBand = getAttribute(lookElement, "w", "noVBand");
+	if (noVBand === "1" || noVBand === "true") look.noVBand = true;
+	const val = getAttribute(lookElement, "w", "val");
+	if (val) {
+		const flags = Number.parseInt(val, 16);
+		if (!Number.isNaN(flags)) {
+			if (flags & 32) look.firstRow = true;
+			if (flags & 64) look.lastRow = true;
+			if (flags & 128) look.firstColumn = true;
+			if (flags & 256) look.lastColumn = true;
+			if (flags & 512) look.noHBand = true;
+			if (flags & 1024) look.noVBand = true;
+		}
+	}
+	if (Object.keys(look).length === 0) return;
+	return look;
+}
+/**
+* Parse floating table properties (w:tblpPr)
+*
+* @param tblpPrElement - The w:tblpPr element
+* @returns Parsed floating properties or undefined
+*/
+function parseFloatingTableProperties(tblpPrElement) {
+	if (!tblpPrElement) return;
+	const floating = {};
+	const horzAnchor = getAttribute(tblpPrElement, "w", "horzAnchor");
+	if (horzAnchor === "margin" || horzAnchor === "page" || horzAnchor === "text") floating.horzAnchor = horzAnchor;
+	const vertAnchor = getAttribute(tblpPrElement, "w", "vertAnchor");
+	if (vertAnchor === "margin" || vertAnchor === "page" || vertAnchor === "text") floating.vertAnchor = vertAnchor;
+	const tblpX = parseNumericAttribute(tblpPrElement, "w", "tblpX");
+	if (tblpX !== void 0) floating.tblpX = tblpX;
+	const tblpXSpec = narrowEnum(getAttribute(tblpPrElement, "w", "tblpXSpec"), FloatingTableXSpecSchema);
+	if (tblpXSpec) floating.tblpXSpec = tblpXSpec;
+	const tblpY = parseNumericAttribute(tblpPrElement, "w", "tblpY");
+	if (tblpY !== void 0) floating.tblpY = tblpY;
+	const tblpYSpec = narrowEnum(getAttribute(tblpPrElement, "w", "tblpYSpec"), FloatingTableYSpecSchema);
+	if (tblpYSpec) floating.tblpYSpec = tblpYSpec;
+	const topFromText = parseNumericAttribute(tblpPrElement, "w", "topFromText");
+	if (topFromText !== void 0) floating.topFromText = topFromText;
+	const bottomFromText = parseNumericAttribute(tblpPrElement, "w", "bottomFromText");
+	if (bottomFromText !== void 0) floating.bottomFromText = bottomFromText;
+	const leftFromText = parseNumericAttribute(tblpPrElement, "w", "leftFromText");
+	if (leftFromText !== void 0) floating.leftFromText = leftFromText;
+	const rightFromText = parseNumericAttribute(tblpPrElement, "w", "rightFromText");
+	if (rightFromText !== void 0) floating.rightFromText = rightFromText;
+	if (Object.keys(floating).length === 0) return;
+	return floating;
+}
+/**
+* Parse table properties (w:tblPr)
+*
+* @param tblPrElement - The w:tblPr element
+* @returns Parsed table formatting
+*/
+function parseTableProperties(tblPrElement) {
+	if (!tblPrElement) return;
+	const formatting = {};
+	const width = parseWidth(findChild(tblPrElement, "w", "tblW"));
+	if (width) formatting.width = width;
+	const jcElement = findChild(tblPrElement, "w", "jc");
+	if (jcElement) {
+		const jcVal = getAttribute(jcElement, "w", "val");
+		if (jcVal === "left" || jcVal === "center" || jcVal === "right" || jcVal === "start") formatting.justification = jcVal === "start" ? "left" : jcVal;
+	}
+	const cellSpacing = parseWidth(findChild(tblPrElement, "w", "tblCellSpacing"));
+	if (cellSpacing) formatting.cellSpacing = cellSpacing;
+	const indent = parseWidth(findChild(tblPrElement, "w", "tblInd"));
+	if (indent) formatting.indent = indent;
+	const borders = parseTableBorders(findChild(tblPrElement, "w", "tblBorders"));
+	if (borders) formatting.borders = borders;
+	const cellMargins = parseCellMargins(findChild(tblPrElement, "w", "tblCellMar"));
+	if (cellMargins) formatting.cellMargins = cellMargins;
+	const layoutElement = findChild(tblPrElement, "w", "tblLayout");
+	if (layoutElement) {
+		const layoutVal = getAttribute(layoutElement, "w", "type");
+		if (layoutVal === "fixed" || layoutVal === "autofit") formatting.layout = layoutVal;
+	}
+	const styleElement = findChild(tblPrElement, "w", "tblStyle");
+	if (styleElement) {
+		const styleId = getAttribute(styleElement, "w", "val");
+		if (styleId) formatting.styleId = styleId;
+	}
+	const look = parseTableLook(findChild(tblPrElement, "w", "tblLook"));
+	if (look) formatting.look = look;
+	const shading = parseShading(findChild(tblPrElement, "w", "shd"));
+	if (shading) formatting.shading = shading;
+	const overlapElement = findChild(tblPrElement, "w", "tblOverlap");
+	if (overlapElement) {
+		const overlapVal = getAttribute(overlapElement, "w", "val");
+		if (overlapVal === "never" || overlapVal === "overlap") formatting.overlap = overlapVal;
+	}
+	const floating = parseFloatingTableProperties(findChild(tblPrElement, "w", "tblpPr"));
+	if (floating) formatting.floating = floating;
+	if (parseBooleanElement(findChild(tblPrElement, "w", "bidiVisual"))) formatting.bidi = true;
+	if (Object.keys(formatting).length === 0) return;
+	return formatting;
+}
+function parseTablePropertyChanges(tblPrElement, currentFormatting) {
+	if (!tblPrElement) return;
+	const changes = findChildren(tblPrElement, "w", "tblPrChange").map((changeElement) => {
+		const previousTblPr = findChild(changeElement, "w", "tblPr");
+		const change = {
+			type: "tablePropertyChange",
+			info: parsePropertyChangeInfo(changeElement)
+		};
+		const prev = parseTableProperties(previousTblPr);
+		if (prev !== void 0) change.previousFormatting = prev;
+		if (currentFormatting !== void 0) change.currentFormatting = currentFormatting;
+		return change;
+	}).filter((change) => change.previousFormatting || change.currentFormatting);
+	return changes.length > 0 ? changes : void 0;
+}
+function parseTableRowPropertyChanges(trPrElement, currentFormatting) {
+	if (!trPrElement) return;
+	const changes = findChildren(trPrElement, "w", "trPrChange").map((changeElement) => {
+		const previousTrPr = findChild(changeElement, "w", "trPr");
+		const change = {
+			type: "tableRowPropertyChange",
+			info: parsePropertyChangeInfo(changeElement)
+		};
+		const prev = parseTableRowProperties(previousTrPr);
+		if (prev !== void 0) change.previousFormatting = prev;
+		if (currentFormatting !== void 0) change.currentFormatting = currentFormatting;
+		return change;
+	}).filter((change) => change.previousFormatting || change.currentFormatting);
+	return changes.length > 0 ? changes : void 0;
+}
+function parseTableCellPropertyChanges(tcPrElement, currentFormatting) {
+	if (!tcPrElement) return;
+	const changes = findChildren(tcPrElement, "w", "tcPrChange").map((changeElement) => {
+		const previousTcPr = findChild(changeElement, "w", "tcPr");
+		const change = {
+			type: "tableCellPropertyChange",
+			info: parsePropertyChangeInfo(changeElement)
+		};
+		const prev = parseTableCellProperties(previousTcPr);
+		if (prev !== void 0) change.previousFormatting = prev;
+		if (currentFormatting !== void 0) change.currentFormatting = currentFormatting;
+		return change;
+	}).filter((change) => change.previousFormatting || change.currentFormatting);
+	return changes.length > 0 ? changes : void 0;
+}
+function parseTableRowStructuralChange(trPrElement) {
+	if (!trPrElement) return;
+	const insertion = findChild(trPrElement, "w", "ins");
+	if (insertion) return {
+		type: "tableRowInsertion",
+		info: parseTrackedChangeInfo(insertion)
+	};
+	const deletion = findChild(trPrElement, "w", "del");
+	if (deletion) return {
+		type: "tableRowDeletion",
+		info: parseTrackedChangeInfo(deletion)
+	};
+}
+function parseTableCellStructuralChange(tcPrElement) {
+	if (!tcPrElement) return;
+	const insertion = findChild(tcPrElement, "w", "cellIns");
+	if (insertion) return {
+		type: "tableCellInsertion",
+		info: parseTrackedChangeInfo(insertion)
+	};
+	const deletion = findChild(tcPrElement, "w", "cellDel");
+	if (deletion) return {
+		type: "tableCellDeletion",
+		info: parseTrackedChangeInfo(deletion)
+	};
+	const merge = findChild(tcPrElement, "w", "cellMerge");
+	if (merge) return {
+		type: "tableCellMerge",
+		info: parseTrackedChangeInfo(merge)
+	};
+}
+/**
+* Parse table row properties (w:trPr)
+*
+* @param trPrElement - The w:trPr element
+* @returns Parsed row formatting
+*/
+function parseTableRowProperties(trPrElement) {
+	if (!trPrElement) return;
+	const formatting = {};
+	const heightElement = findChild(trPrElement, "w", "trHeight");
+	if (heightElement) {
+		const heightVal = parseNumericAttribute(heightElement, "w", "val");
+		if (heightVal !== void 0 && heightVal > 0) formatting.height = {
+			value: heightVal,
+			type: "dxa"
+		};
+		const hRule = getAttribute(heightElement, "w", "hRule");
+		if (hRule === "auto" || hRule === "atLeast" || hRule === "exact") formatting.heightRule = hRule;
+	}
+	if (parseBooleanElement(findChild(trPrElement, "w", "tblHeader"))) formatting.header = true;
+	if (parseBooleanElement(findChild(trPrElement, "w", "cantSplit"))) formatting.cantSplit = true;
+	const jcElement = findChild(trPrElement, "w", "jc");
+	if (jcElement) {
+		const jcVal = getAttribute(jcElement, "w", "val");
+		if (jcVal === "left" || jcVal === "center" || jcVal === "right") formatting.justification = jcVal;
+	}
+	if (parseBooleanElement(findChild(trPrElement, "w", "hidden"))) formatting.hidden = true;
+	const conditionalFormat = parseConditionalFormatStyle(findChild(trPrElement, "w", "cnfStyle"));
+	if (conditionalFormat) formatting.conditionalFormat = conditionalFormat;
+	if (Object.keys(formatting).length === 0) return;
+	return formatting;
+}
+/**
+* Parse conditional format style (for table style conditional formatting)
+*
+* @param cnfElement - The w:cnfStyle element
+* @returns Parsed conditional format or undefined
+*/
+function parseConditionalFormatStyle(cnfElement) {
+	if (!cnfElement) return;
+	const style = {};
+	const firstRow = getAttribute(cnfElement, "w", "firstRow");
+	if (firstRow === "1" || firstRow === "true") style.firstRow = true;
+	const lastRow = getAttribute(cnfElement, "w", "lastRow");
+	if (lastRow === "1" || lastRow === "true") style.lastRow = true;
+	const firstColumn = getAttribute(cnfElement, "w", "firstColumn");
+	if (firstColumn === "1" || firstColumn === "true") style.firstColumn = true;
+	const lastColumn = getAttribute(cnfElement, "w", "lastColumn");
+	if (lastColumn === "1" || lastColumn === "true") style.lastColumn = true;
+	const oddHBand = getAttribute(cnfElement, "w", "oddHBand");
+	if (oddHBand === "1" || oddHBand === "true") style.oddHBand = true;
+	const evenHBand = getAttribute(cnfElement, "w", "evenHBand");
+	if (evenHBand === "1" || evenHBand === "true") style.evenHBand = true;
+	const oddVBand = getAttribute(cnfElement, "w", "oddVBand");
+	if (oddVBand === "1" || oddVBand === "true") style.oddVBand = true;
+	const evenVBand = getAttribute(cnfElement, "w", "evenVBand");
+	if (evenVBand === "1" || evenVBand === "true") style.evenVBand = true;
+	const nwCell = getAttribute(cnfElement, "w", "firstRowFirstColumn");
+	if (nwCell === "1" || nwCell === "true") style.nwCell = true;
+	const neCell = getAttribute(cnfElement, "w", "firstRowLastColumn");
+	if (neCell === "1" || neCell === "true") style.neCell = true;
+	const swCell = getAttribute(cnfElement, "w", "lastRowFirstColumn");
+	if (swCell === "1" || swCell === "true") style.swCell = true;
+	const seCell = getAttribute(cnfElement, "w", "lastRowLastColumn");
+	if (seCell === "1" || seCell === "true") style.seCell = true;
+	const val = getAttribute(cnfElement, "w", "val");
+	if (val && val.length === 12) {
+		if (val[0] === "1") style.firstRow = true;
+		if (val[1] === "1") style.lastRow = true;
+		if (val[2] === "1") style.firstColumn = true;
+		if (val[3] === "1") style.lastColumn = true;
+		if (val[4] === "1") style.oddVBand = true;
+		if (val[5] === "1") style.evenVBand = true;
+		if (val[6] === "1") style.oddHBand = true;
+		if (val[7] === "1") style.evenHBand = true;
+		if (val[8] === "1") style.nwCell = true;
+		if (val[9] === "1") style.neCell = true;
+		if (val[10] === "1") style.swCell = true;
+		if (val[11] === "1") style.seCell = true;
+	}
+	if (Object.keys(style).length === 0) return;
+	return style;
+}
+/**
+* Parse table cell properties (w:tcPr)
+*
+* @param tcPrElement - The w:tcPr element
+* @returns Parsed cell formatting
+*/
+function parseTableCellProperties(tcPrElement) {
+	if (!tcPrElement) return;
+	const formatting = {};
+	const width = parseWidth(findChild(tcPrElement, "w", "tcW"));
+	if (width) formatting.width = width;
+	const borders = parseTableBorders(findChild(tcPrElement, "w", "tcBorders"));
+	if (borders) formatting.borders = borders;
+	const margins = parseCellMargins(findChild(tcPrElement, "w", "tcMar"));
+	if (margins) formatting.margins = margins;
+	const shading = parseShading(findChild(tcPrElement, "w", "shd"));
+	if (shading) formatting.shading = shading;
+	const vAlignElement = findChild(tcPrElement, "w", "vAlign");
+	if (vAlignElement) {
+		const vAlign = getAttribute(vAlignElement, "w", "val");
+		if (vAlign === "top" || vAlign === "center" || vAlign === "bottom") formatting.verticalAlign = vAlign;
+	}
+	const textDirElement = findChild(tcPrElement, "w", "textDirection");
+	if (textDirElement) {
+		const textDir = narrowEnum(getAttribute(textDirElement, "w", "val"), TableCellTextDirectionSchema);
+		if (textDir) formatting.textDirection = textDir;
+	}
+	const gridSpanElement = findChild(tcPrElement, "w", "gridSpan");
+	if (gridSpanElement) {
+		const gridSpan = parseNumericAttribute(gridSpanElement, "w", "val");
+		if (gridSpan !== void 0 && gridSpan > 1) formatting.gridSpan = gridSpan;
+	}
+	const vMergeElement = findChild(tcPrElement, "w", "vMerge");
+	if (vMergeElement) if (getAttribute(vMergeElement, "w", "val") === "restart") formatting.vMerge = "restart";
+	else formatting.vMerge = "continue";
+	if (parseBooleanElement(findChild(tcPrElement, "w", "tcFitText"))) formatting.fitText = true;
+	if (parseBooleanElement(findChild(tcPrElement, "w", "noWrap"))) formatting.noWrap = true;
+	if (parseBooleanElement(findChild(tcPrElement, "w", "hideMark"))) formatting.hideMark = true;
+	const conditionalFormat = parseConditionalFormatStyle(findChild(tcPrElement, "w", "cnfStyle"));
+	if (conditionalFormat) formatting.conditionalFormat = conditionalFormat;
+	if (Object.keys(formatting).length === 0) return;
+	return formatting;
+}
+/**
+* Accumulate a table container's own `xmlns:*` onto the inherited in-scope set,
+* so a `w:pict` nested inside a cell still resolves prefixes scoped on the
+* `w:tbl` / `w:tr` / `w:tc` wrapper.
+*/
+function withContainerXmlns(options, element) {
+	return {
+		...options,
+		rootXmlns: mergeXmlnsDeclarations(options?.rootXmlns ?? {}, element)
+	};
+}
+function parseCellContent(tcElement, styles, theme, numbering, rels, media, options) {
+	const content = [];
+	const pendingBookmarkMarkers = [];
+	const elements = getChildElements(tcElement);
+	for (const child of elements) {
+		if (!child.name) continue;
+		const localName = getLocalName(child.name);
+		if (localName === "p") {
+			const para = parseParagraph(child, styles, theme, numbering, rels, media, options);
+			prependPendingBookmarkMarkers(para, pendingBookmarkMarkers);
+			content.push(para);
+		} else if (localName === "tbl") {
+			const table = parseTable(child, styles, theme, numbering, rels, media, options);
+			if (prependBookmarkMarkersToFirstParagraphInBlocks([table], pendingBookmarkMarkers)) pendingBookmarkMarkers.length = 0;
+			content.push(table);
+		} else if (localName === "bookmarkStart" || localName === "bookmarkEnd") {
+			const marker = parseBookmarkMarker(child, localName);
+			if (!appendBookmarkMarkerToLastParagraphInBlocks(content, marker)) pendingBookmarkMarkers.push(marker);
+		}
+	}
+	if (content.length === 0) content.push({
+		type: "paragraph",
+		content: [...pendingBookmarkMarkers]
+	});
+	else if (pendingBookmarkMarkers.length > 0) appendBookmarkMarkersToLastParagraphInBlocks(content, pendingBookmarkMarkers);
+	return content;
+}
+/**
+* Parse a table cell (w:tc)
+*
+* @param tcElement - The w:tc element
+* @param styles - Style definitions
+* @param theme - Theme for color/font resolution
+* @param numbering - Numbering definitions for lists
+* @param rels - Relationships for hyperlinks
+* @param media - Media files for images
+* @returns Parsed table cell
+*/
+function parseTableCell(tcElement, styles, theme, numbering, rels, media, options) {
+	const cell = {
+		type: "tableCell",
+		content: []
+	};
+	const tcPrElement = findChild(tcElement, "w", "tcPr");
+	const formatting = parseTableCellProperties(tcPrElement);
+	if (formatting) cell.formatting = formatting;
+	const cellPropChanges = parseTableCellPropertyChanges(tcPrElement, formatting);
+	if (cellPropChanges !== void 0) cell.propertyChanges = cellPropChanges;
+	const cellStructChange = parseTableCellStructuralChange(tcPrElement);
+	if (cellStructChange !== void 0) cell.structuralChange = cellStructChange;
+	cell.content = parseCellContent(tcElement, styles, theme, numbering, rels, media, withContainerXmlns(options, tcElement));
+	return cell;
+}
+/**
+* Parse a table row (w:tr)
+*
+* @param trElement - The w:tr element
+* @param styles - Style definitions
+* @param theme - Theme for color/font resolution
+* @param numbering - Numbering definitions for lists
+* @param rels - Relationships for hyperlinks
+* @param media - Media files for images
+* @returns Parsed table row
+*/
+function parseTableRow(trElement, styles, theme, numbering, rels, media, options) {
+	const row = {
+		type: "tableRow",
+		cells: []
+	};
+	const trPrElement = findChild(trElement, "w", "trPr");
+	const formatting = parseTableRowProperties(trPrElement);
+	if (formatting) row.formatting = formatting;
+	const rowPropChanges = parseTableRowPropertyChanges(trPrElement, formatting);
+	if (rowPropChanges !== void 0) row.propertyChanges = rowPropChanges;
+	const rowStructChange = parseTableRowStructuralChange(trPrElement);
+	if (rowStructChange !== void 0) row.structuralChange = rowStructChange;
+	const rowOptions = withContainerXmlns(options, trElement);
+	const pendingBookmarkMarkers = [];
+	const parseRowChild = (child) => {
+		const localName = getLocalName(child.name);
+		if (localName === "tc") {
+			const cell = parseTableCell(child, styles, theme, numbering, rels, media, rowOptions);
+			if (pendingBookmarkMarkers.length > 0) {
+				prependBookmarkMarkersToFirstParagraphInCell(cell, pendingBookmarkMarkers);
+				pendingBookmarkMarkers.length = 0;
+			}
+			row.cells.push(cell);
+			return;
+		}
+		if (localName === "sdt") {
+			const sdtContent = findChildByLocalName(child, "sdtContent");
+			if (!sdtContent) return;
+			for (const sdtChild of getChildElements(sdtContent)) parseRowChild(sdtChild);
+			return;
+		}
+		if (localName !== "bookmarkStart" && localName !== "bookmarkEnd") return;
+		const marker = parseBookmarkMarker(child, localName);
+		if (!appendBookmarkMarkerToLastParagraphInCells(row.cells, marker)) pendingBookmarkMarkers.push(marker);
+	};
+	for (const child of getChildElements(trElement)) parseRowChild(child);
+	if (pendingBookmarkMarkers.length > 0) appendBookmarkMarkersToLastCell(row, pendingBookmarkMarkers);
+	return row;
+}
+function getLocalName(name) {
+	if (!name) return "";
+	const colonIndex = name.indexOf(":");
+	return colonIndex === -1 ? name : name.slice(colonIndex + 1);
+}
+function parseBookmarkMarker(child, localName) {
+	if (localName === "bookmarkStart") return parseBookmarkStart(child);
+	return parseBookmarkEnd(child);
+}
+function prependPendingBookmarkMarkers(paragraph, pendingBookmarkMarkers) {
+	if (pendingBookmarkMarkers.length === 0) return;
+	paragraph.content.unshift(...pendingBookmarkMarkers);
+	pendingBookmarkMarkers.length = 0;
+}
+function appendBookmarkMarkersToLastParagraphInBlocks(blocks, markers) {
+	for (const marker of markers) appendBookmarkMarkerToLastParagraphInBlocks(blocks, marker);
+}
+function appendBookmarkMarkersToLastCell(row, markers) {
+	const lastCell = row.cells.at(-1);
+	if (!lastCell) return;
+	for (const marker of markers) appendBookmarkMarkerToLastParagraphInBlocks(lastCell.content, marker);
+}
+/**
+* Parse table grid (w:tblGrid) for column widths
+*
+* @param tblGridElement - The w:tblGrid element
+* @returns Array of column widths in twips
+*/
+function parseTableGrid(tblGridElement) {
+	if (!tblGridElement) return;
+	const widths = [];
+	const gridCols = findChildren(tblGridElement, "w", "gridCol");
+	for (const col of gridCols) {
+		const width = parseNumericAttribute(col, "w", "w") ?? 0;
+		widths.push(width);
+	}
+	if (widths.length > 0 && widths.every((width) => width <= 0)) return;
+	return widths.length > 0 ? widths : void 0;
+}
+function hasRowGridOffsets(rowElement) {
+	const trPrElement = findChild(rowElement, "w", "trPr");
+	if (!trPrElement) return false;
+	const gridBefore = parseNumericAttribute(findChild(trPrElement, "w", "gridBefore"), "w", "val") ?? 0;
+	const gridAfter = parseNumericAttribute(findChild(trPrElement, "w", "gridAfter"), "w", "val") ?? 0;
+	return gridBefore > 0 || gridAfter > 0;
+}
+function getTableGridWidth(table) {
+	const totalWidth = table.columnWidths?.reduce((sum, width) => sum + width, 0);
+	if (!totalWidth || totalWidth <= 0) return null;
+	return totalWidth;
+}
+function cellWidthCoversTableGrid(cell, tableGridWidth) {
+	const width = cell.formatting?.width;
+	if (!width || width.type !== "dxa" || tableGridWidth === null) return false;
+	return width.value >= tableGridWidth;
+}
+function inferImplicitSingleCellRowSpans(table, rowsWithGridOffsets) {
+	const gridColumnCount = table.columnWidths?.length ?? 0;
+	if (gridColumnCount <= 1) return;
+	const tableGridWidth = getTableGridWidth(table);
+	if (tableGridWidth === null) return;
+	for (const [rowIndex, row] of table.rows.entries()) {
+		if (row.cells.length !== 1) continue;
+		if (rowsWithGridOffsets.has(rowIndex)) continue;
+		const cell = row.cells.at(0);
+		if (!cell) continue;
+		if ((cell.formatting?.gridSpan ?? 1) >= gridColumnCount) continue;
+		if (cell.formatting?.vMerge) continue;
+		if (cell.formatting?.gridSpan != null) continue;
+		if (!cellWidthCoversTableGrid(cell, tableGridWidth)) continue;
+		cell.formatting = {
+			...cell.formatting,
+			gridSpan: gridColumnCount
+		};
+	}
+}
+/**
+* Parse a table element (w:tbl)
+*
+* @param tblElement - The w:tbl element
+* @param styles - Style definitions
+* @param theme - Theme for color/font resolution
+* @param numbering - Numbering definitions for lists
+* @param rels - Relationships for hyperlinks
+* @param media - Media files for images
+* @returns Parsed table
+*/
+function parseTable(tblElement, styles, theme, numbering, rels, media, options) {
+	const table = {
+		type: "table",
+		rows: []
+	};
+	const tblPrElement = findChild(tblElement, "w", "tblPr");
+	const formatting = parseTableProperties(tblPrElement);
+	if (formatting) table.formatting = formatting;
+	const tblPropChanges = parseTablePropertyChanges(tblPrElement, formatting);
+	if (tblPropChanges !== void 0) table.propertyChanges = tblPropChanges;
+	const columnWidths = parseTableGrid(findChild(tblElement, "w", "tblGrid"));
+	if (columnWidths) table.columnWidths = columnWidths;
+	const tableOptions = withContainerXmlns(options, tblElement);
+	const rowsWithGridOffsets = /* @__PURE__ */ new Set();
+	const parseTableChild = (child) => {
+		const localName = getLocalName(child.name);
+		if (localName === "tr") {
+			const rowIndex = table.rows.length;
+			const row = parseTableRow(child, styles, theme, numbering, rels, media, tableOptions);
+			table.rows.push(row);
+			if (hasRowGridOffsets(child)) rowsWithGridOffsets.add(rowIndex);
+			return;
+		}
+		if (localName !== "sdt") return;
+		const sdtContent = findChildByLocalName(child, "sdtContent");
+		if (!sdtContent) return;
+		for (const sdtChild of getChildElements(sdtContent)) parseTableChild(sdtChild);
+	};
+	for (const child of getChildElements(tblElement)) parseTableChild(child);
+	inferImplicitSingleCellRowSpans(table, rowsWithGridOffsets);
+	return table;
+}
+/**
+* Get the number of columns in a table
+*
+* Uses the table grid if available, otherwise counts cells in first row.
+*
+* @param table - The table to measure
+* @returns Number of columns
+*/
+function getTableColumnCount(table) {
+	if (table.columnWidths && table.columnWidths.length > 0) return table.columnWidths.length;
+	if (table.rows.length === 0) return 0;
+	return table.rows[0].cells.reduce((count, cell) => count + (cell.formatting?.gridSpan ?? 1), 0);
+}
+/**
+* Get the number of rows in a table
+*
+* @param table - The table to measure
+* @returns Number of rows
+*/
+function getTableRowCount(table) {
+	return table.rows.length;
+}
+/**
+* Check if a cell is part of a vertical merge
+*
+* @param cell - The cell to check
+* @returns true if cell continues a vertical merge
+*/
+function isCellMergeContinuation(cell) {
+	return cell.formatting?.vMerge === "continue";
+}
+/**
+* Check if a cell starts a vertical merge
+*
+* @param cell - The cell to check
+* @returns true if cell starts a vertical merge
+*/
+function isCellMergeStart(cell) {
+	return cell.formatting?.vMerge === "restart";
+}
+/**
+* Check if a cell spans multiple columns
+*
+* @param cell - The cell to check
+* @returns true if cell spans multiple columns
+*/
+function isCellHorizontallyMerged(cell) {
+	return (cell.formatting?.gridSpan ?? 1) > 1;
+}
+/**
+* Get the plain text content of a table
+*
+* @param table - The table to extract text from
+* @returns Plain text content
+*/
+function getTableText(table) {
+	const rows = [];
+	for (const row of table.rows) {
+		const cells = [];
+		for (const cell of row.cells) {
+			const cellText = cell.content.filter((c) => c.type === "paragraph").map((p) => getParagraphText(p)).join("\n");
+			cells.push(cellText);
+		}
+		rows.push(cells.join("	"));
+	}
+	return rows.join("\n");
+}
+/**
+* Helper to get paragraph text (simplified)
+*/
+function getParagraphText(para) {
+	return para.content.filter((c) => "content" in c).flatMap((run) => {
+		if (!("content" in run) || !Array.isArray(run.content)) return [];
+		return run.content.filter((c) => typeof c === "object" && c !== null && "type" in c && c.type === "text" && "text" in c).map((c) => c.text);
+	}).join("");
+}
+/**
+* Check if table has header row
+*
+* @param table - The table to check
+* @returns true if first row is marked as header
+*/
+function hasHeaderRow(table) {
+	if (table.rows.length === 0) return false;
+	return table.rows[0].formatting?.header === true;
+}
+/**
+* Get all header rows from a table
+*
+* @param table - The table to search
+* @returns Array of header rows
+*/
+function getHeaderRows(table) {
+	return table.rows.filter((row) => row.formatting?.header === true);
+}
+/**
+* Check if table is a floating table
+*
+* @param table - The table to check
+* @returns true if table has floating properties
+*/
+function isFloatingTable(table) {
+	return table.formatting?.floating !== void 0;
+}
+//#endregion
+export { getHeaderRows, getTableColumnCount, getTableRowCount, getTableText, hasHeaderRow, isCellHorizontallyMerged, isCellMergeContinuation, isCellMergeStart, isFloatingTable, parseBorderSpec, parseCellMargins, parseConditionalFormatStyle, parseFloatingTableProperties, parseShading, parseTable, parseTableBorders, parseTableCell, parseTableCellProperties, parseTableGrid, parseTableLook, parseTableMeasurement, parseTableProperties, parseTableRow, parseTableRowProperties };