@stll/folio-core 0.15.13 → 0.17.0

package/dist/ai-edits/headless.js

@@ -8,13 +8,15 @@ import { attemptSelectiveSave } from "../docx/selectiveSave.js";
 import { acceptAIEditRevision, acceptAllChanges, rejectAIEditRevision, rejectAllChanges } from "../prosemirror/commands/comments.js";
 import { proseDocToBlocks, updateDocumentContent } from "../prosemirror/conversion/fromProseDoc.js";
 import { footnoteToProseDoc, headerFooterToProseDoc, toProseDoc } from "../prosemirror/conversion/toProseDoc.js";
-import { getChangedParagraphIds, hasStructuralChanges, hasUntrackedChanges, ignoreTrackedChanges } from "../prosemirror/extensions/features/ParagraphChangeTrackerExtension.js";
+import { ensureBaseDirectionInState } from "../prosemirror/extensions/features/AutoBidiDetectionExtension.js";
+import { getChangedParagraphIds, hasStructuralChanges, hasUntrackedChanges } from "../prosemirror/extensions/features/ParagraphChangeTrackerExtension.js";
 import { schema, singletonManager } from "../prosemirror/schema/index.js";
 import { deterministicHexId } from "../utils/hexId.js";
 import { buildAnnotatedBlockText } from "./clean-text.js";
 import { getCommentAnchorsFromDoc, getTrackedChangesFromDoc } from "./read.js";
 import { createFolioAIEditSnapshot, normalizeFolioAIBlockText } from "./snapshot.js";
 import { TaggedError } from "better-result";
+import { Fragment } from "prosemirror-model";
 import { EditorState } from "prosemirror-state";
 //#region src/ai-edits/headless.ts
 /**
@@ -80,39 +82,48 @@ const createReviewerComment = (text, author) => ({
 *
 * The shared `ParaIdAllocatorExtension` mints RANDOM ids (correct for freshly
 * typed paragraphs in the live editor); this load-time pass is deterministic so
-* a paraId-less corpus document anchors reproducibly. The transaction is marked
-* ignore-tracked so the change baseline stays clean.
+* a paraId-less corpus document anchors reproducibly.
+*
+* Rebuilding only the changed branches, like {@link ensureParaIdsInDoc}, keeps
+* the pass linear in paragraph count. Seeding through a transaction instead
+* costs one `setNodeMarkup` step per paragraph, and both halves of that are
+* quadratic: every step rebuilds the containing fragment, and the plugin
+* `appendTransaction` chain rescans the accumulated step maps. Because the pass
+* runs before the state exists, no history, mapping, or change-tracking
+* semantics depend on it.
 */
