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

package/dist/docx/serializer/tableSerializer.js

@@ -0,0 +1,422 @@
+import { escapeXml, intAttr } from "./xmlUtils.js";
+import { serializeBorder } from "./borderSerializer.js";
+import { serializeParagraph } from "./paragraphSerializer.js";
+//#region src/docx/serializer/tableSerializer.ts
+function normalizeTrackedChangeInfo(info) {
+	const normalizedId = Number.isInteger(info.id) && info.id >= 0 ? info.id : 0;
+	const authorCandidate = typeof info.author === "string" ? info.author.trim() : "";
+	const normalizedAuthor = authorCandidate.length > 0 ? authorCandidate : "Unknown";
+	const normalizedDate = typeof info.date === "string" ? info.date.trim() : void 0;
+	return {
+		id: normalizedId,
+		author: normalizedAuthor,
+		...normalizedDate !== void 0 ? { date: normalizedDate } : {}
+	};
+}
+function serializeTrackedChangeAttributes(info, rsid) {
+	const normalized = normalizeTrackedChangeInfo(info);
+	const attrs = [`w:id="${normalized.id}"`, `w:author="${escapeXml(normalized.author)}"`];
+	if (normalized.date) attrs.push(`w:date="${escapeXml(normalized.date)}"`);
+	if (rsid && rsid.trim().length > 0) attrs.push(`w:rsid="${escapeXml(rsid.trim())}"`);
+	return attrs.join(" ");
+}
+/**
+* Serialize a table measurement (width, height)
+*/
+function serializeMeasurement(measurement, elementName) {
+	if (!measurement) return "";
+	return `<w:${elementName} ${[`w:w="${intAttr(measurement.value)}"`, `w:type="${measurement.type}"`].join(" ")}/>`;
+}
+/**
+* Serialize table borders (w:tblBorders or w:tcBorders)
+*/
+function serializeTableBorders(borders, elementName) {
+	if (!borders) return "";
+	const parts = [];
+	if (borders.top) {
+		const topXml = serializeBorder(borders.top, "top");
+		if (topXml) parts.push(topXml);
+	}
+	if (borders.left) {
+		const leftXml = serializeBorder(borders.left, "left");
+		if (leftXml) parts.push(leftXml);
+	}
+	if (borders.bottom) {
+		const bottomXml = serializeBorder(borders.bottom, "bottom");
+		if (bottomXml) parts.push(bottomXml);
+	}
+	if (borders.right) {
+		const rightXml = serializeBorder(borders.right, "right");
+		if (rightXml) parts.push(rightXml);
+	}
+	if (borders.insideH) {
+		const insideHXml = serializeBorder(borders.insideH, "insideH");
+		if (insideHXml) parts.push(insideHXml);
+	}
+	if (borders.insideV) {
+		const insideVXml = serializeBorder(borders.insideV, "insideV");
+		if (insideVXml) parts.push(insideVXml);
+	}
+	if (parts.length === 0) return "";
+	return `<w:${elementName}>${parts.join("")}</w:${elementName}>`;
+}
+/**
+* Serialize cell margins (w:tblCellMar or w:tcMar)
+*/
+function serializeCellMargins(margins, elementName) {
+	if (!margins) return "";
+	const parts = [];
+	if (margins.top) parts.push(serializeMeasurement(margins.top, "top"));
+	if (margins.left) parts.push(serializeMeasurement(margins.left, "left"));
+	if (margins.bottom) parts.push(serializeMeasurement(margins.bottom, "bottom"));
+	if (margins.right) parts.push(serializeMeasurement(margins.right, "right"));
+	if (parts.length === 0) return "";
+	return `<w:${elementName}>${parts.join("")}</w:${elementName}>`;
+}
+/**
+* Serialize shading properties (w:shd)
+*/
+function serializeShading(shading) {
+	if (!shading) return "";
+	const attrs = [];
+	if (shading.pattern) attrs.push(`w:val="${shading.pattern}"`);
+	else attrs.push("w:val=\"clear\"");
+	if (shading.color?.rgb) attrs.push(`w:color="${shading.color.rgb}"`);
+	else if (shading.color?.auto) attrs.push("w:color=\"auto\"");
+	if (shading.fill?.rgb) attrs.push(`w:fill="${shading.fill.rgb}"`);
+	else if (shading.fill?.auto) attrs.push("w:fill=\"auto\"");
+	if (shading.fill?.themeColor) attrs.push(`w:themeFill="${shading.fill.themeColor}"`);
+	if (shading.fill?.themeTint) attrs.push(`w:themeFillTint="${shading.fill.themeTint}"`);
+	if (shading.fill?.themeShade) attrs.push(`w:themeFillShade="${shading.fill.themeShade}"`);
+	if (attrs.length === 0) return "";
+	return `<w:shd ${attrs.join(" ")}/>`;
+}
+/**
+* Serialize table look flags (w:tblLook)
+*/
+function serializeTableLook(look) {
+	if (!look) return "";
+	const attrs = [];
+	if (look.firstRow) attrs.push("w:firstRow=\"1\"");
+	if (look.lastRow) attrs.push("w:lastRow=\"1\"");
+	if (look.firstColumn) attrs.push("w:firstColumn=\"1\"");
+	if (look.lastColumn) attrs.push("w:lastColumn=\"1\"");
+	if (look.noHBand) attrs.push("w:noHBand=\"1\"");
+	if (look.noVBand) attrs.push("w:noVBand=\"1\"");
+	if (attrs.length === 0) return "";
+	return `<w:tblLook ${attrs.join(" ")}/>`;
+}
+/**
+* Serialize floating table properties (w:tblpPr)
+*/
+function serializeFloatingTableProperties(floating) {
+	if (!floating) return "";
+	const attrs = [];
+	if (floating.horzAnchor) attrs.push(`w:horzAnchor="${floating.horzAnchor}"`);
+	if (floating.vertAnchor) attrs.push(`w:vertAnchor="${floating.vertAnchor}"`);
+	if (floating.tblpX !== void 0) attrs.push(`w:tblpX="${intAttr(floating.tblpX)}"`);
+	if (floating.tblpXSpec) attrs.push(`w:tblpXSpec="${floating.tblpXSpec}"`);
+	if (floating.tblpY !== void 0) attrs.push(`w:tblpY="${intAttr(floating.tblpY)}"`);
+	if (floating.tblpYSpec) attrs.push(`w:tblpYSpec="${floating.tblpYSpec}"`);
+	if (floating.topFromText !== void 0) attrs.push(`w:topFromText="${intAttr(floating.topFromText)}"`);
+	if (floating.bottomFromText !== void 0) attrs.push(`w:bottomFromText="${intAttr(floating.bottomFromText)}"`);
+	if (floating.leftFromText !== void 0) attrs.push(`w:leftFromText="${intAttr(floating.leftFromText)}"`);
+	if (floating.rightFromText !== void 0) attrs.push(`w:rightFromText="${intAttr(floating.rightFromText)}"`);
+	if (attrs.length === 0) return "";
+	return `<w:tblpPr ${attrs.join(" ")}/>`;
+}
+/**
+* Serialize table formatting properties (w:tblPr)
+*/
+function serializeTableFormatting(formatting, propertyChanges) {
+	const parts = [];
+	if (formatting) {
+		if (formatting.styleId) parts.push(`<w:tblStyle w:val="${escapeXml(formatting.styleId)}"/>`);
+		const floatingXml = serializeFloatingTableProperties(formatting.floating);
+		if (floatingXml) parts.push(floatingXml);
+		if (formatting.bidi) parts.push("<w:bidiVisual/>");
+		const widthXml = serializeMeasurement(formatting.width, "tblW");
+		if (widthXml) parts.push(widthXml);
+		if (formatting.justification) parts.push(`<w:jc w:val="${formatting.justification}"/>`);
+		const cellSpacingXml = serializeMeasurement(formatting.cellSpacing, "tblCellSpacing");
+		if (cellSpacingXml) parts.push(cellSpacingXml);
+		const indentXml = serializeMeasurement(formatting.indent, "tblInd");
+		if (indentXml) parts.push(indentXml);
+		const bordersXml = serializeTableBorders(formatting.borders, "tblBorders");
+		if (bordersXml) parts.push(bordersXml);
+		const marginsXml = serializeCellMargins(formatting.cellMargins, "tblCellMar");
+		if (marginsXml) parts.push(marginsXml);
+		if (formatting.layout) parts.push(`<w:tblLayout w:type="${formatting.layout}"/>`);
+		const shadingXml = serializeShading(formatting.shading);
+		if (shadingXml) parts.push(shadingXml);
+		const lookXml = serializeTableLook(formatting.look);
+		if (lookXml) parts.push(lookXml);
+		if (formatting.overlap) parts.push(`<w:tblOverlap w:val="${formatting.overlap}"/>`);
+	}
+	if (propertyChanges && propertyChanges.length > 0) parts.push(...propertyChanges.map((change) => serializeTablePropertyChange(change)));
+	if (parts.length === 0) return "";
+	return `<w:tblPr>${parts.join("")}</w:tblPr>`;
+}
+function extractTblPrInner(tblPrXml) {
+	if (!tblPrXml.startsWith("<w:tblPr>") || !tblPrXml.endsWith("</w:tblPr>")) return "";
+	return tblPrXml.slice(9, -10);
+}
+function serializeTablePropertyChange(change) {
+	const attrs = serializeTrackedChangeAttributes(change.info, change.info.rsid);
+	const previousTblPrInner = extractTblPrInner(serializeTableFormatting(change.previousFormatting) || "<w:tblPr/>");
+	return `<w:tblPrChange ${attrs}>${previousTblPrInner.length > 0 ? `<w:tblPr>${previousTblPrInner}</w:tblPr>` : "<w:tblPr/>"}</w:tblPrChange>`;
+}
+/**
+* Serialize table row formatting properties (w:trPr)
+*/
+function serializeTableRowFormatting(formatting, propertyChanges, structuralChange) {
+	const parts = [];
+	if (formatting) {
+		if (formatting.cantSplit) parts.push("<w:cantSplit/>");
+		if (formatting.header) parts.push("<w:tblHeader/>");
+		if (formatting.height) {
+			const attrs = [`w:val="${intAttr(formatting.height.value)}"`];
+			if (formatting.heightRule) attrs.push(`w:hRule="${formatting.heightRule}"`);
+			parts.push(`<w:trHeight ${attrs.join(" ")}/>`);
+		}
+		if (formatting.justification) parts.push(`<w:jc w:val="${formatting.justification}"/>`);
+		if (formatting.hidden) parts.push("<w:hidden/>");
+	}
+	if (structuralChange) {
+		if (structuralChange.type === "tableRowInsertion") parts.push(`<w:ins ${serializeTrackedChangeAttributes(structuralChange.info)}/>`);
+		else if (structuralChange.type === "tableRowDeletion") parts.push(`<w:del ${serializeTrackedChangeAttributes(structuralChange.info)}/>`);
+	}
+	if (propertyChanges && propertyChanges.length > 0) parts.push(...propertyChanges.map((change) => serializeTableRowPropertyChange(change)));
+	if (parts.length === 0) return "";
+	return `<w:trPr>${parts.join("")}</w:trPr>`;
+}
+function extractTrPrInner(trPrXml) {
+	if (!trPrXml.startsWith("<w:trPr>") || !trPrXml.endsWith("</w:trPr>")) return "";
+	return trPrXml.slice(8, -9);
+}
+function serializeTableRowPropertyChange(change) {
+	const attrs = serializeTrackedChangeAttributes(change.info, change.info.rsid);
+	const previousTrPrInner = extractTrPrInner(serializeTableRowFormatting(change.previousFormatting) || "<w:trPr/>");
+	return `<w:trPrChange ${attrs}>${previousTrPrInner.length > 0 ? `<w:trPr>${previousTrPrInner}</w:trPr>` : "<w:trPr/>"}</w:trPrChange>`;
+}
+/**
+* Serialize conditional format style (w:cnfStyle)
+*/
+function serializeConditionalFormatStyle(style) {
+	if (!style) return "";
+	const val = [
+		style.firstRow ? "1" : "0",
+		style.lastRow ? "1" : "0",
+		style.firstColumn ? "1" : "0",
+		style.lastColumn ? "1" : "0",
+		style.oddVBand ? "1" : "0",
+		style.evenVBand ? "1" : "0",
+		style.oddHBand ? "1" : "0",
+		style.evenHBand ? "1" : "0",
+		style.nwCell ? "1" : "0",
+		style.neCell ? "1" : "0",
+		style.swCell ? "1" : "0",
+		style.seCell ? "1" : "0"
+	].join("");
+	if (val === "000000000000") return "";
+	return `<w:cnfStyle w:val="${val}"/>`;
+}
+/**
+* Serialize table cell formatting properties (w:tcPr)
+*/
+function serializeTableCellFormatting(formatting, propertyChanges, structuralChange) {
+	const parts = [];
+	if (formatting) {
+		const cnfStyleXml = serializeConditionalFormatStyle(formatting.conditionalFormat);
+		if (cnfStyleXml) parts.push(cnfStyleXml);
+		const widthXml = serializeMeasurement(formatting.width, "tcW");
+		if (widthXml) parts.push(widthXml);
+		if (formatting.gridSpan && formatting.gridSpan > 1) parts.push(`<w:gridSpan w:val="${intAttr(formatting.gridSpan)}"/>`);
+		if (formatting.vMerge) if (formatting.vMerge === "restart") parts.push("<w:vMerge w:val=\"restart\"/>");
+		else parts.push("<w:vMerge/>");
+		const bordersXml = serializeTableBorders(formatting.borders, "tcBorders");
+		if (bordersXml) parts.push(bordersXml);
+		const shadingXml = serializeShading(formatting.shading);
+		if (shadingXml) parts.push(shadingXml);
+		if (formatting.noWrap) parts.push("<w:noWrap/>");
+		const marginsXml = serializeCellMargins(formatting.margins, "tcMar");
+		if (marginsXml) parts.push(marginsXml);
+		if (formatting.textDirection) parts.push(`<w:textDirection w:val="${formatting.textDirection}"/>`);
+		if (formatting.fitText) parts.push("<w:tcFitText/>");
+		if (formatting.verticalAlign) parts.push(`<w:vAlign w:val="${formatting.verticalAlign}"/>`);
+		if (formatting.hideMark) parts.push("<w:hideMark/>");
+	}
+	if (structuralChange) {
+		if (structuralChange.type === "tableCellInsertion") parts.push(`<w:cellIns ${serializeTrackedChangeAttributes(structuralChange.info)}/>`);
+		else if (structuralChange.type === "tableCellDeletion") parts.push(`<w:cellDel ${serializeTrackedChangeAttributes(structuralChange.info)}/>`);
+		else if (structuralChange.type === "tableCellMerge") parts.push(`<w:cellMerge ${serializeTrackedChangeAttributes(structuralChange.info)}/>`);
+	}
+	if (propertyChanges && propertyChanges.length > 0) parts.push(...propertyChanges.map((change) => serializeTableCellPropertyChange(change)));
+	if (parts.length === 0) return "";
+	return `<w:tcPr>${parts.join("")}</w:tcPr>`;
+}
+function extractTcPrInner(tcPrXml) {
+	if (!tcPrXml.startsWith("<w:tcPr>") || !tcPrXml.endsWith("</w:tcPr>")) return "";
+	return tcPrXml.slice(8, -9);
+}
+function serializeTableCellPropertyChange(change) {
+	const attrs = serializeTrackedChangeAttributes(change.info, change.info.rsid);
+	const previousTcPrInner = extractTcPrInner(serializeTableCellFormatting(change.previousFormatting) || "<w:tcPr/>");
+	return `<w:tcPrChange ${attrs}>${previousTcPrInner.length > 0 ? `<w:tcPr>${previousTcPrInner}</w:tcPr>` : "<w:tcPr/>"}</w:tcPrChange>`;
+}
+/**
+* Serialize table grid (w:tblGrid)
+*/
+function serializeTableGrid(columnWidths) {
+	if (!columnWidths || columnWidths.length === 0) return "";
+	return `<w:tblGrid>${columnWidths.map((w) => `<w:gridCol w:w="${intAttr(w)}"/>`).join("")}</w:tblGrid>`;
+}
+/**
+* Serialize cell content (paragraphs, nested tables)
+*/
+function serializeCellContent(content) {
+	const parts = [];
+	for (const item of content) if (item.type === "paragraph") parts.push(serializeParagraph(item));
+	else parts.push(serializeTable(item));
+	if (parts.length === 0) parts.push("<w:p/>");
+	return parts.join("");
+}
+/**
+* Serialize a table cell (w:tc)
+*/
+function serializeTableCell(cell) {
+	const parts = [];
+	const tcPrXml = serializeTableCellFormatting(cell.formatting, cell.propertyChanges, cell.structuralChange);
+	if (tcPrXml) parts.push(tcPrXml);
+	parts.push(serializeCellContent(cell.content));
+	return `<w:tc>${parts.join("")}</w:tc>`;
+}
+/**
+* Serialize a table row (w:tr)
+*/
+function serializeTableRow(row) {
+	const parts = [];
+	const trPrXml = serializeTableRowFormatting(row.formatting, row.propertyChanges, row.structuralChange);
+	if (trPrXml) parts.push(trPrXml);
+	for (const cell of row.cells) parts.push(serializeTableCell(cell));
+	return `<w:tr>${parts.join("")}</w:tr>`;
+}
+/**
+* Serialize a table to OOXML XML (w:tbl)
+*
+* @param table - The table to serialize
+* @returns XML string for the table
+*/
+function serializeTable(table) {
+	const parts = [];
+	const tblPrXml = serializeTableFormatting(table.formatting, table.propertyChanges);
+	if (tblPrXml) parts.push(tblPrXml);
+	const tblGridXml = serializeTableGrid(table.columnWidths);
+	if (tblGridXml) parts.push(tblGridXml);
+	for (const row of table.rows) parts.push(serializeTableRow(row));
+	return `<w:tbl>${parts.join("")}</w:tbl>`;
+}
+/**
+* Serialize multiple tables to OOXML XML
+*
+* @param tables - The tables to serialize
+* @returns XML string for all tables
+*/
+function serializeTables(tables) {
+	return tables.map(serializeTable).join("");
+}
+/**
+* Check if a table has any rows
+*/
+function hasTableRows(table) {
+	return table.rows.length > 0;
+}
+/**
+* Check if a table has formatting
+*/
+function hasTableFormatting(table) {
+	return table.formatting !== void 0 && Object.keys(table.formatting).length > 0;
+}
+/**
+* Check if a row has any cells
+*/
+function hasRowCells(row) {
+	return row.cells.length > 0;
+}
+/**
+* Check if a row has formatting
+*/
+function hasRowFormatting(row) {
+	return row.formatting !== void 0 && Object.keys(row.formatting).length > 0;
+}
+/**
+* Check if a cell has any content
+*/
+function hasCellContent(cell) {
+	return cell.content.length > 0;
+}
+/**
+* Check if a cell has formatting
+*/
+function hasCellFormatting(cell) {
+	return cell.formatting !== void 0 && Object.keys(cell.formatting).length > 0;
+}
+/**
+* Get the number of columns in a table
+*/
+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
+*/
+function getTableRowCount(table) {
+	return table.rows.length;
+}
+/**
+* Create an empty table
+*/
+function createEmptyTable(rows = 1, cols = 1) {
+	const tableRows = [];
+	for (let r = 0; r < rows; r++) {
+		const cells = [];
+		for (let c = 0; c < cols; c++) cells.push({
+			type: "tableCell",
+			content: [{
+				type: "paragraph",
+				content: []
+			}]
+		});
+		tableRows.push({
+			type: "tableRow",
+			cells
+		});
+	}
+	return {
+		type: "table",
+		rows: tableRows
+	};
+}
+/**
+* Create a table cell with text content
+*/
+function createTextCell(text, formatting) {
+	return {
+		type: "tableCell",
+		...formatting !== void 0 ? { formatting } : {},
+		content: [{
+			type: "paragraph",
+			content: [{
+				type: "run",
+				content: [{
+					type: "text",
+					text
+				}]
+			}]
+		}]
+	};
+}
+//#endregion
+export { createEmptyTable, createTextCell, getTableColumnCount, getTableRowCount, hasCellContent, hasCellFormatting, hasRowCells, hasRowFormatting, hasTableFormatting, hasTableRows, serializeTable, serializeTableCell, serializeTableCellFormatting, serializeTableFormatting, serializeTableRow, serializeTableRowFormatting, serializeTables };

