@stll/folio-core 0.28.0 → 0.29.0

package/dist/layout-engine/index.js

@@ -1,4 +1,5 @@
 import { emuToPixels } from "../utils/units.js";
+import { reflowFootnoteColumns } from "./footnoteColumnReflow.js";
 import { resolveSectionHeaderFooterRefs } from "./headerFooterRefs.js";
 import { calculateChainHeight, computeKeepNextChains, getMidChainIndices, hasKeepLines, hasPageBreakBefore } from "./keep-together.js";
 import { measuredLineAdvance } from "./lineFlow.js";
@@ -140,13 +141,23 @@ function applyContextualSpacing(blocks) {
 /**
 * Layout a document: convert blocks + measures into pages with positioned fragments.
 *
-* Algorithm:
-* 1. Walk blocks in order with their corresponding measures
-* 2. For each block, create appropriate fragment(s)
-* 3. Use paginator to manage page/column state
-* 4. Handle page breaks, section breaks, and keepNext chains
+* A reference discovered after the first column has already been placed can shrink the
+* shared body band below earlier-column fragments. Retry those documents with the observed
+* reservations as page floors so every column participates in the same footnote geometry.
 */
 function layoutDocument(blocks, measures, options) {
+	const layout = layoutDocumentPass(blocks, measures, options);
+	if (!options.footnoteHeightById) return layout;
+	return reflowFootnoteColumns({
+		initialLayout: layout,
+		...options.footnoteReservedHeights ? { initialReserveFloors: options.footnoteReservedHeights } : {},
+		runLayout: (reserveFloors) => layoutDocumentPass(blocks, measures, {
+			...options,
+			footnoteReservedHeights: reserveFloors
+		})
+	});
+}
+function layoutDocumentPass(blocks, measures, options) {
 	if (blocks.length !== measures.length) panic(`layoutDocument: expected one measure per block (blocks=${blocks.length}, measures=${measures.length})`);
 	const pageSize = options.pageSize;
 	const baseMargins = {
@@ -333,6 +344,10 @@ function getLineFootnoteRefs(block, fromRun, toRun, fnHeights) {
 		height
 	};
 }
+function projectedFootnoteReserveGrowth(state, additionalDemandHeight) {
+	const projectedDemand = state.footnoteDemandHeight + additionalDemandHeight;
+	return Math.max(state.footnoteHeightFloor, projectedDemand) - state.footnoteHeight;
+}
 function layoutParagraph({ block, measure, paginator, contentWidth, footnoteHeightById, suppressSpaceBefore }) {
 	const lines = measure.lines;
 	if (lines.length === 0) {
@@ -370,7 +385,7 @@ function layoutParagraph({ block, measure, paginator, contentWidth, footnoteHeig
 		if (currentLineIndex === 0 && state.trailingSpacing > 0 && state.cursorY !== state.topMargin) {
 			const firstLine = lines[0];
 			const firstLineRefs = getLineFootnoteRefs(block, firstLine.fromRun, firstLine.toRun, footnoteHeightById);
-			const firstLineHeight = measuredLineAdvance(firstLine) + firstLineRefs.height;
+			const firstLineHeight = measuredLineAdvance(firstLine) + projectedFootnoteReserveGrowth(state, firstLineRefs.height);
 			const collapsedLead = collapseParagraphSpacing({
 				before: spaceBefore,
 				after: state.trailingSpacing
@@ -399,7 +414,8 @@ function layoutParagraph({ block, measure, paginator, contentWidth, footnoteHeig
 			}
 			const lineRefs = getLineFootnoteRefs(block, line.fromRun, line.toRun, footnoteHeightById);
 			const totalWithLine = linesHeight + lineAdvance;
-			if (totalWithLine + firstFragmentSpaceBefore + linesFnHeight + lineRefs.height <= availableHeight || fittingLines === 0) {
+			const footnoteGrowth = projectedFootnoteReserveGrowth(state, linesFnHeight + lineRefs.height);
+			if (totalWithLine + firstFragmentSpaceBefore + footnoteGrowth <= availableHeight || fittingLines === 0) {
 				linesHeight = totalWithLine;
 				linesFnHeight += lineRefs.height;
 				for (const id of lineRefs.ids) linesFnIds.push(id);
@@ -449,8 +465,10 @@ function layoutParagraph({ block, measure, paginator, contentWidth, footnoteHeig
 			...block.sdtGroups ? { sdtGroups: block.sdtGroups } : {}
 		};
 		if (linesFnHeight > 0) {
-			paginator.ensureFits(effectiveSpaceBefore + linesHeight + linesFnHeight);
-			if (paginator.getCurrentState().footnoteHeight === 0) paginator.ensureFits(effectiveSpaceBefore + linesHeight + linesFnHeight + 12);
+			const stateBefore = paginator.getCurrentState();
+			paginator.ensureFits(effectiveSpaceBefore + linesHeight + projectedFootnoteReserveGrowth(stateBefore, linesFnHeight));
+			const stateAfter = paginator.getCurrentState();
+			if (stateAfter.footnoteDemandHeight === 0) paginator.ensureFits(effectiveSpaceBefore + linesHeight + projectedFootnoteReserveGrowth(stateAfter, linesFnHeight + 12));
 		}
 		fragment.y = paginator.addFragment(fragment, linesHeight, effectiveSpaceBefore, effectiveSpaceAfter).y;
 		if (linesFnHeight > 0) paginator.addFootnoteHeight(linesFnHeight, linesFnIds);
@@ -650,8 +668,9 @@ function layoutTable(block, measure, paginator, footnoteHeightById) {
 				fragmentFootnoteIds.push(id);
 				rowFootnoteHeight += footnoteHeightById?.get(id) ?? 0;
 			}
-			const separatorHeight = pageFootnoteIds.size === 0 && fragmentFootnoteHeight + rowFootnoteHeight > 0 ? 12 : 0;
-			if (rowsHeight + rowHeight + normalHeaderOverhead + fragmentFootnoteHeight + rowFootnoteHeight + separatorHeight <= availableHeight) {
+			const candidateFootnoteHeight = fragmentFootnoteHeight + rowFootnoteHeight;
+			const footnoteGrowth = projectedFootnoteReserveGrowth(state, candidateFootnoteHeight + (state.footnoteDemandHeight === 0 && candidateFootnoteHeight > 0 ? 12 : 0));
+			if (rowsHeight + rowHeight + normalHeaderOverhead + footnoteGrowth <= availableHeight) {
 				rowsHeight += rowHeight;
 				fragmentFootnoteHeight += rowFootnoteHeight;
 				fittingRows++;
@@ -780,7 +799,7 @@ function layoutFloatingTable(block, measure, paginator, contentWidth) {
 		isFloating: true,
 		...block.sdtGroups ? { sdtGroups: block.sdtGroups } : {}
 	};
-	state.page.fragments.push(fragment);
+	paginator.addUnflowedFragment(fragment);
 }
 /**
 * Layout an image block onto pages.
@@ -825,7 +844,7 @@ function layoutAnchoredImage(block, measure, paginator) {
 		isAnchored: true,
 		zIndex: anchor.behindDoc ? -1 : 1
 	};
-	state.page.fragments.push(fragment);
+	paginator.addUnflowedFragment(fragment);
 }
 /**
 * Layout a text box block onto pages.
@@ -853,10 +872,11 @@ function layoutTextBox(block, measure, { paginator, sectionMarginTop, sectionPag
 			y: state.topMargin + bandTop,
 			width: measure.width,
 			height: measure.height,
+			isPositioned: true,
 			...block.pmStart !== void 0 ? { pmStart: block.pmStart } : {},
 			...block.pmEnd !== void 0 ? { pmEnd: block.pmEnd } : {}
 		};
-		state.page.fragments.push(fragment);
+		paginator.addUnflowedFragment(fragment);
 		return;
 	}
 	if (block.position !== void 0) {
@@ -882,10 +902,11 @@ function layoutTextBox(block, measure, { paginator, sectionMarginTop, sectionPag
 			y,
 			width: measure.width,
 			height: measure.height,
+			isPositioned: true,
 			...block.pmStart !== void 0 ? { pmStart: block.pmStart } : {},
 			...block.pmEnd !== void 0 ? { pmEnd: block.pmEnd } : {}
 		};
-		state.page.fragments.push(fragment);
+		paginator.addUnflowedFragment(fragment);
 		return;
 	}
 	const state = paginator.ensureFits(measure.height);

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

@@ -54,7 +54,7 @@ declare function setFontCacheSize(size: number): void;
  * Get current font metrics cache size
  */
 declare function getFontCacheSize(): number;
-/** Serialize the complete paragraph measurement contract into a cache key. */
+/** Serialize the complete, semantically normalized paragraph measurement contract into a cache key. */
 declare function hashParagraphBlock(block: ParagraphBlock): string;
 /**
  * Get cached paragraph measurement or return undefined

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

@@ -188,11 +188,20 @@ const runMeasureCacheInput = (run) => {
 		default: return run;
 	}
 };
-/** Serialize the complete paragraph measurement contract into a cache key. */
+const paragraphAttrsMeasureCacheInput = (attrs) => {
+	if (attrs === void 0) return void 0;
+	const { snapToGrid, ...measurementAttrs } = attrs;
+	if (measurementAttrs.documentGridLinePitch === void 0) return measurementAttrs;
+	return {
+		...measurementAttrs,
+		snapToGrid: snapToGrid !== false
+	};
+};
+/** Serialize the complete, semantically normalized paragraph measurement contract into a cache key. */
 function hashParagraphBlock(block) {
 	return JSON.stringify({
 		lineBreakProviderGeneration: getLineBreakProviderGeneration(),
-		attrs: block.attrs,
+		attrs: paragraphAttrsMeasureCacheInput(block.attrs),
 		runs: block.runs.map(runMeasureCacheInput)
 	});
 }

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

@@ -27,7 +27,9 @@ declare function resolveListMarkerFont(block: ParagraphBlock): {
  *  - hanging indent — body wraps at `indentLeft`, marker sits at
  *    `indentLeft - hanging`. Width is `hanging` so the marker fills the slot.
  *  - `w:suff` (§17.9.25): `nothing` → natural width, `space` → natural +
- *    one space glyph, `tab` (default) → grow to the next tab stop.
+ *    one space glyph, `tab` (default) → grow to the next tab stop. A hanging
+ *    indent remains the minimum footprint so body text cannot enter the
+ *    marker slot.
  *  - `w:tabs` on the paragraph: non-`clear`/non-`bar` stops past the marker.
  *    `bar` (§17.3.1.37) is a vertical line and doesn't advance the cursor.
  *  - default tab grid: stops at multiples of `DEFAULT_TAB_STOP_TWIPS`,

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

@@ -50,7 +50,9 @@ function resolveListMarkerFont(block) {
 *  - hanging indent — body wraps at `indentLeft`, marker sits at
 *    `indentLeft - hanging`. Width is `hanging` so the marker fills the slot.
 *  - `w:suff` (§17.9.25): `nothing` → natural width, `space` → natural +
-*    one space glyph, `tab` (default) → grow to the next tab stop.
+*    one space glyph, `tab` (default) → grow to the next tab stop. A hanging
+*    indent remains the minimum footprint so body text cannot enter the
+*    marker slot.
 *  - `w:tabs` on the paragraph: non-`clear`/non-`bar` stops past the marker.
 *    `bar` (§17.3.1.37) is a vertical line and doesn't advance the cursor.
 *  - default tab grid: stops at multiples of `DEFAULT_TAB_STOP_TWIPS`,
@@ -67,12 +69,12 @@ function getListMarkerInlineWidth(block) {
 	const naturalWidth = measureTextWidth(attrs.listMarker, style);
 	const markerEndOffset = getMarkerEndOffset(naturalWidth, attrs.listMarkerAlignment);
 	const suffix = attrs.listMarkerSuffix ?? "tab";
-	if (suffix === "nothing") return markerEndOffset;
-	if (suffix === "space") return markerEndOffset + measureTextWidth(" ", style);
+	const hanging = attrs.indent?.hanging ?? 0;
+	if (suffix === "nothing") return Math.max(hanging, markerEndOffset);
+	if (suffix === "space") return Math.max(hanging, markerEndOffset + measureTextWidth(" ", style));
 	const indent = attrs.indent;
 	const indentLeft = indent?.left ?? 0;
 	const firstLine = indent?.firstLine ?? 0;
-	const hanging = indent?.hanging ?? 0;
 	const markerStartPx = hanging > 0 ? indentLeft - hanging : indentLeft + firstLine;
 	const minBodyStart = markerStartPx + markerEndOffset;
 	const customTabs = (attrs.tabs ?? []).filter((t) => t.val !== "clear" && t.val !== "bar").map((t) => t.pos * TWIPS_TO_PX);

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

@@ -22,6 +22,10 @@ type PageState = {
   rawContentBottom: number;
   /** Total height reserved for footnotes on this page (grows as refs are placed). */
   footnoteHeight: number;
+  /** Static reservation supplied by a layout retry. */
+  footnoteHeightFloor: number;
+  /** Footnote demand discovered while placing reference-bearing content. */
+  footnoteDemandHeight: number;
   /** Accumulated trailing spacing (space after previous block). */
   trailingSpacing: number;
 };
@@ -98,6 +102,8 @@ declare function createPaginator(options: PaginatorOptions): {
     x: number;
     y: number;
   };
+  /** Add an already-positioned fragment without advancing normal flow. */
+  addUnflowedFragment: (fragment: Fragment) => PageState;
   /** Reserve additional footnote area on the current page. */
   addFootnoteHeight: (additionalHeight: number, footnoteIds?: number[]) => void;
   /** Force a page break. */

package/dist/layout-engine/paginator.js

@@ -99,8 +99,8 @@ function createPaginator(options) {
 		const pageMargins = getPageMargins(pageNumber, logicalNumber);
 		const topMargin = pageMargins.top;
 		const contentBottom = pageSize.h - pageMargins.bottom;
-		const footnoteHeight = options.footnoteReservedHeights?.get(pageNumber) ?? 0;
-		const pageContentBottom = contentBottom - footnoteHeight;
+		const footnoteHeightFloor = options.footnoteReservedHeights?.get(pageNumber) ?? 0;
+		const pageContentBottom = contentBottom - footnoteHeightFloor;
 		const page = {
 			number: pageNumber,
 			logicalNumber,
@@ -108,7 +108,7 @@ function createPaginator(options) {
 			fragments: [],
 			margins: pageMargins,
 			size: { ...pageSize },
-			...footnoteHeight > 0 ? { footnoteReservedHeight: footnoteHeight } : {},
+			...footnoteHeightFloor > 0 ? { footnoteReservedHeight: footnoteHeightFloor } : {},
 			...columns.count > 1 ? { columns: { ...columns } } : {}
 		};
 		applySectionMetadata(page);
@@ -119,7 +119,9 @@ function createPaginator(options) {
 			topMargin,
 			contentBottom: pageContentBottom,
 			rawContentBottom: contentBottom,
-			footnoteHeight,
+			footnoteHeight: footnoteHeightFloor,
+			footnoteHeightFloor,
+			footnoteDemandHeight: 0,
 			trailingSpacing: 0
 		};
 		pages.push(page);
@@ -197,7 +199,7 @@ function createPaginator(options) {
 		const y = state.cursorY + actualSpaceBefore;
 		fragment.x = x;
 		fragment.y = y;
-		state.page.fragments.push(fragment);
+		commitFragment(state, fragment);
 		state.cursorY = y + height;
 		state.trailingSpacing = spaceAfter;
 		return {
@@ -206,6 +208,18 @@ function createPaginator(options) {
 			y
 		};
 	}
+	function commitFragment(state, fragment) {
+		if (sectionStartPending && state.page.sectionIndex !== currentSectionIndex) {
+			if (currentPageNumbering.type === "restart") nextLogicalPageNumber = currentPageNumbering.start + 1;
+			sectionStartPending = false;
+		}
+		state.page.fragments.push(fragment);
+	}
+	function addUnflowedFragment(fragment) {
+		const state = getCurrentState();
+		commitFragment(state, fragment);
+		return state;
+	}
 	/**
 	* Reserve additional footnote area on the current page.
 	*
@@ -229,8 +243,9 @@ function createPaginator(options) {
 	function addFootnoteHeight(additionalHeight, footnoteIds) {
 		if (!Number.isFinite(additionalHeight) || additionalHeight <= 0) return;
 		const state = getCurrentState();
-		const separatorOverhead = state.footnoteHeight === 0 ? 12 : 0;
-		state.footnoteHeight += additionalHeight + separatorOverhead;
+		const separatorOverhead = state.footnoteDemandHeight === 0 ? 12 : 0;
+		state.footnoteDemandHeight += additionalHeight + separatorOverhead;
+		state.footnoteHeight = Math.max(state.footnoteHeightFloor, state.footnoteDemandHeight);
 		state.contentBottom = state.rawContentBottom - state.footnoteHeight;
 		state.page.footnoteReservedHeight = state.footnoteHeight;
 		if (footnoteIds && footnoteIds.length > 0) {
@@ -261,10 +276,10 @@ function createPaginator(options) {
 		const pageMargins = getPageMargins(current.page.number, current.page.logicalNumber);
 		const topMargin = pageMargins.top;
 		const rawContentBottom = pageSize.h - pageMargins.bottom;
-		const footnoteHeight = options.footnoteReservedHeights?.get(current.page.number) ?? 0;
+		const footnoteHeightFloor = options.footnoteReservedHeights?.get(current.page.number) ?? 0;
 		current.page.size = { ...pageSize };
 		current.page.margins = pageMargins;
-		if (footnoteHeight > 0) current.page.footnoteReservedHeight = footnoteHeight;
+		if (footnoteHeightFloor > 0) current.page.footnoteReservedHeight = footnoteHeightFloor;
 		else delete current.page.footnoteReservedHeight;
 		if (columns.count > 1) current.page.columns = { ...columns };
 		else delete current.page.columns;
@@ -272,8 +287,10 @@ function createPaginator(options) {
 		current.cursorY = topMargin;
 		current.columnIndex = 0;
 		current.rawContentBottom = rawContentBottom;
-		current.footnoteHeight = footnoteHeight;
-		current.contentBottom = rawContentBottom - footnoteHeight;
+		current.footnoteHeight = footnoteHeightFloor;
+		current.footnoteHeightFloor = footnoteHeightFloor;
+		current.footnoteDemandHeight = 0;
+		current.contentBottom = rawContentBottom - footnoteHeightFloor;
 		current.trailingSpacing = 0;
 		columnRegionTop = topMargin;
 		return true;
@@ -370,6 +387,8 @@ function createPaginator(options) {
 		ensureFits,
 		/** Add a fragment to current page. */
 		addFragment,
+		/** Add an already-positioned fragment without advancing normal flow. */
+		addUnflowedFragment,
 		/** Reserve additional footnote area on the current page. */
 		addFootnoteHeight,
 		/** Force a page break. */

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

@@ -1059,6 +1059,8 @@ type TextBoxFragment = FragmentBase & {
   kind: "textBox";
   /** Height of the text box. */
   height: number;
+  /** True if this text box is positioned outside normal body flow. */
+  isPositioned?: true;
 };
 /**
  * Union of all fragment types.
@@ -1226,18 +1228,21 @@ type LayoutOptions = {
   evenAndOddHeaders?: boolean;
   /** Swap left/right margins on even physical pages. */
   mirrorMargins?: boolean;
-  /** Per-page footnote reserved heights (pageNumber → height in pixels). */
+  /**
+   * Per-page footnote reserved heights (pageNumber → height in pixels).
+   * When `footnoteHeightById` is also supplied, a value is a retry floor only
+   * while that page has assigned footnote IDs; without the dynamic height map,
+   * the value remains a static reservation.
+   */
   footnoteReservedHeights?: Map<number, number>;
   /**
    * Footnote content heights keyed by internal footnote id (the OOXML
    * `<w:footnoteReference w:id>`). When provided, the layout engine
    * tracks footnote demand per body line: each line carrying a fn ref
    * grows its page's reservation by that fn's height before the next
-   * line is fitted. This single-pass approach avoids the static-
-   * reservation + iterative-convergence loop that produced oscillation
-   * (and either body-overflow into the footer or large empty gaps
-   * above the fn area) on documents with multiple long footnotes per
-   * page.
+   * line is fitted. Multi-column pages may retry with the observed
+   * reservation as a shared floor when a later column invalidates
+   * earlier-column placement.
    */
   footnoteHeightById?: Map<number, number>;
   /** Header/footer references for each document section, by section index. */

package/dist/markdown/renderParagraph.js

@@ -1,4 +1,4 @@
-import { resolveListTemplate } from "../layout-bridge/convert/toFlowBlocks.js";
+import { resolveListTemplate } from "../prosemirror/listMarker.js";
 import { isHeadingStyle, parseHeadingLevel } from "./headings.js";
 import { renderParagraphInline } from "./renderRuns.js";
 //#region src/markdown/renderParagraph.ts
@@ -58,7 +58,12 @@ function resolveTemplateMarker(ctx, list) {
 	for (let i = level + 1; i < counters.length; i += 1) counters[i] = 0;
 	ctx.listCounters.set(list.numId, counters);
 	const levelFormats = list.levelNumFmts ?? (list.numFmt ? [list.numFmt] : void 0);
-	return resolveListTemplate(list.marker, counters, levelFormats, list.isLegal).trim();
+	return resolveListTemplate({
+		template: list.marker,
+		counters,
+		levelFormats,
+		forceDecimal: list.isLegal
+	}).trim();
 }
 //#endregion
 export { renderParagraph };

package/dist/prosemirror/attrs/index.js

@@ -77,11 +77,10 @@ const TEXT_BOX_TRACKED_CHANGE_TYPES = [
 	"moveTo"
 ];
 const HARD_BREAK_TYPES = ["column"];
-const RUN_FORMATTING_OVERRIDE_FALSE_KEYS = [
+const RUN_FORMATTING_OVERRIDE_BOOLEAN_KEYS = [
 	"bold",
 	"italic",
 	"strike",
-	"doubleStrike",
 	"allCaps",
 	"smallCaps",
 	"hidden",
@@ -90,6 +89,7 @@ const RUN_FORMATTING_OVERRIDE_FALSE_KEYS = [
 	"shadow",
 	"outline"
 ];
+const RUN_FORMATTING_OVERRIDE_FALSE_KEYS = ["doubleStrike", "rtl"];
 const SECTION_ORIENTATIONS = ["portrait", "landscape"];
 const SECTION_START_TYPES = [
 	"continuous",
@@ -371,10 +371,11 @@ const expectImageAttrs = (node) => expectCachedNodeAttrs(node, imageAttrsCache,
 const readFieldAttrs = (node) => {
 	const attrs = attrsRecord(node.attrs);
 	const issues = [];
-	expectNodeType(node, "field", issues);
+	expectNodeTypeOneOf(node, ["field", "structuredField"], issues);
 	requiredOneOf(attrs, "fieldType", "field.attrs.fieldType", issues, FIELD_TYPE_VALUES);
 	requiredString(attrs, "instruction", "field.attrs.instruction", issues);
 	requiredString(attrs, "displayText", "field.attrs.displayText", issues);
+	optionalString(attrs, "_numberedRefBaseline", "field.attrs._numberedRefBaseline", issues);
 	requiredOneOf(attrs, "fieldKind", "field.attrs.fieldKind", issues, FIELD_KINDS);
 	optionalBoolean(attrs, "fldLock", "field.attrs.fldLock", issues);
 	optionalBoolean(attrs, "dirty", "field.attrs.dirty", issues);
@@ -659,6 +660,7 @@ const readRunFormattingOverrideMarkAttrs = (mark) => {
 	const attrs = attrsRecord(mark.attrs);
 	const issues = [];
 	expectMarkType(mark, "runFormattingOverride", issues);
+	for (const key of RUN_FORMATTING_OVERRIDE_BOOLEAN_KEYS) optionalBoolean(attrs, key, `runFormattingOverride.attrs.${key}`, issues);
 	for (const key of RUN_FORMATTING_OVERRIDE_FALSE_KEYS) optionalFalse(attrs, key, `runFormattingOverride.attrs.${key}`, issues);
 	optionalBoolean(attrs, "boldCs", "runFormattingOverride.attrs.boldCs", issues);
 	optionalBoolean(attrs, "italicCs", "runFormattingOverride.attrs.italicCs", issues);

package/dist/prosemirror/bookmarkBoundaryAttrs.d.ts

@@ -0,0 +1,8 @@
+import { BookmarkBoundaryAttrs } from "./schema/nodes.js";
+import { ReadProseMirrorAttrsResult } from "./attrs/index.js";
+import { Node } from "prosemirror-model";
+//#region src/prosemirror/bookmarkBoundaryAttrs.d.ts
+declare const readBookmarkBoundaryAttrs: (node: Node) => ReadProseMirrorAttrsResult<BookmarkBoundaryAttrs>;
+declare const expectBookmarkBoundaryAttrs: (node: Node) => BookmarkBoundaryAttrs;
+//#endregion
+export { expectBookmarkBoundaryAttrs, readBookmarkBoundaryAttrs };

package/dist/prosemirror/bookmarkBoundaryAttrs.js

@@ -0,0 +1,66 @@
+import { panic } from "better-result";
+//#region src/prosemirror/bookmarkBoundaryAttrs.ts
+const attrsCache = /* @__PURE__ */ new WeakMap();
+const readBookmarkBoundaryAttrs = (node) => {
+	const issues = [];
+	if (node.type.name !== "bookmarkBoundary") issues.push({
+		path: "bookmarkBoundary.type.name",
+		message: `Expected bookmarkBoundary, got ${node.type.name}.`
+	});
+	const type = node.attrs["type"];
+	if (type !== "start" && type !== "end") issues.push({
+		path: "bookmarkBoundary.attrs.type",
+		message: "Expected \"start\" or \"end\"."
+	});
+	const id = node.attrs["id"];
+	if (typeof id !== "number" || !Number.isInteger(id) || id < 0) issues.push({
+		path: "bookmarkBoundary.attrs.id",
+		message: "Expected a non-negative integer."
+	});
+	const name = node.attrs["name"];
+	if (type === "start" && (typeof name !== "string" || name.length === 0)) issues.push({
+		path: "bookmarkBoundary.attrs.name",
+		message: "Expected a non-empty string for a bookmark start."
+	});
+	const colFirst = node.attrs["colFirst"];
+	if (colFirst !== void 0 && colFirst !== null && (typeof colFirst !== "number" || !Number.isInteger(colFirst) || colFirst < 0)) issues.push({
+		path: "bookmarkBoundary.attrs.colFirst",
+		message: "Expected a non-negative integer."
+	});
+	const colLast = node.attrs["colLast"];
+	if (colLast !== void 0 && colLast !== null && (typeof colLast !== "number" || !Number.isInteger(colLast) || colLast < 0)) issues.push({
+		path: "bookmarkBoundary.attrs.colLast",
+		message: "Expected a non-negative integer."
+	});
+	if (issues.length > 0 || typeof id !== "number") return {
+		ok: false,
+		issues
+	};
+	if (type === "start" && typeof name === "string") return {
+		ok: true,
+		value: {
+			type,
+			id,
+			name,
+			...typeof colFirst === "number" ? { colFirst } : {},
+			...typeof colLast === "number" ? { colLast } : {}
+		}
+	};
+	return {
+		ok: true,
+		value: {
+			type: "end",
+			id
+		}
+	};
+};
+const expectBookmarkBoundaryAttrs = (node) => {
+	const cached = attrsCache.get(node);
+	if (cached) return cached;
+	const result = readBookmarkBoundaryAttrs(node);
+	if (!result.ok) panic(`Invalid ProseMirror bookmark boundary attrs:\n${result.issues.map((issue) => `${issue.path}: ${issue.message}`).join("\n")}`);
+	attrsCache.set(node, result.value);
+	return result.value;
+};
+//#endregion
+export { expectBookmarkBoundaryAttrs, readBookmarkBoundaryAttrs };

package/dist/prosemirror/commands/formatPainter.js

@@ -1,3 +1,4 @@
+import { expectCharacterStyleMarkAttrs, expectParagraphAttrs } from "../attrs/index.js";
 //#region src/prosemirror/commands/formatPainter.ts
 /**
 * Character-formatting marks the painter copies. Structural marks — comments,
@@ -64,6 +65,40 @@ function sanitizeOverrideMark(mark) {
 	if (Object.keys(kept).length === 0) return null;
 	return mark.type.create(kept);
 }
+const PAINTABLE_STYLE_TOGGLE_MARKS = [
+	["allCaps", "allCaps"],
+	["bold", "bold"],
+	["emboss", "emboss"],
+	["imprint", "imprint"],
+	["italic", "italic"],
+	["outline", "textOutline"],
+	["shadow", "textShadow"],
+	["smallCaps", "smallCaps"],
+	["strike", "strike"]
+];
+const PAINTABLE_COMPLEX_SCRIPT_TOGGLES = ["boldCs", "italicCs"];
+function materializeStyleToggleNegatives({ inheritedFormatting, marks }) {
+	const characterStyle = marks.find((mark) => mark.type.name === "characterStyle");
+	if (!characterStyle) return [...marks];
+	const styleRPr = expectCharacterStyleMarkAttrs(characterStyle)._styleRPr;
+	if (!styleRPr) return [...marks];
+	const negativeAttrs = {};
+	for (const [key, markName] of PAINTABLE_STYLE_TOGGLE_MARKS) if (styleRPr[key] === true && !marks.some((mark) => mark.type.name === markName)) negativeAttrs[key] = false;
+	for (const key of PAINTABLE_COMPLEX_SCRIPT_TOGGLES) {
+		if (styleRPr[key] === void 0) continue;
+		const inheritedValue = inheritedFormatting?.[key] ?? false;
+		if (!(styleRPr[key] === true ? !inheritedValue : false)) negativeAttrs[key] = false;
+	}
+	if (Object.keys(negativeAttrs).length === 0) return [...marks];
+	const existingOverride = marks.find((mark) => mark.type.name === "runFormattingOverride");
+	const overrideType = existingOverride?.type ?? characterStyle.type.schema.marks["runFormattingOverride"];
+	if (!overrideType) return [...marks];
+	const override = overrideType.create({
+		...negativeAttrs,
+		...existingOverride?.attrs
+	});
+	return existingOverride ? marks.map((mark) => mark === existingOverride ? override : mark) : [...marks, override];
+}
 /**
 * Marks of the first text node inside [from, to). A word processor's format
 * brush copies from the start of the source selection, so a mixed selection
@@ -81,6 +116,12 @@ function firstTextMarks(state, from, to) {
 	});
 	return marks ?? [];
 }
+function paragraphDefaultTextFormatting(position) {
+	for (let depth = position.depth; depth >= 0; depth -= 1) {
+		const ancestor = position.node(depth);
+		if (ancestor.type.name === "paragraph") return expectParagraphAttrs(ancestor).defaultTextFormatting;
+	}
+}
 /**
 * Capture the paintable character marks active over the current selection.
 * Returns the marks (with their attrs) to hand to `applyFormatMarks`. An empty
@@ -100,7 +141,10 @@ function captureFormatMarks(state) {
 		}
 		captured.push(mark);
 	}
-	return captured;
+	return materializeStyleToggleNegatives({
+		inheritedFormatting: paragraphDefaultTextFormatting($from),
+		marks: captured
+	});
 }
 /**
 * Apply captured marks onto the current selection's range: clear every paintable

package/dist/prosemirror/conversion/fromProseDoc.d.ts

@@ -8,7 +8,10 @@ declare function fromProseDoc(pmDoc: Node, baseDocument?: document_d_exports.Doc
 /**
  * Convert ProseMirror marks to TextFormatting
  */
-declare function marksToTextFormatting(marks: readonly Mark[]): document_d_exports.TextFormatting;
+type MarksToTextFormattingOptions = {
+  inheritedFormatting: document_d_exports.TextFormatting | undefined;
+};
+declare function marksToTextFormatting(marks: readonly Mark[], options?: MarksToTextFormattingOptions): document_d_exports.TextFormatting;
 declare const standaloneTableCellFromProseMirror: (node: Node) => document_d_exports.TableCell;
 /**
  * Update a Document with content from a ProseMirror document