@stll/folio-core 0.6.1 → 0.8.0

package/dist/layout-painter/renderParagraph.js

@@ -5,7 +5,7 @@ import { calculateTabWidth } from "../prosemirror/utils/tabCalculator.js";
 import { inlineImageBoundingBox, parseRotationDegrees, rotatedBoundingBox } from "../utils/rotationBoundingBox.js";
 import { hasCjk, segmentByScript } from "../utils/scriptSegments.js";
 import { isFloatingImageRun } from "../layout-engine/types.js";
-import { getListMarkerInlineWidth } from "../layout-engine/measure/listMarkerWidth.js";
+import { getListMarkerInlineWidth, getListMarkerVisualOffset } from "../layout-engine/measure/listMarkerWidth.js";
 import { applySdtDataAttrs } from "./sdtBoundary.js";
 import { applyImageVisualAttrs, hasImageVisualAttrs, wrapImageWithCrop } from "./renderImage.js";
 import { ommlToMathml } from "../docx/mathToMathml.js";
@@ -709,6 +709,75 @@ function splitTextRunsByEastAsia(runs) {
 	}
 	return result;
 }
+const paintsLineEdgeSpaces = (run) => Boolean(run.underline || run.strike || run.highlight || run.shading || run.hyperlink || run.hidden || run.templatePreview || run.isInsertion || run.isDeletion || run.commentIds?.length || run.textEffect || run.emphasisMark);
+const splitTextRunAt = (run, index) => {
+	const leading = {
+		...run,
+		text: run.text.slice(0, index)
+	};
+	const trailing = {
+		...run,
+		text: run.text.slice(index)
+	};
+	if (run.pmStart === void 0) return [leading, trailing];
+	const splitPosition = Math.min(run.pmStart + index, run.pmEnd ?? Number.POSITIVE_INFINITY);
+	leading.pmEnd = splitPosition;
+	trailing.pmStart = splitPosition;
+	return [leading, trailing];
+};
+/**
+* Word keeps ordinary line-edge spaces addressable in the document model but
+* gives them no painted advance. Collapsible trailing spaces always collapse;
+* leading spaces collapse only after a soft wrap, not at the authored
+* paragraph start or after a manual line break. Split paint runs to preserve
+* exact PM ranges.
+*/
+const splitCollapsibleLineEdgeSpaces = (sourceRuns, collapseLeading) => {
+	const runs = [...sourceRuns];
+	const collapsedLeadingRuns = /* @__PURE__ */ new Set();
+	const collapsedTrailingRuns = /* @__PURE__ */ new Set();
+	for (let index = runs.length - 1; index >= 0; index--) {
+		const run = runs[index];
+		if (!run || !isTextRun(run)) break;
+		if (run.text.length === 0) continue;
+		const trailingSpaces = / +$/u.exec(run.text);
+		if (!trailingSpaces || paintsLineEdgeSpaces(run)) break;
+		if (trailingSpaces.index === 0) {
+			collapsedTrailingRuns.add(run);
+			continue;
+		}
+		const [leading, trailing] = splitTextRunAt(run, trailingSpaces.index);
+		runs.splice(index, 1, leading, trailing);
+		collapsedTrailingRuns.add(trailing);
+		break;
+	}
+	if (collapseLeading) for (let index = 0; index < runs.length; index++) {
+		const run = runs[index];
+		if (!run || !isTextRun(run)) break;
+		if (run.text.length === 0) continue;
+		const leadingSpaces = /^ +/u.exec(run.text);
+		if (!leadingSpaces || paintsLineEdgeSpaces(run)) break;
+		if (leadingSpaces[0].length === run.text.length) {
+			collapsedLeadingRuns.add(run);
+			continue;
+		}
+		const [leading, trailing] = splitTextRunAt(run, leadingSpaces[0].length);
+		runs.splice(index, 1, leading, trailing);
+		collapsedLeadingRuns.add(leading);
+		break;
+	}
+	return {
+		runs,
+		collapsedLeadingRuns,
+		collapsedTrailingRuns
+	};
+};
+const startsAfterSoftWrap = (block, line) => {
+	if (line.fromChar > 0) return true;
+	if (line.fromRun === 0) return false;
+	const previousRun = block.runs.at(line.fromRun - 1);
+	return previousRun !== void 0 && !isLineBreakRun(previousRun);
+};
 /**
 * Sub-pixel tolerance when comparing canvas-measured widths against the DOM's
 * actual right edge. Accumulated rounding from canvas measureText vs. browser
@@ -878,7 +947,20 @@ function renderLine(block, line, alignment, doc, options) {
 	lineEl.style.boxSizing = "content-box";
 	lineEl.style.height = `${line.lineHeight}px`;
 	lineEl.style.lineHeight = `${line.lineHeight}px`;
-	const runsForLine = splitTextRunsByEastAsia(sliceRunsForLine(block, line));
+	const splitRuns = splitTextRunsByEastAsia(sliceRunsForLine(block, line));
+	const { runs: runsForLine, collapsedLeadingRuns: collapsedLeadingSpaceRuns, collapsedTrailingRuns: collapsedTrailingSpaceRuns } = splitCollapsibleLineEdgeSpaces(splitRuns, startsAfterSoftWrap(block, line));
+	const isCollapsedLineEdgeSpaceRun = (run) => collapsedLeadingSpaceRuns.has(run) || collapsedTrailingSpaceRuns.has(run);
+	const renderLineTextRun = (run) => {
+		const runEl = renderTextRun(run, doc);
+		if (collapsedLeadingSpaceRuns.has(run)) runEl.dataset["collapsedLeadingSpaces"] = "true";
+		if (collapsedTrailingSpaceRuns.has(run)) runEl.dataset["collapsedTrailingSpaces"] = "true";
+		if (isCollapsedLineEdgeSpaceRun(run)) {
+			runEl.style.fontSize = "0";
+			runEl.style.letterSpacing = "0";
+			runEl.style.wordSpacing = "0";
+		}
+		return runEl;
+	};
 	const onlyRun = runsForLine.length === 1 ? runsForLine[0] : void 0;
 	if (onlyRun && isMathRun(onlyRun) && onlyRun.display === "block" && block.attrs?.alignment !== "right") lineEl.style.textAlign = "center";
 	if (runsForLine.length === 1 && isImageRun(runsForLine[0])) {
@@ -914,7 +996,7 @@ function renderLine(block, line, alignment, doc, options) {
 			const firstLineHangingExpansionPx = hasVisibleListMarker ? Math.min(firstLineHangingPx, Math.max(0, options.leftIndentPx ?? 0)) : firstLineHangingPx;
 			const justifyCapacityPx = options.availableWidth + firstLineHangingExpansionPx;
 			const overfullPx = line.width - justifyCapacityPx;
-			const shrinkableSpaces = countShrinkableSpaces(runsForLine);
+			const shrinkableSpaces = countShrinkableSpaces(runsForLine.filter((run) => !isTextRun(run) || !isCollapsedLineEdgeSpaceRun(run)));
 			if (overfullPx > RIGHT_EDGE_EPSILON_PX && shrinkableSpaces > 0) {
 				lineEl.style.textAlign = "left";
 				lineEl.style.textAlignLast = "auto";
@@ -989,7 +1071,7 @@ function renderLine(block, line, alignment, doc, options) {
 				for (let j = i + 1; j < runsForLine.length; j++) {
 					const next = runsForLine[j];
 					if (isTabRun(next) || isLineBreakRun(next)) break;
-					if (isTextRun(next)) lineEl.append(renderTextRun(next, doc));
+					if (isTextRun(next)) lineEl.append(renderLineTextRun(next));
 					else if (isFieldRun(next) && options?.context) lineEl.append(renderFieldRun(next, doc, options.context));
 					else if (isImageRun(next)) {
 						if (isFloatingImageRun(next)) continue;
@@ -1003,13 +1085,14 @@ function renderLine(block, line, alignment, doc, options) {
 				break;
 			}
 			let tabWidth = tabResult.width;
-			if (lineRightEdgeX !== void 0 && canClampTabToRightEdge(tabResult.alignment, i > 0, runsForLine.slice(0, i).some(isTabRun), options?.isLastLine === true) && currentX + tabWidth + followingWidthForCheck > lineRightEdgeX) tabWidth = Math.max(1, lineRightEdgeX - currentX - followingWidthForCheck);
+			if (!(tabResult.alignment === "start" && leftIndentPx > 0 && Math.abs(currentX + tabWidth - leftIndentPx) <= RIGHT_EDGE_EPSILON_PX) && lineRightEdgeX !== void 0 && canClampTabToRightEdge(tabResult.alignment, i > 0, runsForLine.slice(0, i).some(isTabRun), options?.isLastLine === true) && currentX + tabWidth + followingWidthForCheck > lineRightEdgeX) tabWidth = Math.max(1, lineRightEdgeX - currentX - followingWidthForCheck);
 			const tabEl = renderTabRun(run, doc, tabWidth, tabResult.leader);
 			lineEl.append(tabEl);
 			currentX += tabWidth;
 		} else if (isTextRun(run)) {
-			const runEl = renderTextRun(run, doc);
+			const runEl = renderLineTextRun(run);
 			lineEl.append(runEl);
+			if (isCollapsedLineEdgeSpaceRun(run)) continue;
 			const fontSize = run.fontSize || 11;
 			const fontFamily = run.fontFamily || "Calibri";
 			const measuredWidth = measureText(run.allCaps ? run.text.toLocaleUpperCase() : run.text, fontSize, fontFamily, {
@@ -1268,7 +1351,7 @@ function renderParagraphFragment(fragment, block, measure, context, options = {}
 			}
 			const markerFontFamily = block.attrs.listMarkerFontFamily ?? firstTextRun?.fontFamily ?? block.attrs.defaultFontFamily;
 			const markerFontSize = block.attrs.listMarkerFontSize ?? firstTextRun?.fontSize ?? block.attrs.defaultFontSize;
-			const marker = renderListMarker(block.attrs.listMarker, getListMarkerInlineWidth(block), doc, markerFontFamily, markerFontSize, block.attrs.listMarkerRevision, block.attrs.listMarkerSecondSlotOffsetTwips);
+			const marker = renderListMarker(block.attrs.listMarker, getListMarkerInlineWidth(block), getListMarkerVisualOffset(block), doc, markerFontFamily, markerFontSize, block.attrs.listMarkerRevision, block.attrs.listMarkerSecondSlotOffsetTwips);
 			const markerMarginLeft = markerStart - Math.min(indentLeft, 0);
 			if (markerMarginLeft < 0) marker.style.marginLeft = `${markerMarginLeft}px`;
 			lineEl.prepend(marker);
@@ -1279,13 +1362,13 @@ function renderParagraphFragment(fragment, block, measure, context, options = {}
 }
 /**
 * Render a list marker element as an inline-block at the start of the first
-* body line. `minWidth` (from `getListMarkerInlineWidth`) sizes the marker
+* body line. `inlineWidth` (from `getListMarkerInlineWidth`) sizes the marker
 * so the body text aligns at the next tab stop per ECMA-376 §17.9.25 —
 * this honours `w:suff` (`tab` / `space` / `nothing`) and the document's
 * tab grid. Long markers like "1.1.1." therefore grow to the next stop
 * instead of butting against the body text.
 */