package/dist/docx/serializer/xmlUtils.d.ts

@@ -0,0 +1,20 @@
+//#region src/docx/serializer/xmlUtils.d.ts
+/**
+ * Shared XML utility functions for serializers.
+ */
+declare function escapeXml(text: string): string;
+/**
+ * Format a numeric value as an integer XML attribute.
+ *
+ * OOXML measure types (twips, EMU, half-points, eighths-of-point) are
+ * integer-typed in the schema (xs:unsignedInt / xs:long / xs:int). Word
+ * rejects floating-point values (e.g. `0.7 * 1440 === 1008.0000000000001`
+ * from `inches * TWIPS_PER_INCH`), even though tolerant readers accept them.
+ * Coerce to a finite integer at every serialization site.
+ *
+ * `NaN`/`Infinity`/`null`/`undefined` collapse to `'0'` rather than leaking
+ * literal `"NaN"` or `"Infinity"` into the XML.
+ */
+declare function intAttr(value: number | undefined | null): string;
+//#endregion
+export { escapeXml, intAttr };

package/dist/docx/serializer/xmlUtils.js

@@ -0,0 +1,25 @@
+//#region src/docx/serializer/xmlUtils.ts
+/**
+* Shared XML utility functions for serializers.
+*/
+function escapeXml(text) {
+	return text.replace(/&/gu, "&amp;").replace(/</gu, "&lt;").replace(/>/gu, "&gt;").replace(/"/gu, "&quot;").replace(/'/gu, "&apos;");
+}
+/**
+* Format a numeric value as an integer XML attribute.
+*
+* OOXML measure types (twips, EMU, half-points, eighths-of-point) are
+* integer-typed in the schema (xs:unsignedInt / xs:long / xs:int). Word
+* rejects floating-point values (e.g. `0.7 * 1440 === 1008.0000000000001`
+* from `inches * TWIPS_PER_INCH`), even though tolerant readers accept them.
+* Coerce to a finite integer at every serialization site.
+*
+* `NaN`/`Infinity`/`null`/`undefined` collapse to `'0'` rather than leaking
+* literal `"NaN"` or `"Infinity"` into the XML.
+*/
+function intAttr(value) {
+	if (value == null || !Number.isFinite(value)) return "0";
+	return String(Math.round(value));
+}
+//#endregion
+export { escapeXml, intAttr };

package/dist/docx/settingsParser.d.ts

@@ -0,0 +1,8 @@
+import { document_d_exports } from "../types/document.js";
+
+//#region src/docx/settingsParser.d.ts
+/** OOXML default per §17.6.13 when `w:defaultTabStop` is absent. */
+declare const DEFAULT_TAB_STOP_TWIPS = 720;
+declare function parseSettings(xml: string | null): document_d_exports.DocumentSettings;
+type DocumentSettings = document_d_exports.DocumentSettings;
+export { DEFAULT_TAB_STOP_TWIPS, type DocumentSettings, parseSettings };

package/dist/docx/settingsParser.js

@@ -0,0 +1,36 @@
+import { findChild, getAttribute, parseBooleanElement, parseXmlDocument } from "./xmlParser.js";
+//#region src/docx/settingsParser.ts
+/** OOXML default per §17.6.13 when `w:defaultTabStop` is absent. */
+const DEFAULT_TAB_STOP_TWIPS = 720;
+/**
+* Sanity cap on `w:defaultTabStop`. Word's maximum margin is ~22 inches
+* (31 680 twips); anything past that is corruption or a hostile input and
+* we substitute the OOXML default instead.
+*/
+const MAX_TAB_STOP_TWIPS = 31680;
+function parseSettings(xml) {
+	const root = xml ? parseXmlDocument(xml) : null;
+	const settings = { defaultTabStop: parseDefaultTabStop(root) };
+	const evenAndOddHeaders = root ? findChild(root, "w", "evenAndOddHeaders") : null;
+	if (evenAndOddHeaders && parseBooleanElement(evenAndOddHeaders)) settings.evenAndOddHeaders = true;
+	const themeFontLangEl = root ? findChild(root, "w", "themeFontLang") : null;
+	const eastAsiaLang = themeFontLangEl ? getAttribute(themeFontLangEl, "w", "eastAsia") || void 0 : void 0;
+	const bidiLang = themeFontLangEl ? getAttribute(themeFontLangEl, "w", "bidi") || void 0 : void 0;
+	if (eastAsiaLang || bidiLang) settings.themeFontLang = {
+		...eastAsiaLang ? { eastAsia: eastAsiaLang } : {},
+		...bidiLang ? { bidi: bidiLang } : {}
+	};
+	return settings;
+}
+function parseDefaultTabStop(root) {
+	if (!root) return 720;
+	const el = findChild(root, "w", "defaultTabStop");
+	if (!el) return 720;
+	const raw = getAttribute(el, "w", "val");
+	if (raw === null) return 720;
+	const parsed = Number.parseInt(raw, 10);
+	if (!Number.isFinite(parsed) || parsed <= 0 || parsed > MAX_TAB_STOP_TWIPS) return 720;
+	return parsed;
+}
+//#endregion
+export { DEFAULT_TAB_STOP_TWIPS, parseSettings };

package/dist/docx/shapeParser.d.ts

@@ -0,0 +1,20 @@
+import { document_d_exports } from "../types/document.js";
+import { XmlElement } from "./xmlParser.js";
+
+//#region src/docx/shapeParser.d.ts
+/**
+ * Parse a `<wps:wsp>` element into a Shape model. Does NOT pick up the
+ * extent / position / wrap fields — those live on the wrapping
+ * `<wp:inline>` / `<wp:anchor>` and are handled by `parseShapeFromDrawing`.
+ */
+declare function parseShape(node: XmlElement): document_d_exports.Shape;
+/**
+ * Parse a `<w:drawing>` element as a shape (i.e. the `<a:graphicData>` payload
+ * is `<wps:wsp>`, not `<pic:pic>` or a text-box). Returns null when the
+ * drawing is not a shape, or when it is a text-box (delegated to
+ * `textBoxParser.parseTextBox`).
+ */
+declare function parseShapeFromDrawing(drawingEl: XmlElement): document_d_exports.Shape | null;
+declare function shouldPreserveRawShapeDrawing(drawingEl: XmlElement): boolean;
+//#endregion
+export { parseShape, parseShapeFromDrawing, shouldPreserveRawShapeDrawing };