-const ensureDeterministicParaIdsInState = (state) => {
+const ensureDeterministicParaIdsInDoc = (doc) => {
 	const seen = /* @__PURE__ */ new Set();
-	const updates = [];
 	let ordinal = 0;
-	state.doc.descendants((node, pos) => {
-		if (node.type.name !== "paragraph") return;
-		ordinal += 1;
-		const existing = node.attrs["paraId"];
-		if (typeof existing === "string" && existing.length > 0 && !seen.has(existing)) {
-			seen.add(existing);
-			return false;
-		}
-		let paraId = deterministicHexId(`${node.textContent}:${ordinal}`);
-		for (let salt = 1; seen.has(paraId); salt++) paraId = deterministicHexId(`${node.textContent}:${ordinal}:${salt}`);
-		seen.add(paraId);
-		updates.push({
-			pos,
-			attrs: {
-				...node.attrs,
-				paraId
+	const rewrite = (parent) => {
+		let changed = false;
+		const children = [];
+		parent.forEach((child) => {
+			let next = child;
+			if (child.type.name === "paragraph") {
+				ordinal += 1;
+				const existing = child.attrs["paraId"];
+				if (typeof existing === "string" && existing.length > 0 && !seen.has(existing)) seen.add(existing);
+				else {
+					let paraId = deterministicHexId(`${child.textContent}:${ordinal}`);
+					for (let salt = 1; seen.has(paraId); salt++) paraId = deterministicHexId(`${child.textContent}:${ordinal}:${salt}`);
+					seen.add(paraId);
+					next = child.type.create({
+						...child.attrs,
+						paraId
+					}, child.content, child.marks);
+				}
+			} else if (child.childCount > 0) {
+				const content = rewrite(child);
+				if (content !== child.content) next = child.copy(content);
 			}
+			if (next !== child) changed = true;
+			children.push(next);
 		});
-		return false;
-	});
-	if (updates.length === 0) return state;
-	const tr = state.tr;
-	for (const update of updates) tr.setNodeMarkup(update.pos, void 0, update.attrs);
-	ignoreTrackedChanges(tr);
-	tr.setMeta("addToHistory", false);
-	return state.apply(tr);
+		return changed ? Fragment.fromArray(children) : parent.content;
+	};
+	const content = rewrite(doc);
+	return content === doc.content ? doc : doc.copy(content);
 };
 const FOLIO_REVIEWED_VIEWS = Object.freeze([
 	"original",
@@ -225,9 +236,9 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 			password: options.password
 		});
 		const plugins = singletonManager.getPlugins();
-		const state = ensureDeterministicParaIdsInState(EditorState.create({
+		const state = ensureBaseDirectionInState(EditorState.create({
 			schema,
-			doc: toProseDoc(baseDocument),
+			doc: ensureDeterministicParaIdsInDoc(toProseDoc(baseDocument)),
 			plugins
 		}));
 		return new FolioDocxReviewer({
@@ -711,9 +722,10 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 			...this.baseDocument.package.styles !== void 0 && { styles: this.baseDocument.package.styles },
 			...this.baseDocument.package.theme !== void 0 && { theme: this.baseDocument.package.theme }
 		};
-		const state = ensureDeterministicParaIdsInState(EditorState.create({
+		const storyDoc = story.type === "header" || story.type === "footer" ? headerFooterToProseDoc(source.content, conversionOptions) : footnoteToProseDoc(source.content, conversionOptions);
+		const state = ensureBaseDirectionInState(EditorState.create({
 			schema,
-			doc: story.type === "header" || story.type === "footer" ? headerFooterToProseDoc(source.content, conversionOptions) : footnoteToProseDoc(source.content, conversionOptions),
+			doc: ensureDeterministicParaIdsInDoc(storyDoc),
 			plugins: singletonManager.getPlugins()
 		}));
 		this.secondaryStoryStates.set(key, {

package/dist/controller/fontReadiness.js

@@ -120,6 +120,8 @@ function addLayoutFontFamilyFace(faces, value, descriptor) {
 	const fontFamily = value;
 	addLayoutFontFamilyFace(faces, fontFamily.ascii, descriptor);
 	addLayoutFontFamilyFace(faces, fontFamily.hAnsi, descriptor);
+	addLayoutFontFamilyFace(faces, fontFamily.cs, descriptor);
+	addLayoutFontFamilyFace(faces, fontFamily.eastAsia, descriptor);
 }
 function addLayoutFontFamilyNameFace(faces, family, descriptor) {
 	const normalized = family.trim();

package/dist/docx/server/extractDocxText.d.ts

@@ -1,6 +1,41 @@
 //#region src/docx/server/extractDocxText.d.ts
 /** Document part containing an extracted paragraph. */
 type DocxParagraphSource = "header" | "body" | "footer";
+/**
+ * Role of an emitted markdown table row.
+ *
+ * - `cells` — a `w:tr` rendered as a pipe row, including the first row when the
+ *   table declares it as its header.
+ * - `syntheticHeader` — the empty header row emitted for a table that declares
+ *   no header row; GFM has no headerless table.
+ * - `delimiter` — the `| --- |` line GFM requires under the header.
+ */
+type DocxTableRowKind = "cells" | "syntheticHeader" | "delimiter";
+/** Source paragraph inside a structured table cell. */
+type ExtractedDocxTableCellParagraph = {
+  text: string;
+  style?: string;
+  bold?: boolean;
+  fontSize?: number;
+  alignment?: "left" | "center" | "right" | "both";
+};
+/** Source paragraphs contained by one physical table cell. */
+type ExtractedDocxTableCell = {
+  /** Source `w:p` records in document order; empty padding cells have no entries. */
+  paragraphs: readonly ExtractedDocxTableCellParagraph[];
+};
+/** Table membership of a paragraph whose `text` is a markdown table row. */
+type DocxTableRowPosition = {
+  /** 0-based index of the source `w:tbl`, in extraction order across all parts. */
+  table: number;
+  kind: "cells";
+  /** Source cells aligned to the rendered GFM columns. */
+  cells: readonly ExtractedDocxTableCell[];
+} | {
+  /** 0-based index of the source `w:tbl`, in extraction order across all parts. */
+  table: number;
+  kind: "syntheticHeader" | "delimiter";
+};
 /** Paragraph text and lightweight formatting metadata from a DOCX archive. */
 type ExtractedDocxParagraph = {
   index: number;
@@ -10,6 +45,13 @@ type ExtractedDocxParagraph = {
   bold?: boolean;
   fontSize?: number;
   alignment?: "left" | "center" | "right" | "both";
+  /**
+   * Present only when `text` is a markdown table row rendered from a `w:tbl`,
+   * absent for ordinary prose paragraphs. Consumers that join `text` across
+   * paragraphs need no change; consumers that want to regroup a table's rows,
+   * or drop the rows GFM forced into existence, can key off this.
+   */
+  tableRow?: DocxTableRowPosition;
 };
 /** Accepted-revision paragraph text extracted in deterministic part order. */
 type ExtractedDocxText = {
@@ -20,4 +62,4 @@ type ExtractedDocxText = {
 /** Extract paragraph text and formatting metadata from a DOCX archive. */
 declare const extractDocxText: (bytes: ArrayBuffer | Uint8Array) => Promise<ExtractedDocxText>;
 //#endregion
-export { DocxParagraphSource, ExtractedDocxParagraph, ExtractedDocxText, extractDocxText };
+export { DocxParagraphSource, DocxTableRowKind, DocxTableRowPosition, ExtractedDocxParagraph, ExtractedDocxTableCell, ExtractedDocxTableCellParagraph, ExtractedDocxText, extractDocxText };

package/dist/docx/server/extractDocxText.js

@@ -1,13 +1,21 @@
+import { escapeTableCell } from "../../markdown/escape.js";
 import { RELATIONSHIP_TYPES, parseRelationships } from "../relsParser.js";
-import { findAllDeep, findChild, findDeep, getAttribute, getAttributeAnyPrefix, getLocalName, getTextContent, parseXml } from "../xmlParser.js";
+import { findAllDeep, findDeep, getAttribute, getAttributeByNamespaceUri, getLocalName, getNamespaceUri, getTextContent, parseXml } from "../xmlParser.js";
 import { loadDocxArchive } from "./boundedArchive.js";
 //#region src/docx/server/extractDocxText.ts
 const DOCUMENT_RELS_PATH = "word/_rels/document.xml.rels";
+const WORDPROCESSINGML_NAMESPACES = /* @__PURE__ */ new Set(["http://schemas.openxmlformats.org/wordprocessingml/2006/main", "http://purl.oclc.org/ooxml/wordprocessingml/main"]);
 const childElements = (element) => element.elements?.filter((child) => child.type === "element") ?? [];
+const wordElementName = (element) => WORDPROCESSINGML_NAMESPACES.has(getNamespaceUri(element) ?? "") ? getLocalName(element.name) : null;
+const findWordChild = (parent, localName) => {
+	if (!parent) return null;
+	return childElements(parent).find((child) => wordElementName(child) === localName) ?? null;
+};
+const getWordAttribute = (element, localName) => getAttributeByNamespaceUri(element, WORDPROCESSINGML_NAMESPACES, localName);
 const collectText = (element) => {
 	let text = "";
 	const walk = (node) => {
-		const localName = getLocalName(node.name ?? "");
+		const localName = wordElementName(node);
 		if (localName === "t") {
 			text += getTextContent(node);
 			return;
@@ -26,29 +34,45 @@ const collectText = (element) => {
 	walk(element);
 	return text;
 };
+const countAcceptedTextChars = (element) => {
+	let chars = 0;
+	const walk = (node) => {
+		const localName = wordElementName(node);
+		if (localName === "t") {
+			chars += getTextContent(node).length;
+			return;
+		}
+		if (localName === "del" || localName === "delText" || localName === "moveFrom") return;
+		for (const child of childElements(node)) walk(child);
+	};
+	walk(element);
+	return chars;
+};
 const readParagraphProperties = (paragraph) => {
-	const properties = findChild(paragraph, "w", "pPr");
+	const properties = findWordChild(paragraph, "pPr");
 	if (!properties) return {};
 	const result = {};
-	const styleValue = getAttributeAnyPrefix(findChild(properties, "w", "pStyle"), "val");
+	const style = findWordChild(properties, "pStyle");
+	const styleValue = getWordAttribute(style, "val");
 	if (styleValue !== null) result.style = styleValue;
-	const alignment = getAttributeAnyPrefix(findChild(properties, "w", "jc"), "val");
+	const justification = findWordChild(properties, "jc");
+	const alignment = getWordAttribute(justification, "val");
 	if (alignment === "left" || alignment === "center" || alignment === "right" || alignment === "both") result.alignment = alignment;
 	return result;
 };
 const readRunMetrics = (paragraph) => {
 	const metrics = [];
 	for (const run of childElements(paragraph)) {
-		if (getLocalName(run.name ?? "") !== "r") continue;
-		const properties = findChild(run, "w", "rPr");
-		const boldProperty = findChild(properties, "w", "b");
-		const boldValue = getAttributeAnyPrefix(boldProperty, "val");
+		if (wordElementName(run) !== "r") continue;
+		const properties = findWordChild(run, "rPr");
+		const boldProperty = findWordChild(properties, "b");
+		const boldValue = getWordAttribute(boldProperty, "val");
 		const bold = boldProperty !== null && boldValue !== "0" && boldValue !== "false";
-		const sizeValue = getAttributeAnyPrefix(findChild(properties, "w", "sz"), "val");
+		const sizeProperty = findWordChild(properties, "sz");
+		const sizeValue = getWordAttribute(sizeProperty, "val");
 		const parsedSize = sizeValue === null ? NaN : Number.parseInt(sizeValue, 10);
 		const fontSize = Number.isFinite(parsedSize) && parsedSize > 0 ? parsedSize : void 0;
-		let chars = 0;
-		for (const textNode of findAllDeep(run, "w", "t")) chars += getTextContent(textNode).length;
+		const chars = countAcceptedTextChars(run);
 		if (chars === 0) continue;
 		const entry = {
 			bold,
@@ -59,37 +83,269 @@ const readRunMetrics = (paragraph) => {
 	}
 	return metrics;
 };
-const extractContainer = ({ container, source, startIndex }) => {
+const readParagraph = (paragraph) => {
+	const entry = { text: collectText(paragraph) };
+	const { style, alignment } = readParagraphProperties(paragraph);
+	if (style !== void 0) entry.style = style;
+	if (alignment !== void 0) entry.alignment = alignment;
+	const runs = readRunMetrics(paragraph);
+	if (runs.length === 0) return entry;
+	const totalChars = runs.reduce((sum, run) => sum + run.chars, 0);
+	if (runs.reduce((sum, run) => sum + (run.bold ? run.chars : 0), 0) > totalChars / 2) entry.bold = true;
+	const firstFontSize = runs.find((run) => run.fontSize !== void 0)?.fontSize;
+	if (firstFontSize !== void 0) entry.fontSize = firstFontSize;
+	return entry;
+};
+const TABLE_DELIMITER_CELL = "---";
+/** GFM cannot nest tables; an inner table joins its cells inside the outer cell. */
+const NESTED_TABLE_CELL_SEPARATOR = " / ";
+/** Word supports 63 table columns; cap well above that so a hostile `w:gridSpan` cannot balloon a row. */
+const MAX_TABLE_COLUMNS = 256;
+/** Bound the mutual recursion between a cell and the tables nested inside it. */
+const MAX_NESTED_TABLE_DEPTH = 8;
+/**
+* Collect a table's `w:tr`, or a row's `w:tc`, seeing through the wrappers Word
+* puts around them (`w:sdt` / `w:sdtContent` content controls, `w:customXml`).
+* The walk stops at `w:tbl` and `w:p` so a nested table's rows and cells never
+* leak into the grid of the table that contains them.
+*/
+const collectTableParts = (parent, localName) => {
+	const parts = [];
+	const walk = (node) => {
+		for (const child of childElements(node)) {
+			const childName = wordElementName(child);
+			if (childName === localName) {
+				parts.push(child);
+				continue;
+			}
+			if (childName === "tbl" || childName === "p") continue;
+			walk(child);
+		}
+	};
+	walk(parent);
+	return parts;
+};
+/**
+* Raw (unescaped) text of one cell: its paragraphs in order, one per line.
+* Blank paragraphs are dropped so a cell padded with empty paragraphs does not
+* render as a run of `<br>`. A nested table contributes one line per inner row.
+*/
+const readCellSourceParagraphs = (cell, depth) => {
+	const paragraphs = [];
+	const walk = (node) => {
+		for (const child of childElements(node)) {
+			const childName = wordElementName(child);
+			if (childName === "p") {
+				const paragraph = readParagraph(child);
+				if (paragraph.text.length > 0) paragraphs.push(paragraph);
+				continue;
+			}
+			if (childName === "tbl") {
+				if (depth >= MAX_NESTED_TABLE_DEPTH) continue;
+				for (const row of collectTableParts(child, "tr")) for (const nestedCell of collectTableParts(row, "tc")) for (const paragraph of readCellSourceParagraphs(nestedCell, depth + 1)) paragraphs.push(paragraph);
+				continue;
+			}
+			walk(child);
+		}
+	};
+	walk(cell);
+	return paragraphs;
+};
+const readCellRenderedLines = (cell, depth) => {
+	const lines = [];
+	const walk = (node) => {
+		for (const child of childElements(node)) {
+			const childName = wordElementName(child);
+			if (childName === "p") {
+				const text = collectText(child);
+				if (text.length > 0) lines.push(text);
+				continue;
+			}
+			if (childName === "tbl") {
+				if (depth < MAX_NESTED_TABLE_DEPTH) for (const line of flattenNestedTable(child, depth + 1)) lines.push(line);
+				continue;
+			}
+			walk(child);
+		}
+	};
+	walk(cell);
+	return lines;
+};
+const flattenNestedTable = (table, depth) => {
+	const lines = [];
+	for (const row of collectTableParts(table, "tr")) {
+		const cells = collectTableParts(row, "tc").map((cell) => readCellRenderedLines(cell, depth).join("\n"));
+		if (cells.some((text) => text.length > 0)) lines.push(cells.join(NESTED_TABLE_CELL_SEPARATOR));
+	}
+	return lines;
+};
+const emptyTableCell = () => ({
+	text: "",
+	paragraphs: [],
+	gridSpan: 1
+});
+const readTableCell = (cell, depth) => {
+	const properties = findWordChild(cell, "tcPr");
+	const gridSpanValue = getWordAttribute(findWordChild(properties, "gridSpan"), "val");
+	const parsedGridSpan = gridSpanValue === null ? 1 : Number.parseInt(gridSpanValue, 10);
+	const gridSpan = Number.isFinite(parsedGridSpan) && parsedGridSpan > 1 ? parsedGridSpan : 1;
+	const vMerge = findWordChild(properties, "vMerge");
+	if (vMerge !== null && getWordAttribute(vMerge, "val") !== "restart") return {
+		text: "",
+		paragraphs: [],
+		gridSpan
+	};
+	const paragraphs = readCellSourceParagraphs(cell, depth);
+	return {
+		text: readCellRenderedLines(cell, depth).join("\n"),
+		paragraphs,
+		gridSpan
+	};
+};
+/**
+* Does the row declare itself a header? `w:tblHeader` is the only OOXML signal
+* that says so: it marks the row Word repeats at the top of each page. The
+* neighbouring `w:tblLook/@w:firstRow` is conditional *formatting* that Word
+* writes on essentially every table (its default `w:val="04A0"`), so keying off
+* it would promote the first data row of almost every document.
+*
+* Without the flag the table is headerless and GFM gets a synthetic empty header
+* row: a table's first row is data until the document says otherwise, and column
+* names invented here would be read back as facts about the document.
+*/
+const declaresHeaderRow = (row) => {
+	const header = findWordChild(findWordChild(row, "trPr"), "tblHeader");
+	if (header === null) return false;
+	const value = getWordAttribute(header, "val");
+	return value !== "0" && value !== "false";
+};
+const readRowGridOffset = (row, localName) => {
+	const properties = findWordChild(row, "trPr");
+	const value = getWordAttribute(findWordChild(properties, localName), "val");
+	const parsed = value === null ? 0 : Number.parseInt(value, 10);
+	return Number.isFinite(parsed) && parsed > 0 ? Math.min(parsed, MAX_TABLE_COLUMNS) : 0;
+};
+const readTableGrid = (table) => {
+	const rows = [];
+	let columnCount = 0;
+	let firstRowIsHeader = false;
+	for (const [rowIndex, row] of collectTableParts(table, "tr").entries()) {
+		if (rowIndex === 0) firstRowIsHeader = declaresHeaderRow(row);
+		const columns = [];
+		const gridBefore = readRowGridOffset(row, "gridBefore");
+		for (let index = 0; index < gridBefore; index += 1) columns.push(emptyTableCell());
+		for (const cell of collectTableParts(row, "tc")) {
+			if (columns.length >= MAX_TABLE_COLUMNS) break;
+			const extractedCell = readTableCell(cell, 0);
+			columns.push(extractedCell);
+			const padding = Math.min(extractedCell.gridSpan - 1, MAX_TABLE_COLUMNS - columns.length);
+			for (let index = 0; index < padding; index++) columns.push(emptyTableCell());
+		}
+		const gridAfter = Math.min(readRowGridOffset(row, "gridAfter"), MAX_TABLE_COLUMNS - columns.length);
+		for (let index = 0; index < gridAfter; index += 1) columns.push(emptyTableCell());
+		if (columns.length > columnCount) columnCount = columns.length;
+		rows.push(columns);
+	}
+	return {
+		rows,
+		columnCount,
+		firstRowIsHeader
+	};
+};
+/** Pad a row to the table's column count and escape each cell into a pipe row. */
+const toRowLine = (columns, columnCount) => {
+	const cells = [];
+	for (let column = 0; column < columnCount; column++) cells.push(escapeTableCell(columns[column]?.text ?? ""));
+	return `| ${cells.join(" | ")} |`;
+};
+/** Render a `w:tbl` as GFM rows. A table with no cell at all renders nothing. */
+const renderTableRows = (table, tableIndex) => {
+	const { rows, columnCount, firstRowIsHeader } = readTableGrid(table);
+	const [firstRow, ...remainingRows] = rows;
+	if (columnCount === 0 || firstRow === void 0) return [];
+	const rendered = [];
+	const pushScaffolding = (text, kind) => {
+		rendered.push({
+			text,
+			position: {
+				table: tableIndex,
+				kind
+			}
+		});
+	};
+	const pushCells = (cells) => {
+		rendered.push({
+			text: toRowLine(cells, columnCount),
+			position: {
+				table: tableIndex,
+				kind: "cells",
+				cells: Array.from({ length: columnCount }, (_, column) => ({ paragraphs: cells.at(column)?.paragraphs ?? [] }))
+			}
+		});
+	};
+	if (firstRowIsHeader) pushCells(firstRow);
+	else pushScaffolding(toRowLine([], columnCount), "syntheticHeader");
+	pushScaffolding(toRowLine(Array.from({ length: columnCount }, () => ({
+		text: TABLE_DELIMITER_CELL,
+		paragraphs: [],
+		gridSpan: 1
+	})), columnCount), "delimiter");
+	for (const row of firstRowIsHeader ? remainingRows : rows) pushCells(row);
+	return rendered;
+};
+const extractContainer = ({ container, source, startIndex, startTableIndex }) => {
 	const paragraphs = [];
 	let charCount = 0;
-	for (const [offset, paragraph] of findAllDeep(container, "w", "p").entries()) {
-		const text = collectText(paragraph);
+	let tableCount = 0;
+	const pushProse = (paragraph) => {
+		const extracted = readParagraph(paragraph);
+		const { text } = extracted;
 		const entry = {
-			index: startIndex + offset,
-			text,
-			source
+			index: startIndex + paragraphs.length,
+			source,
+			...extracted
 		};
-		const { style, alignment } = readParagraphProperties(paragraph);
-		if (style !== void 0) entry.style = style;
-		if (alignment !== void 0) entry.alignment = alignment;
-		const runs = readRunMetrics(paragraph);
-		if (runs.length > 0) {
-			const totalChars = runs.reduce((sum, run) => sum + run.chars, 0);
-			if (runs.reduce((sum, run) => sum + (run.bold ? run.chars : 0), 0) > totalChars / 2) entry.bold = true;
-			const firstFontSize = runs.find((run) => run.fontSize !== void 0)?.fontSize;
-			if (firstFontSize !== void 0) entry.fontSize = firstFontSize;
-		}
 		paragraphs.push(entry);
 		charCount += text.length;
-	}
+	};
+	const pushTableRow = ({ text, position }) => {
+		paragraphs.push({
+			index: startIndex + paragraphs.length,
+			text,
+			source,
+			tableRow: position
+		});
+		charCount += text.length;
+	};
+	/**
+	* Walk block content in document order. Descent mirrors the previous
+	* `findAllDeep(container, "w", "p")` — every wrapper (`w:sdt`, textboxes) is
+	* still entered — except that a `w:tbl` is consumed as a table instead of
+	* having its cell paragraphs emitted individually.
+	*/
+	const walkBlocks = (node) => {
+		for (const child of childElements(node)) {
+			const childName = wordElementName(child);
+			if (childName === "tbl") {
+				for (const row of renderTableRows(child, startTableIndex + tableCount)) pushTableRow(row);
+				tableCount += 1;
+				continue;
+			}
+			if (childName === "p") pushProse(child);
+			walkBlocks(child);
+		}
+	};
+	walkBlocks(container);
 	return {
 		paragraphs,
-		charCount
+		charCount,
+		tableCount
 	};
 };
-const extractParts = async ({ archive, source, rootName, startIndex, paths }) => {
+const extractParts = async ({ archive, source, rootName, startIndex, startTableIndex, paths }) => {
 	const paragraphs = [];
 	let charCount = 0;
+	let tableCount = 0;
 	let nextIndex = startIndex;
 	for (const path of paths) {
 		const xml = await archive.readEntryString(path);
@@ -99,15 +355,18 @@ const extractParts = async ({ archive, source, rootName, startIndex, paths }) =>
 		const result = extractContainer({
 			container,
 			source,
-			startIndex: nextIndex
+			startIndex: nextIndex,
+			startTableIndex: startTableIndex + tableCount
 		});
-		paragraphs.push(...result.paragraphs);
+		for (const paragraph of result.paragraphs) paragraphs.push(paragraph);
 		charCount += result.charCount;
+		tableCount += result.tableCount;
 		nextIndex += result.paragraphs.length;
 	}
 	return {
 		paragraphs,
-		charCount
+		charCount,
+		tableCount
 	};
 };
 /** A `word/_rels/document.xml.rels` `Target` is relative to `word/`; resolve it to a full archive-entry path. */
@@ -173,18 +432,21 @@ const extractDocxText = async (bytes) => {
 		source: "header",
 		rootName: "hdr",
 		startIndex: 0,
+		startTableIndex: 0,
 		paths: referencedParts.headers
 	});
 	const bodyResult = extractContainer({
 		container: body,
 		source: "body",
-		startIndex: headers.paragraphs.length
+		startIndex: headers.paragraphs.length,
+		startTableIndex: headers.tableCount
 	});
 	const footers = await extractParts({
 		archive,
 		source: "footer",
 		rootName: "ftr",
 		startIndex: headers.paragraphs.length + bodyResult.paragraphs.length,
+		startTableIndex: headers.tableCount + bodyResult.tableCount,
 		paths: referencedParts.footers
 	});
 	return {

package/dist/docx/xmlParser.d.ts

@@ -36,8 +36,17 @@ type XmlElement = {
   text?: string | number | boolean;
   type?: string;
   name?: string;
+  /** Resolved namespace URI; non-enumerable so legacy structural comparisons stay stable. */
+  namespaceUri?: string;
+  /** In-scope namespace declarations; non-enumerable so legacy comparisons stay stable. */
+  namespaceScope?: XmlNamespaceScope;
   elements?: XmlElement[];
 };
+/** Parent-linked XML namespace declarations; each scope stores only local overrides. */
+type XmlNamespaceScope = {
+  bindings: ReadonlyMap<string, string>;
+  parent?: XmlNamespaceScope;
+};
 /**
  * Common OOXML namespace URIs — re-exported from @stll/docx-utils.
  */
@@ -85,6 +94,10 @@ declare function getLocalName(name: string | undefined): string;
  * e.g., "w:p" -> "w", "a:graphic" -> "a"
  */
 declare function getNamespacePrefix(name: string): string | null;
+/** Namespace URI resolved from the element's in-scope XML declarations. */
+declare const getNamespaceUri: (element: XmlElement) => string | undefined;
+/** Get an attribute whose prefix resolves to one of the accepted namespace URIs. */
+declare function getAttributeByNamespaceUri(element: XmlElement | null | undefined, namespaceUris: ReadonlySet<string>, localName: string): string | null;
 /**
  * Check if an element matches a given namespaced name
  *
@@ -313,4 +326,4 @@ declare function mergeXmlnsDeclarations(inherited: Record<string, string>, eleme
  */
 declare function cloneWithXmlnsDeclarations(element: XmlElement, xmlnsDecls: Record<string, string>): XmlElement;
 //#endregion
-export { NAMESPACES, XmlElement, cloneWithXmlnsDeclarations, collectXmlnsDeclarations, elementToXml, findAllDeep, findByFullName, findChild, findChildByLocalName, findChildren, findChildrenByLocalName, findDeep, getAttribute, getAttributeAny, getAttributeAnyPrefix, getAttributes, getChildElements, getLocalName, getNamespacePrefix, getTextContent, hasChild, hasFlag, matchesName, mergeXmlnsDeclarations, parseBooleanElement, parseColorElement, parseNumberingLevelAttribute, parseNumericAttribute, parseTableMeasurementValue, parseXml, parseXmlDocument };
+export { NAMESPACES, XmlElement, XmlNamespaceScope, cloneWithXmlnsDeclarations, collectXmlnsDeclarations, elementToXml, findAllDeep, findByFullName, findChild, findChildByLocalName, findChildren, findChildrenByLocalName, findDeep, getAttribute, getAttributeAny, getAttributeAnyPrefix, getAttributeByNamespaceUri, getAttributes, getChildElements, getLocalName, getNamespacePrefix, getNamespaceUri, getTextContent, hasChild, hasFlag, matchesName, mergeXmlnsDeclarations, parseBooleanElement, parseColorElement, parseNumberingLevelAttribute, parseNumericAttribute, parseTableMeasurementValue, parseXml, parseXmlDocument };