-function renderListMarker(marker, minWidth, doc, fontFamily, fontSize, revision, secondSlotOffsetTwips) {
+function renderListMarker(marker, inlineWidth, visualOffset, doc, fontFamily, fontSize, revision, secondSlotOffsetTwips) {
 	const span = doc.createElement("span");
 	span.className = "layout-list-marker";
 	span.style.display = "inline-block";
@@ -1294,7 +1377,8 @@ function renderListMarker(marker, minWidth, doc, fontFamily, fontSize, revision,
 	span.style.textAlign = "left";
 	span.style.textAlignLast = "left";
 	span.style.boxSizing = "border-box";
-	if (minWidth > 0) span.style.minWidth = `${minWidth}px`;
+	span.style.width = `${inlineWidth}px`;
+	if (visualOffset !== 0) span.style.transform = `translateX(${visualOffset}px)`;
 	if (revision) {
 		const authorIdx = getAuthorColorIdx(revision.author ?? "");
 		const authorColor = AUTHOR_COLORS[authorIdx];

package/dist/layout-painter/renderTable.js

@@ -1,5 +1,5 @@
 import { emuToPixels } from "../utils/units.js";
-import { isFloatingImageRun, isFloatingTextBoxBlock, tableColumnsArePinned } from "../layout-engine/types.js";
+import { getTableRowLeadingWidth, isFloatingImageRun, isFloatingTextBoxBlock, tableColumnsArePinned } from "../layout-engine/types.js";
 import { measureParagraph } from "../layout-engine/measure/measureParagraph.js";
 import { getAutomaticTextColorForBackground } from "./documentColors.js";
 import { renderParagraphFragment } from "./renderParagraph.js";
@@ -207,6 +207,7 @@ function renderNestedTable(block, measure, context, doc) {
 	rowYPositions.push(yPos);
 	const spanningCells = /* @__PURE__ */ new Map();
 	const columnsPinned = tableColumnsArePinned(block);
+	const cellGrid = buildTableCellGrid(block, measure.columnWidths.length);
 	let y = 0;
 	for (let rowIndex = 0; rowIndex < block.rows.length; rowIndex++) {
 		const row = block.rows[rowIndex];
@@ -216,7 +217,7 @@ function renderNestedTable(block, measure, context, doc) {
 			y += rowMeasure.height;
 			continue;
 		}
-		const rowEl = renderTableRow(row, rowMeasure, rowIndex, y, measure.columnWidths, block.rows.length, context, doc, spanningCells, rowYPositions, void 0, block.bidi, columnsPinned);
+		const rowEl = renderTableRow(row, rowMeasure, rowIndex, y, measure.columnWidths, block.rows.length, context, doc, spanningCells, rowYPositions, void 0, block.bidi, columnsPinned, cellGrid);
 		tableEl.append(rowEl);
 		y += rowMeasure.height;
 	}
@@ -255,10 +256,10 @@ function renderTableCell(cell, cellMeasure, x, rowHeight, borderFlags, columnsPi
 	const padLeft = cell.padding?.left ?? 7;
 	cellEl.style.padding = `${padTop}px ${padRight}px ${padBottom}px ${padLeft}px`;
 	if (cell.borders) {
-		if (borderFlags.isFirstRow) applyBorder(cellEl, "top", cell.borders.top);
+		if (borderFlags.drawTop) applyBorder(cellEl, "top", cell.borders.top);
 		applyBorder(cellEl, "right", cell.borders.right);
 		applyBorder(cellEl, "bottom", cell.borders.bottom);
-		if (borderFlags.isFirstCol) applyBorder(cellEl, "left", cell.borders.left);
+		if (borderFlags.drawLeft) applyBorder(cellEl, "left", cell.borders.left);
 	}
 	if (cell.background) {
 		cellEl.style.backgroundColor = cell.background;
@@ -303,10 +304,30 @@ function renderTableCell(cell, cellMeasure, x, rowHeight, borderFlags, columnsPi
 	}
 	return cellEl;
 }
+const tableCellGridKey = (rowIndex, columnIndex) => `${rowIndex}:${columnIndex}`;
+function buildTableCellGrid(block, columnCount) {
+	const grid = /* @__PURE__ */ new Map();
+	for (let rowIndex = 0; rowIndex < block.rows.length; rowIndex++) {
+		const row = block.rows[rowIndex];
+		if (!row) continue;
+		let columnIndex = 0;
+		for (const cell of row.cells) {
+			while (grid.has(tableCellGridKey(rowIndex, columnIndex))) columnIndex += 1;
+			const colSpan = cell.colSpan ?? 1;
+			const rowSpan = cell.rowSpan ?? 1;
+			const rowEnd = Math.min(block.rows.length, rowIndex + rowSpan);
+			const columnEnd = Math.min(columnCount, columnIndex + colSpan);
+			for (let gridRow = rowIndex; gridRow < rowEnd; gridRow++) for (let gridColumn = columnIndex; gridColumn < columnEnd; gridColumn++) grid.set(tableCellGridKey(gridRow, gridColumn), cell);
+			columnIndex += colSpan;
+		}
+	}
+	return grid;
+}
+const hasVisibleBorder = (border) => border !== void 0 && border.width !== 0 && border.style !== "none" && border.style !== "nil";
 /**
 * Render a table row with rowSpan support
 */
-function renderTableRow(row, rowMeasure, rowIndex, y, columnWidths, totalRows, context, doc, spanningCells, rowYPositions, isFirstRowInFragment, bidi = false, columnsPinned = false) {
+function renderTableRow(row, rowMeasure, rowIndex, y, columnWidths, totalRows, context, doc, spanningCells, rowYPositions, isFirstRowInFragment, bidi = false, columnsPinned = false, cellGrid) {
 	const rowEl = doc.createElement("div");
 	rowEl.className = TABLE_CLASS_NAMES.row;
 	const tableWidth = bidi ? columnWidths.reduce((sum, columnWidth) => sum + columnWidth, 0) : 0;
@@ -320,8 +341,9 @@ function renderTableRow(row, rowMeasure, rowIndex, y, columnWidths, totalRows, c
 	if (spanningCells) {
 		for (const [, spanCell] of spanningCells) if (spanCell.startRow < rowIndex && spanCell.startRow + spanCell.rowSpan > rowIndex) for (let c = 0; c < spanCell.colSpan; c++) occupiedColumns.add(spanCell.columnIndex + c);
 	}
-	let x = 0;
-	let columnIndex = 0;
+	const gridBefore = row.gridBefore ?? 0;
+	let x = getTableRowLeadingWidth(row, columnWidths);
+	let columnIndex = gridBefore;
 	while (occupiedColumns.has(columnIndex)) {
 		x += columnWidths[columnIndex] ?? 0;
 		columnIndex++;
@@ -345,11 +367,18 @@ function renderTableRow(row, rowMeasure, rowIndex, y, columnWidths, totalRows, c
 		const isLastRow = rowIndex + rowSpan >= totalRows;
 		const atLogicalStart = columnIndex === 0;
 		const atLogicalEnd = columnIndex + colSpan >= columnWidths.length;
+		const isFirstCol = bidi ? atLogicalEnd : atLogicalStart;
+		const isLastCol = bidi ? atLogicalStart : atLogicalEnd;
+		const aboveCell = cellGrid?.get(tableCellGridKey(rowIndex - 1, columnIndex));
+		const leftNeighborColumn = bidi ? columnIndex + colSpan : columnIndex - 1;
+		const leftCell = cellGrid?.get(tableCellGridKey(rowIndex, leftNeighborColumn));
+		const drawTop = isFirstRow || !hasVisibleBorder(aboveCell?.borders?.bottom);
+		const drawLeft = isFirstCol || !hasVisibleBorder(leftCell?.borders?.right);
 		const cellEl = renderTableCell(cell, cellMeasure, cellLeft, cellHeight, {
-			isFirstRow,
+			drawTop,
 			isLastRow,
-			isFirstCol: bidi ? atLogicalEnd : atLogicalStart,
-			isLastCol: bidi ? atLogicalStart : atLogicalEnd
+			drawLeft,
+			isLastCol
 		}, columnsPinned, context, doc);
 		cellEl.dataset["cellIndex"] = String(cellIndex);
 		cellEl.dataset["columnIndex"] = String(columnIndex);
@@ -429,6 +458,7 @@ function renderTableFragment(fragment, block, measure, context, options = {}) {
 	rowYPositions.push(yPos);
 	const spanningCells = /* @__PURE__ */ new Map();
 	const columnsPinned = tableColumnsArePinned(block);
+	const cellGrid = buildTableCellGrid(block, measure.columnWidths.length);
 	const headerRowCount = fragment.headerRowCount ?? 0;
 	let y = 0;
 	if (headerRowCount > 0 && fragment.continuesFromPrev) for (let hdrIdx = 0; hdrIdx < headerRowCount; hdrIdx++) {
@@ -439,7 +469,7 @@ function renderTableFragment(fragment, block, measure, context, options = {}) {
 			y += hdrRowMeasure.height;
 			continue;
 		}
-		const rowEl = renderTableRow(hdrRow, hdrRowMeasure, hdrIdx, y, measure.columnWidths, block.rows.length, context, doc, spanningCells, rowYPositions, hdrIdx === 0, block.bidi, columnsPinned);
+		const rowEl = renderTableRow(hdrRow, hdrRowMeasure, hdrIdx, y, measure.columnWidths, block.rows.length, context, doc, spanningCells, rowYPositions, hdrIdx === 0, block.bidi, columnsPinned, cellGrid);
 		rowEl.dataset["repeatedHeader"] = "true";
 		tableEl.append(rowEl);
 		y += hdrRowMeasure.height;
@@ -467,7 +497,7 @@ function renderTableFragment(fragment, block, measure, context, options = {}) {
 			continue;
 		}
 		const isFirstRowInFragment = headerRowCount > 0 && fragment.continuesFromPrev ? false : fragment.continuesFromPrev && rowIndex === fragment.fromRow;
-		const rowEl = renderTableRow(row, rowMeasure, rowIndex, y, measure.columnWidths, block.rows.length, context, doc, spanningCells, rowYPositions, isFirstRowInFragment, block.bidi, columnsPinned);
+		const rowEl = renderTableRow(row, rowMeasure, rowIndex, y, measure.columnWidths, block.rows.length, context, doc, spanningCells, rowYPositions, isFirstRowInFragment, block.bidi, columnsPinned, cellGrid);
 		contentParent.append(rowEl);
 		y += rowMeasure.height;
 	}

package/dist/layout-painter/renderTextBox.js

@@ -1,5 +1,6 @@
 import { DEFAULT_TEXTBOX_MARGINS } from "../layout-engine/types.js";
 import { renderParagraphFragment } from "./renderParagraph.js";
+import { layoutTextBoxParagraphs } from "../layout-engine/measure/textBoxParagraphLayout.js";
 //#region src/layout-painter/renderTextBox.ts
 /**
 * Text Box Renderer
@@ -38,28 +39,37 @@ function renderTextBoxFragment(fragment, block, measure, context, options = {})
 	if (fragment.pmStart !== void 0) containerEl.dataset["pmStart"] = String(fragment.pmStart);
 	if (fragment.pmEnd !== void 0) containerEl.dataset["pmEnd"] = String(fragment.pmEnd);
 	const innerWidth = fragment.width - margins.left - margins.right;
-	let yOffset = 0;
+	const paragraphLayout = layoutTextBoxParagraphs(block.content, measure.innerMeasures);
 	for (let i = 0; i < block.content.length; i++) {
 		const paraBlock = block.content[i];
 		const paraMeasure = measure.innerMeasures[i];
-		if (!paraBlock || !paraMeasure) continue;
-		const paraEl = renderParagraphFragment({
+		const placement = paragraphLayout.placements[i];
+		if (!paraBlock || !paraMeasure || !placement) continue;
+		const paraFragment = {
 			kind: "paragraph",
 			blockId: paraBlock.id,
 			x: 0,
-			y: yOffset,
+			y: 0,
 			width: innerWidth,
-			height: paraMeasure.totalHeight,
+			height: placement.contentHeight,
 			...paraBlock.pmStart !== void 0 ? { pmStart: paraBlock.pmStart } : {},
 			...paraBlock.pmEnd !== void 0 ? { pmEnd: paraBlock.pmEnd } : {},
 			fromLine: 0,
 			toLine: paraMeasure.lines.length
-		}, paraBlock, paraMeasure, context, { document: doc });
+		};
+		const prevBorders = block.content[i - 1]?.attrs?.borders;
+		const nextBorders = block.content[i + 1]?.attrs?.borders;
+		const paraEl = renderParagraphFragment(paraFragment, paraBlock, paraMeasure, context, {
+			document: doc,
+			...prevBorders !== void 0 ? { prevBorders } : {},
+			...nextBorders !== void 0 ? { nextBorders } : {}
+		});
 		paraEl.style.position = "relative";
 		paraEl.style.left = "0";
 		paraEl.style.top = "0";
+		paraEl.style.height = `${placement.contentHeight}px`;
+		paraEl.style.marginTop = `${placement.leadingSpacing}px`;
 		containerEl.append(paraEl);
-		yOffset += paraMeasure.totalHeight;
 	}
 	return containerEl;
 }

package/dist/managers/DocumentLoaderManager.js

@@ -1,8 +1,8 @@
+import { inspectDocxCompatibility } from "../docx/compatibility.js";
 import { resetAuthorColors } from "../utils/authorColors.js";
 import { loadFontsWithMapping } from "../utils/fontLoader.js";
 import { parseDocx } from "../docx/parser.js";
 import { recordDocumentLoadPhase } from "../layout-engine/layoutInstrumentation.js";
-import { inspectDocxCompatibility } from "../docx/compatibility.js";
 //#region src/managers/DocumentLoaderManager.ts
 /**
 * DocumentLoaderManager

package/dist/paged-layout/sectionBlockWidths.d.ts

@@ -11,6 +11,9 @@ type PerBlockMeasureInputs = {
   widths: number[];
   marginTops: number[];
   pageHeights: number[];
+  pageWidths: number[];
+  marginLefts: number[];
+  marginRights: number[];
   marginBottoms: number[];
 };
 /**

package/dist/paged-layout/sectionBlockWidths.js

@@ -35,6 +35,9 @@ function computePerBlockMeasureInputs({ blocks, bodyConfig, finalConfig }) {
 	const widths = [];
 	const marginTops = [];
 	const pageHeights = [];
+	const pageWidths = [];
+	const marginLefts = [];
+	const marginRights = [];
 	const marginBottoms = [];
 	for (let i = 0; i < blocks.length; i++) {
 		const config = sectionConfigs[sectionIdx] ?? finalConfig;
@@ -42,6 +45,9 @@ function computePerBlockMeasureInputs({ blocks, bodyConfig, finalConfig }) {
 		widths.push(colWidth(contentWidth(config), columns, columnIndex));
 		marginTops.push(config.margins.top);
 		pageHeights.push(config.pageSize.h);
+		pageWidths.push(config.pageSize.w);
+		marginLefts.push(config.margins.left);
+		marginRights.push(config.margins.right);
 		marginBottoms.push(config.margins.bottom);
 		if (sectionIdx < breakIndices.length && i === breakIndices[sectionIdx]) {
 			sectionIdx++;
@@ -53,6 +59,9 @@ function computePerBlockMeasureInputs({ blocks, bodyConfig, finalConfig }) {
 		widths,
 		marginTops,
 		pageHeights,
+		pageWidths,
+		marginLefts,
+		marginRights,
 		marginBottoms
 	};
 }

package/dist/paged-layout/sectionGeometry.js

@@ -9,7 +9,7 @@ const DEFAULT_MARGINS = {
 	bottom: 96,
 	left: 96
 };
-const twipsToPixels = (twips) => Math.round(twips / 1440 * 96);
+const twipsToPixels = (twips) => twips / 1440 * 96;
 /**
 * Convert an offset-like twip dimension to px. Explicit 0 is meaningful for
 * page margins and header/footer distances; only absence should use fallback.

package/dist/prosemirror/attrs/index.js

@@ -18,6 +18,11 @@ const IMAGE_CSS_FLOATS = [
 	"right",
 	"none"
 ];
+const TEXT_BOX_AUTO_FIT_VALUES = [
+	"none",
+	"normal",
+	"shape"
+];
 const FIELD_KINDS = ["simple", "complex"];
 const MATH_DISPLAYS = ["inline", "block"];
 const SHAPE_FILL_TYPES = [
@@ -156,6 +161,11 @@ const readParagraphAttrs = (node) => {
 	optionalBoolean(attrs, "listMarkerHidden", "paragraph.attrs.listMarkerHidden", issues);
 	optionalString(attrs, "listMarkerFontFamily", "paragraph.attrs.listMarkerFontFamily", issues);
 	optionalNumber(attrs, "listMarkerFontSize", "paragraph.attrs.listMarkerFontSize", issues);
+	optionalOneOf(attrs, "listMarkerAlignment", "paragraph.attrs.listMarkerAlignment", issues, [
+		"left",
+		"center",
+		"right"
+	]);
 	optionalString(attrs, "listMarkerSuffix", "paragraph.attrs.listMarkerSuffix", issues);
 	optionalBoolean(attrs, "listMarkerAllCaps", "paragraph.attrs.listMarkerAllCaps", issues);
 	optionalNumber(attrs, "listImplicitChildLevelAdvances", "paragraph.attrs.listImplicitChildLevelAdvances", issues);
@@ -410,6 +420,7 @@ const readTextBoxAttrs = (node) => {
 	expectNodeType(node, "textBox", issues);
 	optionalNumber(attrs, "width", "textBox.attrs.width", issues);
 	optionalNumber(attrs, "height", "textBox.attrs.height", issues);
+	optionalOneOf(attrs, "autoFit", "textBox.attrs.autoFit", issues, TEXT_BOX_AUTO_FIT_VALUES);
 	optionalString(attrs, "textBoxId", "textBox.attrs.textBoxId", issues);
 	optionalString(attrs, "fillColor", "textBox.attrs.fillColor", issues);
 	optionalNumber(attrs, "outlineWidth", "textBox.attrs.outlineWidth", issues);

package/dist/prosemirror/conversion/fromProseDoc.js

@@ -210,6 +210,7 @@ function listRenderingFromAttrs(attrs) {
 		...attrs.listMarkerHidden != null && { markerHidden: attrs.listMarkerHidden },
 		...attrs.listMarkerFontFamily != null && { markerFontFamily: attrs.listMarkerFontFamily },
 		...attrs.listMarkerFontSize != null && { markerFontSize: attrs.listMarkerFontSize },
+		...attrs.listMarkerAlignment != null && { markerAlignment: attrs.listMarkerAlignment },
 		...attrs.listMarkerSuffix != null && { markerSuffix: attrs.listMarkerSuffix },
 		...attrs.listMarkerAllCaps != null && { markerAllCaps: attrs.listMarkerAllCaps },
 		...attrs.listImplicitChildLevelAdvances != null && { implicitChildLevelAdvances: attrs.listImplicitChildLevelAdvances },
@@ -1516,6 +1517,7 @@ function convertPMTextBox(node) {
 				type: "paragraph",
 				content: []
 			}],
+			...attrs.autoFit !== void 0 ? { autoFit: attrs.autoFit } : {},
 			margins: (() => {
 				const m = {};
 				if (typeof attrs.marginTop === "number") m.top = pixelsToEmu(attrs.marginTop);

package/dist/prosemirror/conversion/toProseDoc.js

@@ -227,6 +227,7 @@ function paragraphFormattingToAttrs(paragraph, styleResolver, tableParagraphOver
 	if (paragraph.listRendering?.markerHidden) attrs.listMarkerHidden = paragraph.listRendering.markerHidden;
 	if (paragraph.listRendering?.markerFontFamily) attrs.listMarkerFontFamily = paragraph.listRendering.markerFontFamily;
 	if (paragraph.listRendering?.markerFontSize) attrs.listMarkerFontSize = paragraph.listRendering.markerFontSize;
+	if (paragraph.listRendering?.markerAlignment) attrs.listMarkerAlignment = paragraph.listRendering.markerAlignment;
 	if (paragraph.listRendering?.markerSuffix) attrs.listMarkerSuffix = paragraph.listRendering.markerSuffix;
 	if (paragraph.listRendering?.markerAllCaps) attrs.listMarkerAllCaps = paragraph.listRendering.markerAllCaps;
 	if (paragraph.listRendering?.implicitChildLevelAdvances !== void 0) attrs.listImplicitChildLevelAdvances = paragraph.listRendering.implicitChildLevelAdvances;
@@ -259,11 +260,11 @@ function paragraphFormattingToAttrs(paragraph, styleResolver, tableParagraphOver
 		if (formatting?.spaceBefore === void 0 && tableParagraphOverlay?.spaceBefore === void 0 && paragraphStyle?.pPr?.spaceBefore === void 0 && docDefaultSpacing?.spaceBefore !== void 0) spacingFromDocDefaults.before = true;
 		if (formatting?.spaceAfter === void 0 && tableParagraphOverlay?.spaceAfter === void 0 && paragraphStyle?.pPr?.spaceAfter === void 0 && docDefaultSpacing?.spaceAfter !== void 0) spacingFromDocDefaults.after = true;
 		if (spacingFromDocDefaults.before || spacingFromDocDefaults.after) attrs.spacingFromDocDefaults = spacingFromDocDefaults;
-		set("indentLeft", formatting?.indentLeft ?? stylePpr?.indentLeft);
+		const numberingStyleIndent = formatting?.numPr?.numId === 0 && stylePpr?.numPr !== void 0 && stylePpr.numPr.numId !== 0 ? void 0 : stylePpr;
+		set("indentLeft", formatting?.indentLeft ?? numberingStyleIndent?.indentLeft);
 		set("indentRight", formatting?.indentRight ?? stylePpr?.indentRight);
-		const styleFirstLine = formatting?.numPr?.numId === 0 && stylePpr?.numPr !== void 0 && stylePpr.numPr.numId !== 0 ? void 0 : stylePpr;
-		set("indentFirstLine", formatting?.indentFirstLine ?? styleFirstLine?.indentFirstLine);
-		set("hangingIndent", formatting?.hangingIndent ?? styleFirstLine?.hangingIndent);
+		set("indentFirstLine", formatting?.indentFirstLine ?? numberingStyleIndent?.indentFirstLine);
+		set("hangingIndent", formatting?.hangingIndent ?? numberingStyleIndent?.hangingIndent);
 		set("borders", formatting?.borders ?? stylePpr?.borders);
 		set("shading", formatting?.shading ?? stylePpr?.shading);
 		set("tabs", formatting?.tabs ?? stylePpr?.tabs);
@@ -301,7 +302,7 @@ function paragraphFormattingToAttrs(paragraph, styleResolver, tableParagraphOver
 		set("runInWithNext", formatting?.runInWithNext);
 		set("outlineLevel", formatting?.outlineLevel);
 		set("direction", directionFromBidi(formatting?.bidi));
-		set("defaultTextFormatting", resolveTextFormatting(formatting?.runProperties, styleResolver));
+		set("defaultTextFormatting", stripParagraphMarkOnlyFormatting(resolveTextFormatting(formatting?.runProperties, styleResolver) ?? {}));
 	}
 	if (paragraph.sectionProperties) {
 		attrs._sectionProperties = paragraph.sectionProperties;
@@ -401,33 +402,33 @@ function hasDirectRunFormatting(formatting) {
 	return Object.entries(formatting).some(([key, value]) => key !== "styleId" && value !== void 0);
 }
 function stripParagraphMarkOnlyFormatting(formatting) {
-	const { allCaps: _ac, highlight: _h, shading: _s, smallCaps: _sc, ...rest } = formatting;
+	const { allCaps: _ac, highlight: _h, shading: _s, smallCaps: _sc, vertAlign: _va, ...rest } = formatting;
 	return Object.keys(rest).length > 0 ? rest : void 0;
 }
 function suppressParagraphMarkFormatting(base, paragraphMark, direct, paragraphMarkPrecedesStyle = false) {
 	if (!paragraphMark) return base;
 	const result = (paragraphMarkPrecedesStyle ? mergeTextFormatting(paragraphMark, base) : mergeTextFormatting(base, paragraphMark)) ?? {};
-	suppressBooleanParagraphMark(result, paragraphMark, direct, "bold");
-	suppressBooleanParagraphMark(result, paragraphMark, direct, "italic");
-	suppressBooleanParagraphMark(result, paragraphMark, direct, "strike");
-	suppressBooleanParagraphMark(result, paragraphMark, direct, "doubleStrike");
-	suppressBooleanParagraphMark(result, paragraphMark, direct, "allCaps");
-	suppressBooleanParagraphMark(result, paragraphMark, direct, "smallCaps");
-	suppressBooleanParagraphMark(result, paragraphMark, direct, "hidden");
-	suppressBooleanParagraphMark(result, paragraphMark, direct, "emboss");
-	suppressBooleanParagraphMark(result, paragraphMark, direct, "imprint");
-	suppressBooleanParagraphMark(result, paragraphMark, direct, "shadow");
-	suppressBooleanParagraphMark(result, paragraphMark, direct, "outline");
-	suppressBooleanParagraphMark(result, paragraphMark, direct, "rtl");
+	suppressBooleanParagraphMark(result, base, paragraphMark, direct, "bold");
+	suppressBooleanParagraphMark(result, base, paragraphMark, direct, "italic");
+	suppressBooleanParagraphMark(result, base, paragraphMark, direct, "strike");
+	suppressBooleanParagraphMark(result, base, paragraphMark, direct, "doubleStrike");
+	suppressBooleanParagraphMark(result, base, paragraphMark, direct, "allCaps");
+	suppressBooleanParagraphMark(result, base, paragraphMark, direct, "smallCaps");
+	suppressBooleanParagraphMark(result, base, paragraphMark, direct, "hidden");
+	suppressBooleanParagraphMark(result, base, paragraphMark, direct, "emboss");
+	suppressBooleanParagraphMark(result, base, paragraphMark, direct, "imprint");
+	suppressBooleanParagraphMark(result, base, paragraphMark, direct, "shadow");
+	suppressBooleanParagraphMark(result, base, paragraphMark, direct, "outline");
+	suppressBooleanParagraphMark(result, base, paragraphMark, direct, "rtl");
 	if (paragraphMark.fontSize !== void 0 && direct?.fontSize === void 0 && base?.fontSize !== void 0) result.fontSize = base.fontSize;
 	if (paragraphMark.fontSizeCs !== void 0 && direct?.fontSizeCs === void 0 && base?.fontSizeCs !== void 0) result.fontSizeCs = base.fontSizeCs;
 	if (paragraphMark.underline !== void 0 && direct?.underline === void 0) result.underline = { style: "none" };
 	if (paragraphMark.spacing !== void 0 && direct?.spacing === void 0) result.spacing = 0;
 	return Object.keys(result).length > 0 ? result : void 0;
 }
-function suppressBooleanParagraphMark(result, paragraphMark, direct, key) {
+function suppressBooleanParagraphMark(result, base, paragraphMark, direct, key) {
 	if (paragraphMark[key] === void 0 || direct?.[key] !== void 0) return;
-	result[key] = false;
+	result[key] = base?.[key] ?? false;
 }
 function resolveTextFormatting(formatting, styleResolver) {
 	if (!formatting) return styleResolver?.resolveRunStyle(null);
@@ -456,7 +457,7 @@ function calculateRowSpans(table) {
 			clearActiveVerticalMerges(activeMerges, result);
 			continue;
 		}
-		let colIndex = 0;
+		let colIndex = row.formatting?.gridBefore ?? 0;
 		const rowCells = row.cells.map((cell) => {
 			const colspan = cell.formatting?.gridSpan ?? 1;
 			const vMerge = cell.formatting?.vMerge;
@@ -549,6 +550,7 @@ function convertTable(table, styleResolver, context) {
 	const fallbackTableStyle = tableStyleId ? void 0 : defaultTableStyle;
 	const conditionalTableStyleId = tableStyle?.styleId ?? fallbackTableStyle?.styleId;
 	const resolvedTableBorders = table.formatting?.borders ?? tableStyle?.tblPr?.borders ?? fallbackTableStyle?.tblPr?.borders;
+	const resolvedTableIndent = table.formatting?.indent ?? tableStyle?.tblPr?.indent ?? fallbackTableStyle?.tblPr?.indent;
 	const tableCellMargins = table.formatting?.cellMargins ?? tableStyle?.tblPr?.cellMargins ?? fallbackTableStyle?.tblPr?.cellMargins;
 	let cellMarginsAttr;
 	if (tableCellMargins) {
@@ -569,6 +571,7 @@ function convertTable(table, styleResolver, context) {
 	if (cellMarginsAttr) attrs.cellMargins = cellMarginsAttr;
 	if (table.formatting?.look) attrs.look = table.formatting.look;
 	if (table.formatting?.borders) attrs.borders = table.formatting.borders;
+	if (resolvedTableIndent) attrs._resolvedIndent = resolvedTableIndent;
 	if (table.formatting) attrs._originalFormatting = table.formatting;
 	if (table.propertyChanges && table.propertyChanges.length > 0) attrs.tblPrChange = [...table.propertyChanges];
 	const conditionalStyles = {};
@@ -614,8 +617,9 @@ function convertTable(table, styleResolver, context) {
 function countTableColumns(rows) {
 	let maxColumns = 0;
 	for (const row of rows) {
-		let rowColumns = 0;
+		let rowColumns = row.formatting?.gridBefore ?? 0;
 		for (const cell of row.cells) rowColumns += cell.formatting?.gridSpan ?? 1;
+		rowColumns += row.formatting?.gridAfter ?? 0;
 		maxColumns = Math.max(maxColumns, rowColumns);
 	}
 	return maxColumns;
@@ -649,7 +653,7 @@ function convertTableRow(row, styleResolver, context, isHeaderRow, columnWidths,
 		if (totalCols > 1) fallback.formatting = { gridSpan: totalCols };
 		effectiveCells = [fallback];
 	}
-	let colIndex = 0;
+	let colIndex = row.formatting?.gridBefore ?? 0;
 	const cells = [];
 	for (const cellIndex_item of effectiveCells) {
 		const cell = cellIndex_item;
@@ -1262,6 +1266,7 @@ function extractTextBoxesFromParagraph(paragraph) {
 				if (shape.fill) textBox.fill = shape.fill;
 				if (shape.outline) textBox.outline = shape.outline;
 				if (shape.textBody.margins) textBox.margins = shape.textBody.margins;
+				if (shape.textBody.autoFit) textBox.autoFit = shape.textBody.autoFit;
 				textBoxes.push(textBox);
 			}
 		}
@@ -1330,6 +1335,7 @@ function convertTextBox(textBox, styleResolver, options = {}) {
 	return schema.node("textBox", {
 		width: widthPx,
 		height: heightPx,
+		autoFit: textBox.autoFit,
 		textBoxId: textBox.id,
 		fillColor,
 		outlineWidth,

package/dist/prosemirror/extensions/core/ParagraphExtension.js

@@ -199,6 +199,7 @@ const paragraphNodeSpec = {
 		listMarkerHidden: { default: null },
 		listMarkerFontFamily: { default: null },
 		listMarkerFontSize: { default: null },
+		listMarkerAlignment: { default: null },
 		listMarkerSuffix: { default: null },
 		listMarkerAllCaps: { default: null },
 		listImplicitChildLevelAdvances: { default: null },

package/dist/prosemirror/extensions/features/ListExtension.js

@@ -34,6 +34,7 @@ const LIST_FORMATTING_ATTRS = [
 	"listMarkerHidden",
 	"listMarkerFontFamily",
 	"listMarkerFontSize",
+	"listMarkerAlignment",
 	"listMarkerSuffix",
 	"listLevelNumFmts",
 	"listLevelStarts",