@stll/folio-core 0.32.2 → 0.33.0

package/dist/layout-engine/measure/advanceComposition.js

@@ -0,0 +1,148 @@
+import { getHorizontalScaleFactor } from "../../utils/horizontalScale.js";
+import { SCRIPT_CLASS, hasComplexScript, scriptClassOf, segmentByScript } from "../../utils/scriptSegments.js";
+import { applyComplexScriptFormatting, hasComplexScriptFormatting } from "./complexScriptFormatting.js";
+//#region src/layout-engine/measure/advanceComposition.ts
+/**
+* The arithmetic that turns raw glyph advances into measured widths.
+*
+* Text transform, per-script font selection, letter spacing and horizontal
+* scale are the same calculation whoever supplies the advances: a canvas, a
+* parsed font, a shaper. Only the advance source differs. Keeping the
+* calculation here and parameterizing the source means a second measurement
+* backend can disagree with the canvas one about a glyph's width (which the
+* differential tests measure) but cannot disagree about where letter spacing
+* goes or which font a CJK code point takes.
+*
+* Pure: no canvas, no DOM, no caching.
+*/
+const applyMeasurementTextTransform = (text, style) => style.textTransform === "uppercase" ? text.toLocaleUpperCase() : text;
+const countCodePoints = (text) => [...text].length;
+/** Resolve the independent font/style slot a script segment selects. */
+const scriptStyle = (style, script) => {
+	if (script === SCRIPT_CLASS.eastAsia) {
+		if (style.eastAsiaFontFamily === void 0) return style;
+		const result = {
+			...style,
+			fontFamily: style.eastAsiaFontFamily
+		};
+		delete result.alternateFontFamily;
+		if (style.eastAsiaAlternateFontFamily !== void 0) result.alternateFontFamily = style.eastAsiaAlternateFontFamily;
+		return result;
+	}
+	if (script === SCRIPT_CLASS.complex) return applyComplexScriptFormatting(style, style);
+	return style;
+};
+/**
+* Keep only the properties that change a glyph's advance, so a per-script
+* segment takes the single-font path: letter spacing and horizontal scale are
+* applied once over the whole string, never per segment.
+*/
+const glyphAdvanceStyle = (style) => {
+	const result = {};
+	if (style.fontFamily !== void 0) result.fontFamily = style.fontFamily;
+	if (style.alternateFontFamily !== void 0) result.alternateFontFamily = style.alternateFontFamily;
+	if (style.fontSize !== void 0) result.fontSize = style.fontSize;
+	if (style.bold !== void 0) result.bold = style.bold;
+	if (style.italic !== void 0) result.italic = style.italic;
+	if (style.fontVariant !== void 0) result.fontVariant = style.fontVariant;
+	if (style.kerning !== void 0) result.kerning = style.kerning;
+	return result;
+};
+const needsPerScriptFonts = (style, text) => style.eastAsiaFontFamily !== void 0 && [...text].some((c) => isEastAsia(c)) || hasComplexScriptFormatting(style) && hasComplexScript(text);
+const isEastAsia = (char) => {
+	return scriptClassOf(char.codePointAt(0)) === SCRIPT_CLASS.eastAsia;
+};
+/**
+* Width of a string: the advance width used for line breaking, never the
+* painted (ink) extent, which includes overhang a break decision must ignore.
+*/
+const composeTextWidth = ({ text, style: source, advanceOf }) => {
+	if (!text) return 0;
+	const style = source.forceComplexScript ? applyComplexScriptFormatting(source, source) : source;
+	const transformed = applyMeasurementTextTransform(text, style);
+	const letterSpacing = style.letterSpacing ?? 0;
+	const horizontalScale = getHorizontalScaleFactor(style.horizontalScale);
+	const glyphWidth = !source.forceComplexScript && !letterSpacing && needsPerScriptFonts(style, transformed) ? segmentByScript(transformed).reduce((sum, segment) => sum + advanceOf(segment.text, glyphAdvanceStyle(scriptStyle(style, segment.script))), 0) : advanceOf(transformed, style);
+	const codePoints = countCodePoints(transformed);
+	return (letterSpacing && codePoints > 1 ? glyphWidth + letterSpacing * (codePoints - 1) : glyphWidth) * horizontalScale;
+};
+/**
+* Per-code-point advances for click positioning.
+*
+* Iterates whole code points so an astral ideograph takes the East-Asian font
+* and gets a real width, while `charWidths` stays one entry per UTF-16 unit
+* (the trailing unit of a surrogate pair carries 0) so it keeps aligning with
+* ProseMirror offsets. The total differs from {@link composeTextWidth} for a
+* kerned or ligature-forming run, because each code point is measured alone.
+*/
+const composeRunMeasurement = ({ text, style: source, metrics, advanceOf, advancesOf }) => {
+	const style = source.forceComplexScript ? applyComplexScriptFormatting(source, source) : source;
+	if (!text) return {
+		width: 0,
+		charWidths: [],
+		metrics
+	};
+	const perScript = !style.letterSpacing;
+	const letterSpacing = style.letterSpacing ?? 0;
+	const scale = getHorizontalScaleFactor(style.horizontalScale);
+	const charWidths = [];
+	let totalWidth = 0;
+	let offset = 0;
+	const shaped = shapedAdvances({
+		text,
+		style,
+		advancesOf,
+		perScript
+	});
+	let codePointIndex = 0;
+	for (const char of text) {
+		const cp = char.codePointAt(0);
+		const charStyle = perScript ? scriptStyle(style, scriptClassOf(cp)) : style;
+		let charWidth = shaped.get(codePointIndex) ?? advanceOf(applyMeasurementTextTransform(char, style), charStyle);
+		if (letterSpacing && offset + char.length < text.length) charWidth += letterSpacing;
+		charWidth *= scale;
+		charWidths.push(charWidth);
+		if (char.length === 2) charWidths.push(0);
+		totalWidth += charWidth;
+		offset += char.length;
+		codePointIndex += 1;
+	}
+	return {
+		width: totalWidth,
+		charWidths,
+		metrics
+	};
+};
+/**
+* Advances by code-point index for every stretch of the run that shapes.
+*
+* Each such stretch is measured in one call, because that is the only unit
+* shaping has an answer for. A text transform that changes the length of a
+* shaping stretch would break the alignment between the advances and the
+* source's code points, so the transform is applied to the stretch and the
+* result is only used when it did not change.
+*/
+const shapedAdvances = ({ text, style, advancesOf, perScript }) => {
+	const byIndex = /* @__PURE__ */ new Map();
+	if (advancesOf === void 0 || !hasComplexScript(text)) return byIndex;
+	const characters = [...text];
+	const shapingStyle = perScript ? scriptStyle(style, SCRIPT_CLASS.complex) : style;
+	let start = 0;
+	while (start < characters.length) {
+		if (scriptClassOf(characters[start].codePointAt(0)) !== SCRIPT_CLASS.complex) {
+			start += 1;
+			continue;
+		}
+		let end = start + 1;
+		while (end < characters.length && scriptClassOf(characters[end].codePointAt(0)) === SCRIPT_CLASS.complex) end += 1;
+		const segment = characters.slice(start, end).join("");
+		if (applyMeasurementTextTransform(segment, style) === segment) {
+			const advances = advancesOf(segment, shapingStyle);
+			for (const [offset, advance] of advances.entries()) byIndex.set(start + offset, advance);
+		}
+		start = end;
+	}
+	return byIndex;
+};
+//#endregion
+export { applyMeasurementTextTransform, composeRunMeasurement, composeTextWidth, glyphAdvanceStyle, scriptStyle };

package/dist/layout-engine/measure/cache.d.ts

@@ -31,6 +31,8 @@ declare function getTextCacheSize(): number;
 type FontMetricsEntry = {
   ascent: number;
   descent: number;
+  fontBoxAscent: number;
+  fontBoxDescent: number;
   lineHeight: number;
   singleLineRatio: number;
 };

package/dist/layout-engine/measure/measureContainer.js

@@ -81,6 +81,8 @@ function canvasGetFontMetrics(style) {
 		fontSize,
 		ascent: cached.ascent,
 		descent: cached.descent,
+		fontBoxAscent: cached.fontBoxAscent,
+		fontBoxDescent: cached.fontBoxDescent,
 		lineHeight: cached.lineHeight,
 		fontFamily,
 		singleLineRatio: cached.singleLineRatio
@@ -88,6 +90,8 @@ function canvasGetFontMetrics(style) {
 	const fontSizePx = ptToPx(fontSize);
 	let ascent = fontSizePx * DEFAULT_ASCENT_RATIO;
 	let descent = fontSizePx * DEFAULT_DESCENT_RATIO;
+	let fontBoxAscent = ascent;
+	let fontBoxDescent = descent;
 	let lineHeight = fontSizePx * DEFAULT_LINE_HEIGHT_MULTIPLIER;
 	try {
 		const ctx = getCanvasContext();
@@ -98,6 +102,13 @@ function canvasGetFontMetrics(style) {
 			ascent = metrics.actualBoundingBoxAscent;
 			descent = metrics.actualBoundingBoxDescent;
 		}
+		if (typeof metrics.fontBoundingBoxAscent === "number" && typeof metrics.fontBoundingBoxDescent === "number") {
+			fontBoxAscent = metrics.fontBoundingBoxAscent;
+			fontBoxDescent = metrics.fontBoundingBoxDescent;
+		} else {
+			fontBoxAscent = ascent;
+			fontBoxDescent = descent;
+		}
 	} catch {}
 	lineHeight = Math.max(lineHeight, ascent + descent);
 	const singleLineRatio = getResolvedData(fontFamily, alternateFontFamily).singleLineRatio;
@@ -105,6 +116,8 @@ function canvasGetFontMetrics(style) {
 		fontSize,
 		ascent,
 		descent,
+		fontBoxAscent,
+		fontBoxDescent,
 		lineHeight,
 		fontFamily,
 		singleLineRatio

package/dist/layout-engine/measure/measureParagraph.js

@@ -369,7 +369,7 @@ function uppercaseLetterRatio(text) {
 	return letters === 0 ? 0 : uppercase / letters;
 }
 function resolveJustifyFitStrategy(block, isFirstLine, profile) {
-	if (block.attrs?.justificationCompatibility?.type === "legacy") return { type: "strict" };
+	if (block.attrs?.justificationCompatibility?.type === "legacy") return { type: "rounding" };
 	if (isShallowFullHangingListContinuation(block, isFirstLine)) return { type: "rounding" };
 	if (block.attrs?.listMarker !== void 0) {
 		const hanging = block.attrs.indent?.hanging ?? 0;
@@ -461,7 +461,6 @@ function compressibleSpaceWidth(text, style) {
 	return count === 0 ? 0 : count * measureTextWidth(" ", style);
 }
 function justifyFitTolerance(line, strategy, candidateSpaceWidth) {
-	if (strategy.type === "strict") return 0;
 	if (strategy.type === "rounding") return WIDTH_TOLERANCE;
 	if (strategy.type === "width") return Math.max(WIDTH_TOLERANCE, line.availableWidth * strategy.ratio);
 	const spaceTolerance = (line.regularSpaceWidth + candidateSpaceWidth) * strategy.ratio;

package/dist/layout-engine/measure/measureTypes.d.ts

@@ -48,8 +48,20 @@ type FontStyle = {
  */
 type FontMetrics = {
   fontSize: number;
+  /** Ink extent above the baseline: how far the glyphs actually reach. */
   ascent: number;
+  /** Ink extent below the baseline. */
   descent: number;
+  /**
+   * Extent of the font's own box (hhea/OS-2), which is wider than the ink and
+   * is what a browser builds an inline content area from. A painter that
+   * positions a text box from the ink extents instead puts every baseline out
+   * by half the difference between the two, per face, with nothing to
+   * attribute it to. Carried beside the ink extents rather than replacing them
+   * because line boxes are sized from the ink.
+   */
+  fontBoxAscent: number;
+  fontBoxDescent: number;
   lineHeight: number;
   fontFamily: string;
   /** OS/2 single-line ratio for OOXML line spacing calculation */

package/dist/layout-engine/measure/tableInlinePlacement.d.ts

@@ -6,10 +6,11 @@ type TableInlinePlacement = {
   alignment: "left" | "right";
   offset: number;
 };
+type LeadingEdgeTable = Pick<TableBlock, "bidi" | "indent" | "indentCompatibility" | "justification" | "rows">;
 /** Resolve an inline table's horizontal anchor without losing RTL leading-edge semantics. */
-declare const resolveTableInlinePlacement: (table: Pick<TableBlock, "bidi" | "indent" | "justification">, rowJustification?: TableBlock["justification"]) => TableInlinePlacement;
+declare const resolveTableInlinePlacement: (table: LeadingEdgeTable, rowJustification?: TableBlock["justification"]) => TableInlinePlacement;
 type ResolveTableInlineOffsetOptions = {
-  table: Pick<TableBlock, "bidi" | "indent" | "justification">;
+  table: LeadingEdgeTable;
   rowJustification?: TableBlock["justification"];
   frameWidth: number;
   tableWidth: number;

package/dist/layout-engine/measure/tableInlinePlacement.js

@@ -1,9 +1,22 @@
+import { resolveTableCellPadding } from "../types.js";
 //#region src/layout-engine/measure/tableInlinePlacement.ts
+/**
+* Distance the leading border is pulled back so the leading cell's text lands
+* on `w:tblInd`. Zero unless the document uses the pre-Word-2013 indent
+* semantics, where the indent measures to that text edge rather than to the
+* border. Only the leading, indent-bearing edge compensates; centered and
+* trailing-edge tables are placed by their border box.
+*/
+const leadingEdgeCompensation = (table) => {
+	if (table.indentCompatibility?.type !== "legacy") return 0;
+	const padding = resolveTableCellPadding(table.rows.at(0)?.cells.at(0));
+	return table.bidi === true ? padding.right : padding.left;
+};
 /** Resolve an inline table's horizontal anchor without losing RTL leading-edge semantics. */
 const resolveTableInlinePlacement = (table, rowJustification) => {
 	const logicalJustification = rowJustification ?? table.justification ?? "left";
 	if (logicalJustification === "center") return { alignment: "center" };
-	const offset = logicalJustification === "left" ? table.indent ?? 0 : 0;
+	const offset = logicalJustification === "left" ? (table.indent ?? 0) - leadingEdgeCompensation(table) : 0;
 	if (table.bidi !== true) return {
 		alignment: logicalJustification,
 		offset

package/dist/layout-engine/tableIndentCompatibility.d.ts

@@ -0,0 +1,5 @@
+import { TableBlock } from "./types.js";
+//#region src/layout-engine/tableIndentCompatibility.d.ts
+declare const resolveTableIndentCompatibility: (compatibilityMode: number | undefined) => NonNullable<TableBlock["indentCompatibility"]> | undefined;
+//#endregion
+export { resolveTableIndentCompatibility };

package/dist/layout-engine/tableIndentCompatibility.js

@@ -0,0 +1,15 @@
+//#region src/layout-engine/tableIndentCompatibility.ts
+/**
+* First `compatibilityMode` that measures `w:tblInd` to the table border.
+*
+* Word 2013 moved the reference edge: from that mode on, `w:tblInd` offsets
+* the border and the leading cell margin pushes the text further in. Earlier
+* modes measure the indent to the leading cell's text edge and pull the border
+* back by that cell's leading margin, so the first character lands exactly on
+* the indent. A document that declares no `compatSetting` at all is read with
+* the oldest semantics, so it takes the legacy rule too.
+*/
+const FIRST_BORDER_EDGE_INDENT_COMPATIBILITY_MODE = 15;
+const resolveTableIndentCompatibility = (compatibilityMode) => compatibilityMode !== void 0 && compatibilityMode >= FIRST_BORDER_EDGE_INDENT_COMPATIBILITY_MODE ? void 0 : { type: "legacy" };
+//#endregion
+export { resolveTableIndentCompatibility };

package/dist/layout-engine/types.d.ts

@@ -644,6 +644,14 @@ type TableBlock = {
   justification?: "left" | "center" | "right";
   /** Table indent from the leading margin (in pixels, from w:tblInd). */
   indent?: number;
+  /**
+   * Pre-Word-2013 `w:tblInd` semantics: the indent measures to the leading
+   * cell's text edge instead of the table border. Derived from the document's
+   * `compatibilityMode` (see `resolveTableIndentCompatibility`).
+   */
+  indentCompatibility?: {
+    type: "legacy";
+  };
   /** Right-to-left column order (w:bidiVisual): logical column 0 paints on the right. */
   bidi?: boolean;
   /** Floating table properties (pixel values). */

package/dist/layout-painter/renderPage.d.ts

@@ -84,6 +84,12 @@ type FootnoteRenderItem = {
 /**
  * Options for rendering a page
  */
+/** Everything a replacement page renderer is handed. */
+type PaintPageRequest = {
+  readonly page: Page;
+  readonly context: RenderContext;
+  readonly options: RenderPageOptions;
+};
 type RenderPageOptions = {
   /** Document to create elements in (default: window.document) */
   document?: Document;
@@ -163,6 +169,17 @@ type RenderPageOptions = {
    * silently skipped.
    */
   watermarkImageSrc?: string;
+  /**
+   * Paints the page in place of this module, returning the finished element.
+   *
+   * The one seam a second page renderer needs: everything around it (page
+   * shells, virtualization, the fingerprint comparison, the intersection
+   * observer, the painted event) is a page-container concern rather than a
+   * painting one, and stays shared. Returning `null` falls back to this
+   * module for that page, so a renderer that cannot express a page yields
+   * rather than painting it wrong.
+   */
+  paintPage?: (request: PaintPageRequest) => HTMLElement | null;
 };
 type HeaderFooterLayoutInfo = {
   flowTop: number;
@@ -242,6 +259,17 @@ declare function renderFootnoteArea(footnotes: FootnoteRenderItem[], contentWidt
  * @returns The page DOM element
  */
 declare function renderPage(page: Page, context: RenderContext, options?: RenderPageOptions): HTMLElement;
+/**
+ * Which header and footer part a page selects, by `w:titlePg` and
+ * `w:evenAndOddHeaders`. Exported because a second consumer needs to tell "this
+ * page selects no part" from "this page selects a part nobody supplied", and
+ * recomputing the rule to answer that is how the two would come to disagree
+ * about which header a page carries. `undefined` means the page selects none.
+ */
+declare function selectSectionHeaderFooterRIds(page: Page): {
+  headerRId: string | undefined;
+  footerRId: string | undefined;
+};
 declare function applySectionHeaderFooterOptions(page: Page, pageOptions: RenderPageOptions, options: RenderPageOptions): boolean;
 /**
  * Compute a fingerprint string for a page that changes when its content changes.
@@ -302,4 +330,4 @@ declare function findPageShellForPmPos(container: HTMLElement, pmPos: number): {
   isExact: boolean;
 } | null;
 //#endregion
-export { type AnchoredImagePosition, FootnoteRenderItem, type HeaderFooterContent, HeaderFooterLayoutInfo, PAGE_CLASS_NAMES, PAINTER_PAINTED_EVENT, PageFloatingImage, type PageGeometry, PainterPaintedDetail, type RenderContext, RenderPageOptions, applySectionHeaderFooterOptions, calculateFootnoteAreaRenderHeight, computePageFingerprint, emuToPixels, findPageShellForPmPos, floatingTableReservesBand, getDefaultPageFontFamily, isFloatingImageRun, renderAllPagesNow, renderFloatingImagesLayer, renderFootnoteArea, renderPage, renderPages, resolveAnchoredImagePosition, resolveHeaderFooterFloatLeft, resolveHeaderFooterIntrinsicFrameHorizontalPosition };
+export { type AnchoredImagePosition, FootnoteRenderItem, type HeaderFooterContent, HeaderFooterLayoutInfo, PAGE_CLASS_NAMES, PAINTER_PAINTED_EVENT, PageFloatingImage, type PageGeometry, PaintPageRequest, PainterPaintedDetail, type RenderContext, RenderPageOptions, applySectionHeaderFooterOptions, calculateFootnoteAreaRenderHeight, computePageFingerprint, emuToPixels, findPageShellForPmPos, floatingTableReservesBand, getDefaultPageFontFamily, isFloatingImageRun, renderAllPagesNow, renderFloatingImagesLayer, renderFootnoteArea, renderPage, renderPages, resolveAnchoredImagePosition, resolveHeaderFooterFloatLeft, resolveHeaderFooterIntrinsicFrameHorizontalPosition, selectSectionHeaderFooterRIds };

package/dist/layout-painter/renderPage.js

@@ -1,6 +1,7 @@
 import { resolveFloatingTableX } from "../layout-engine/measure/floatingTablePosition.js";
 import { rectsToFloatingZones } from "../layout-engine/measure/floatingZones.js";
 import { measureParagraph } from "../layout-engine/measure/measureParagraph.js";
+import { resolveTableInlineOffset } from "../layout-engine/measure/tableInlinePlacement.js";
 import { floatingTextBoxReservesBand, floatingTextBoxWrapsText, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun } from "../layout-engine/types.js";
 import { resolveFontFamily } from "../utils/fontResolver.js";
 import { borderToStyle } from "../utils/formatToStyle.js";
@@ -504,10 +505,11 @@ function renderHeaderFooterContent(content, context, options, layout) {
 				fragEl.style.left = `${left}px`;
 				containerEl.append(fragEl);
 			} else {
-				let inlineLeft = 0;
-				if (block.justification === "center") inlineLeft = (contentWidth - measure.totalWidth) / 2;
-				else if (block.justification === "right") inlineLeft = contentWidth - measure.totalWidth;
-				else if (block.indent) inlineLeft = block.indent;
+				const inlineLeft = resolveTableInlineOffset({
+					table: block,
+					frameWidth: contentWidth,
+					tableWidth: measure.totalWidth
+				});
 				fragEl.style.position = "absolute";
 				fragEl.style.top = `${cursorY}px`;
 				fragEl.style.left = `${inlineLeft}px`;
@@ -816,6 +818,12 @@ function getFootnoteMeasureHeight(measure) {
 */
 function renderPage(page, context, options = {}) {
 	const doc = options.document ?? document;
+	const painted = options.paintPage?.({
+		page,
+		context,
+		options
+	});
+	if (painted) return painted;
 	const pageEl = doc.createElement("div");
 	pageEl.className = options.pageClassName ?? PAGE_CLASS_NAMES.page;
 	pageEl.dataset["pageNumber"] = String(page.number);
@@ -1171,22 +1179,42 @@ function moveBehindHeaderFooterElementsToPage(slotEl, pageEl, contentTop, conten
 		pageEl.prepend(element);
 	}
 }
-function applySectionHeaderFooterOptions(page, pageOptions, options) {
+/**
+* Which header and footer part a page selects, by `w:titlePg` and
+* `w:evenAndOddHeaders`. Exported because a second consumer needs to tell "this
+* page selects no part" from "this page selects a part nobody supplied", and
+* recomputing the rule to answer that is how the two would come to disagree
+* about which header a page carries. `undefined` means the page selects none.
+*/
+function selectSectionHeaderFooterRIds(page) {
 	const refs = page.headerFooterRefs;
-	if (!refs) return false;
-	const isFirstSectionPage = page.sectionPageNumber === 1;
-	const useFirst = refs.titlePg === true && isFirstSectionPage;
+	if (!refs) return {
+		headerRId: void 0,
+		footerRId: void 0
+	};
+	const useFirst = refs.titlePg === true && page.sectionPageNumber === 1;
 	const useEven = refs.evenAndOddHeaders === true && page.logicalNumber % 2 === 0;
-	const headerRId = (() => {
-		if (useFirst) return refs.headerFirst;
-		if (useEven) return refs.headerEven;
-		return refs.headerDefault;
-	})();
-	const footerRId = (() => {
-		if (useFirst) return refs.footerFirst;
-		if (useEven) return refs.footerEven;
-		return refs.footerDefault;
-	})();
+	const pick = (variants) => {
+		if (useFirst) return variants.first;
+		if (useEven) return variants.even;
+		return variants.fallback;
+	};
+	return {
+		headerRId: pick({
+			first: refs.headerFirst,
+			even: refs.headerEven,
+			fallback: refs.headerDefault
+		}),
+		footerRId: pick({
+			first: refs.footerFirst,
+			even: refs.footerEven,
+			fallback: refs.footerDefault
+		})
+	};
+}
+function applySectionHeaderFooterOptions(page, pageOptions, options) {
+	if (!page.headerFooterRefs) return false;
+	const { headerRId, footerRId } = selectSectionHeaderFooterRIds(page);
 	if (headerRId) {
 		const content = options.headerContentByRId?.get(headerRId);
 		if (content) pageOptions.headerContent = content;
@@ -1864,4 +1892,4 @@ function depopulatePageShell(shell, pageDataMap) {
 	}
 }
 //#endregion
-export { PAGE_CLASS_NAMES, PAINTER_PAINTED_EVENT, applySectionHeaderFooterOptions, calculateFootnoteAreaRenderHeight, computePageFingerprint, emuToPixels, findPageShellForPmPos, floatingTableReservesBand, getDefaultPageFontFamily, isFloatingImageRun, renderAllPagesNow, renderFloatingImagesLayer, renderFootnoteArea, renderPage, renderPages, resolveAnchoredImagePosition, resolveHeaderFooterFloatLeft, resolveHeaderFooterIntrinsicFrameHorizontalPosition };
+export { PAGE_CLASS_NAMES, PAINTER_PAINTED_EVENT, applySectionHeaderFooterOptions, calculateFootnoteAreaRenderHeight, computePageFingerprint, emuToPixels, findPageShellForPmPos, floatingTableReservesBand, getDefaultPageFontFamily, isFloatingImageRun, renderAllPagesNow, renderFloatingImagesLayer, renderFootnoteArea, renderPage, renderPages, resolveAnchoredImagePosition, resolveHeaderFooterFloatLeft, resolveHeaderFooterIntrinsicFrameHorizontalPosition, selectSectionHeaderFooterRIds };

package/dist/layout-painter/renderParagraph.d.ts

@@ -1,4 +1,4 @@
-import { HyperlinkInfo, MeasuredLine, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphMeasure, Run, TabStop } from "../layout-engine/types.js";
+import { HyperlinkInfo, MeasuredLine, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphMeasure, Run, TabRun, TabStop, TextRun } from "../layout-engine/types.js";
 import { RenderContext } from "./renderUtils.js";
 import { PhysicalParagraphInlineLayout } from "../utils/paragraphInlineLayout.js";
 //#region src/layout-painter/renderParagraph.d.ts
@@ -29,6 +29,11 @@ type RenderParagraphOptions = {
   /** Inline image runs already rendered for this paragraph block */
   renderedInlineImageKeys?: Set<string>;
 };
+declare function getRenderableTextColor(run: TextRun | TabRun): string | undefined;
+/**
+ * Get leader character for tab
+ */
+declare function getLeaderChar(leader: string): string | null;
 /**
  * Slice runs for a specific line
  *
@@ -47,6 +52,20 @@ declare function sliceRunsForLine(block: ParagraphBlock, line: MeasuredLine): Ru
  * runs without CJK pass through unchanged (the common path).
  */
 declare function splitTextRunsByEastAsia(runs: Run[]): Run[];
+type CollapsibleLineEdgeSpacesResult = {
+  runs: Run[];
+  collapsedLeadingRuns: Set<TextRun>;
+  collapsedTrailingRuns: Set<TextRun>;
+};
+/**
+ * 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.
+ */
+declare const splitCollapsibleLineEdgeSpaces: (sourceRuns: Run[], collapseLeading: boolean) => CollapsibleLineEdgeSpacesResult;
+declare const startsAfterSoftWrap: (block: ParagraphBlock, line: MeasuredLine) => boolean;
 /**
  * Options for rendering a line with justify support
  */
@@ -115,4 +134,4 @@ declare function renderLine(block: ParagraphBlock, line: MeasuredLine, alignment
  */
 declare function renderParagraphFragment(fragment: ParagraphFragment, block: ParagraphBlock, measure: ParagraphMeasure, context: RenderContext, options?: RenderParagraphOptions): HTMLElement;
 //#endregion
-export { PARAGRAPH_CLASS_NAMES, RenderParagraphOptions, renderLine, renderParagraphFragment, sliceRunsForLine, splitTextRunsByEastAsia };
+export { PARAGRAPH_CLASS_NAMES, RenderParagraphOptions, getLeaderChar, getRenderableTextColor, renderLine, renderParagraphFragment, sliceRunsForLine, splitCollapsibleLineEdgeSpaces, splitTextRunsByEastAsia, startsAfterSoftWrap };

package/dist/layout-painter/renderParagraph.js

@@ -1671,4 +1671,4 @@ function renderListMarker({ marker, inlineWidth, visualOffset, doc, formatting,
 	return span;
 }
 //#endregion
-export { PARAGRAPH_CLASS_NAMES, renderLine, renderParagraphFragment, sliceRunsForLine, splitTextRunsByEastAsia };
+export { PARAGRAPH_CLASS_NAMES, getLeaderChar, getRenderableTextColor, renderLine, renderParagraphFragment, sliceRunsForLine, splitCollapsibleLineEdgeSpaces, splitTextRunsByEastAsia, startsAfterSoftWrap };

package/dist/layout-painter/renderTable.js

@@ -38,6 +38,30 @@ const TABLE_CLASS_NAMES = {
 };
 const CELL_DIAGONAL_BORDER_CLASS = "layout-table-cell-diagonal-border";
 const CELL_BOTTOM_BORDER_CLASS = "layout-table-cell-bottom-border";
+/**
+* Quarter turn a `w:textDirection` puts on cell content (§17.18.93, plus the
+* short spellings Word also writes).
+*
+* `btLr` runs bottom-to-top up the left edge, so it turns counter-clockwise;
+* every top-to-bottom direction runs down the right edge and turns clockwise.
+* The horizontal directions are the identity — `rl` is bidi, not rotation.
+* Only `btLr` was handled, so a rotated header cell (the common `tbRl` shape)
+* painted horizontally and overflowed its column.
+*
+* Total over the union on purpose: a new direction has to state its turn here
+* rather than silently falling back to horizontal.
+*/
+const CELL_TEXT_ROTATION_DEGREES = {
+	lr: 0,
+	lrV: 0,
+	rl: 0,
+	rlV: 0,
+	tb: 90,
+	tbV: 90,
+	tbRl: 90,
+	tbRlV: 90,
+	btLr: -90
+};
 function renderCellContent({ cell, cellMeasure, context, doc, contentWidthOverride, pageContentPosition }) {
 	const contentEl = doc.createElement("div");
 	contentEl.className = TABLE_CLASS_NAMES.cellContent;
@@ -122,11 +146,19 @@ function renderCellContent({ cell, cellMeasure, context, doc, contentWidthOverri
 				...paragraphBlock.pmStart !== void 0 ? { pmStart: paragraphBlock.pmStart } : {},
 				...paragraphBlock.pmEnd !== void 0 ? { pmEnd: paragraphBlock.pmEnd } : {}
 			};
+			const previousBlock = cell.blocks[i - 1];
+			const nextBlock = cell.blocks[i + 1];
+			const prevBorders = previousBlock?.kind === "paragraph" ? previousBlock.attrs?.borders : void 0;
+			const nextBorders = nextBlock?.kind === "paragraph" ? nextBlock.attrs?.borders : void 0;
 			const cellContext = {
 				...context,
 				insideTableCell: true
 			};
-			const fragEl = renderParagraphFragment(syntheticFragment, paragraphBlock, paragraphMeasure, cellContext, { document: doc });
+			const fragEl = renderParagraphFragment(syntheticFragment, paragraphBlock, paragraphMeasure, cellContext, {
+				document: doc,
+				...prevBorders !== void 0 ? { prevBorders } : {},
+				...nextBorders !== void 0 ? { nextBorders } : {}
+			});
 			fragEl.style.position = "relative";
 			fragEl.style.boxSizing = "border-box";
 			fragEl.style.height = `${placement.leadingSpacing + placement.contentHeight}px`;
@@ -382,7 +414,8 @@ function renderTableCell({ cell, cellMeasure, x, width, rowHeight, borderFlags,
 			default: break;
 		}
 	}
-	const contentWidthOverride = cell.textDirection === "btLr" ? Math.max(1, rowHeight - padTop - padBottom) : void 0;
+	const cellTextRotation = cell.textDirection ? CELL_TEXT_ROTATION_DEGREES[cell.textDirection] : 0;
+	const contentWidthOverride = cellTextRotation === 0 ? void 0 : Math.max(1, rowHeight - padTop - padBottom);
 	const renderedContent = renderCellContent({
 		cell,
 		cellMeasure,
@@ -395,11 +428,11 @@ function renderTableCell({ cell, cellMeasure, x, width, rowHeight, borderFlags,
 			y: pageContentPosition.y + padTop
 		} } : {}
 	});
-	if (cell.textDirection === "btLr") {
+	if (cellTextRotation !== 0) {
 		renderedContent.content.style.position = "absolute";
 		renderedContent.content.style.left = "50%";
 		renderedContent.content.style.top = "50%";
-		renderedContent.content.style.transform = "translate(-50%, -50%) rotate(-90deg)";
+		renderedContent.content.style.transform = `translate(-50%, -50%) rotate(${cellTextRotation}deg)`;
 	}
 	if (renderedContent.floatingLayers.length > 0) {
 		renderedContent.content.style.height = "100%";

package/dist/managers/editorShortcuts.d.ts

@@ -30,6 +30,38 @@ type ClassifyEditorKeydownOptions = {
  *  - Delete/Backspace (no modifiers, focus not in an input) → delete selected table
  */
 declare function classifyEditorKeydown(e: KeyboardEvent, { isMac, isInputLike }: ClassifyEditorKeydownOptions): EditorKeydownIntent;
+/**
+ * Which key presses the editor's page-level shortcuts answer.
+ *  - `"document"`: every press on the page.
+ *  - `"editor"`: only a press whose target is inside the editor.
+ *  - `"none"`: no page-level listener; the host dispatches shortcuts itself.
+ */
+type KeyboardShortcutScope = "document" | "editor" | "none";
+/**
+ * The containment surface a scope root has to offer. Structural rather than
+ * `Element` so the predicate carries no DOM dependency and answers the same
+ * under a server render and a DOM-less test runtime.
+ */
+type ShortcutScopeRoot = {
+  contains(other: unknown): boolean;
+};
+type IsKeydownInShortcutScopeOptions = {
+  scope: KeyboardShortcutScope;
+  /**
+   * Elements a press must land inside under `"editor"`: the editor root plus
+   * any surface it owns outside that subtree (a portaled dialog). A nullish
+   * entry — an unmounted ref — never matches.
+   */
+  roots: readonly (ShortcutScopeRoot | null | undefined)[];
+};
+/**
+ * Whether a keydown is one the editor answers under `scope`. The adapters own
+ * the listener; this decides, from the event target alone, whether the press
+ * belongs to this editor or to whatever else the host has on the page.
+ */
+declare function isKeydownInShortcutScope(event: {
+  target: unknown;
+}, { scope, roots }: IsKeydownInShortcutScopeOptions): boolean;
 /**
  * If the selection is a ProseMirror `CellSelection` covering every cell of its
  * table, delete the table and return `true`. Returns `false` for any other
@@ -37,4 +69,4 @@ declare function classifyEditorKeydown(e: KeyboardEvent, { isMac, isInputLike }:
  */
 declare function deleteSelectedTable(state: EditorState, dispatch: (tr: Transaction) => void): boolean;
 //#endregion
-export { ClassifyEditorKeydownOptions, EditorKeydownIntent, classifyEditorKeydown, deleteSelectedTable, isFocusInInputLike, isMacPlatform };
+export { ClassifyEditorKeydownOptions, EditorKeydownIntent, IsKeydownInShortcutScopeOptions, KeyboardShortcutScope, ShortcutScopeRoot, classifyEditorKeydown, deleteSelectedTable, isFocusInInputLike, isKeydownInShortcutScope, isMacPlatform };