@stll/folio-core 0.35.1 → 0.37.0

package/dist/prosemirror/commands/formatPainter.d.ts

@@ -1,3 +1,4 @@
+import { document_d_exports } from "../../types/document.js";
 import { Command, EditorState } from "prosemirror-state";
 import { Mark } from "prosemirror-model";
 //#region src/prosemirror/commands/formatPainter.d.ts
@@ -9,22 +10,56 @@ import { Mark } from "prosemirror-model";
  * text direction or hide content, which is surprising for a formatting brush.
  */
 declare const PAINTABLE_MARK_NAMES: ReadonlySet<string>;
+type PaintableFormatting = {
+  allCaps?: document_d_exports.TextFormatting["allCaps"];
+  bold?: document_d_exports.TextFormatting["bold"];
+  boldCs?: document_d_exports.TextFormatting["boldCs"];
+  color?: document_d_exports.TextFormatting["color"];
+  cs?: document_d_exports.TextFormatting["cs"];
+  doubleStrike?: document_d_exports.TextFormatting["doubleStrike"];
+  effect?: document_d_exports.TextFormatting["effect"];
+  emboss?: document_d_exports.TextFormatting["emboss"];
+  emphasisMark?: document_d_exports.TextFormatting["emphasisMark"];
+  fontFamily?: document_d_exports.TextFormatting["fontFamily"];
+  fontSize?: document_d_exports.TextFormatting["fontSize"];
+  fontSizeCs?: document_d_exports.TextFormatting["fontSizeCs"];
+  highlight?: document_d_exports.TextFormatting["highlight"];
+  imprint?: document_d_exports.TextFormatting["imprint"];
+  italic?: document_d_exports.TextFormatting["italic"];
+  italicCs?: document_d_exports.TextFormatting["italicCs"];
+  kerning?: document_d_exports.TextFormatting["kerning"];
+  outline?: document_d_exports.TextFormatting["outline"];
+  position?: document_d_exports.TextFormatting["position"];
+  scale?: document_d_exports.TextFormatting["scale"];
+  shading?: document_d_exports.TextFormatting["shading"];
+  shadow?: document_d_exports.TextFormatting["shadow"];
+  smallCaps?: document_d_exports.TextFormatting["smallCaps"];
+  spacing?: document_d_exports.TextFormatting["spacing"];
+  strike?: document_d_exports.TextFormatting["strike"];
+  underline?: document_d_exports.TextFormatting["underline"];
+  vertAlign?: document_d_exports.TextFormatting["vertAlign"];
+};
+type CapturedTextFormatting = Readonly<{
+  effectiveFormatting: Readonly<PaintableFormatting>;
+  marks: readonly Mark[];
+  type: "capturedTextFormatting";
+}>;
 /**
- * Capture the paintable character marks active over the current selection.
- * Returns the marks (with their attrs) to hand to `applyFormatMarks`. An empty
- * selection reads the stored/insertion marks; a range reads its leading run.
- * Returns an empty array when the source carries no direct character formatting.
+ * Capture the paintable character formatting active over the current selection.
+ * An empty selection reads the stored/insertion marks; a range reads its leading
+ * run. The discriminated result deliberately represents an effectively plain run:
+ * `null` belongs to the host's “nothing captured” state, not this command.
  */
-declare function captureFormatMarks(state: EditorState): Mark[];
+declare function captureFormatMarks(state: EditorState): CapturedTextFormatting;
 /**
  * Apply captured marks onto the current selection's range: clear every paintable
  * mark type first (replace, not merge — so painting Georgia-12-bold onto
  * Arial-10 leaves only Georgia-12-bold), then lay down the captured marks.
  *
- * Best-effort: a collapsed selection or an empty capture is a no-op (returns
- * false so a keymap binding stays unclaimed and the keystroke passes through).
- * Never throws.
+ * Best-effort: a collapsed selection, no capture, or a target-relative delta
+ * that cannot be represented without guessing document defaults is a no-op.
+ * Returns false so a keymap binding stays unclaimed; never partially mutates.
  */
-declare function applyFormatMarks(marks: readonly Mark[]): Command;
+declare function applyFormatMarks(captured: CapturedTextFormatting | null): Command;
 //#endregion
-export { PAINTABLE_MARK_NAMES, applyFormatMarks, captureFormatMarks };
+export { CapturedTextFormatting, PAINTABLE_MARK_NAMES, applyFormatMarks, captureFormatMarks };

package/dist/prosemirror/commands/formatPainter.js

@@ -1,4 +1,8 @@
-import { expectCharacterStyleMarkAttrs, expectParagraphAttrs } from "../attrs/index.js";
+import { mergeTextFormatting } from "../../utils/textFormattingMerge.js";
+import { expectCharacterStyleMarkAttrs } from "../attrs/index.js";
+import { getDocumentStyleResolver } from "../plugins/documentStyles.js";
+import { readAuthoredRunFormatting, reconcileRunFormattingMarks } from "../runFormattingReconciliation.js";
+import { paragraphFormattingForRun, paragraphRunStyleContext, paragraphRunStyleContextAt, resolveEffectiveRunStyleFormatting } from "../runStyleFormatting.js";
 //#region src/prosemirror/commands/formatPainter.ts
 /**
 * Character-formatting marks the painter copies. Structural marks — comments,
@@ -61,76 +65,288 @@ function sanitizeOverrideMark(mark) {
 		}
 		kept[key] = value;
 	}
+	for (const provenanceKey of ["_authoredOn", "_authoredOff"]) {
+		const properties = kept[provenanceKey];
+		if (!Array.isArray(properties)) continue;
+		const paintableProperties = properties.filter((property) => typeof property === "string" && !NON_PAINTABLE_FORMATS.has(property));
+		if (paintableProperties.length !== properties.length) {
+			kept[provenanceKey] = paintableProperties;
+			removedExcluded = true;
+		}
+	}
 	if (!removedExcluded) return 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;
+/**
+* Every effective property represented by a paintable mark has one target-context
+* policy. Adding a new paintable formatting field therefore requires an explicit
+* decision: an OOXML off sentinel, a neutral scalar, or a source value that cannot
+* be synthesized without flattening document defaults.
+*/
+const TARGET_RELATIVE_FORMATTING_POLICIES = {
+	allCaps: {
+		type: "boolean",
+		override: "allCaps"
+	},
+	bold: {
+		type: "boolean",
+		override: "bold"
+	},
+	boldCs: {
+		type: "boolean",
+		override: "boldCs",
+		fallback: "bold"
+	},
+	color: {
+		type: "sentinel",
+		override: "color",
+		inactive: "auto",
+		cancellation: { auto: true }
+	},
+	cs: {
+		type: "boolean",
+		override: "cs"
+	},
+	doubleStrike: {
+		type: "boolean",
+		override: "doubleStrike"
+	},
+	effect: {
+		type: "sentinel",
+		override: "effect",
+		inactive: "none",
+		cancellation: "none"
+	},
+	emboss: {
+		type: "boolean",
+		override: "emboss"
+	},
+	emphasisMark: {
+		type: "sentinel",
+		override: "emphasisMark",
+		inactive: "none",
+		cancellation: "none"
+	},
+	fontFamily: { type: "source-value-required" },
+	fontSize: { type: "source-value-required" },
+	fontSizeCs: {
+		type: "source-value-required",
+		fallback: "fontSize"
+	},
+	highlight: {
+		type: "sentinel",
+		override: "highlight",
+		inactive: "none",
+		cancellation: "none"
+	},
+	imprint: {
+		type: "boolean",
+		override: "imprint"
+	},
+	italic: {
+		type: "boolean",
+		override: "italic"
+	},
+	italicCs: {
+		type: "boolean",
+		override: "italicCs",
+		fallback: "italic"
+	},
+	kerning: {
+		type: "sentinel",
+		override: "kerning",
+		inactive: 0,
+		cancellation: 0
+	},
+	outline: {
+		type: "boolean",
+		override: "outline"
+	},
+	position: {
+		type: "sentinel",
+		override: "position",
+		inactive: 0,
+		cancellation: 0
+	},
+	scale: {
+		type: "sentinel",
+		override: "scale",
+		inactive: 100,
+		cancellation: 100
+	},
+	shading: {
+		type: "sentinel",
+		override: "shading",
+		inactive: "nil",
+		cancellation: { pattern: "nil" },
+		projection: "shading"
+	},
+	shadow: {
+		type: "boolean",
+		override: "shadow"
+	},
+	smallCaps: {
+		type: "boolean",
+		override: "smallCaps"
+	},
+	spacing: {
+		type: "sentinel",
+		override: "spacing",
+		inactive: 0,
+		cancellation: 0
+	},
+	strike: {
+		type: "boolean",
+		override: "strike"
+	},
+	underline: {
+		type: "sentinel",
+		override: "underline",
+		inactive: "none",
+		cancellation: { style: "none" },
+		projection: "style"
+	},
+	vertAlign: {
+		type: "sentinel",
+		override: "vertAlign",
+		inactive: "baseline",
+		cancellation: "baseline"
+	}
+};
+const PAINTABLE_FORMATTING_KEYS = Object.keys(TARGET_RELATIVE_FORMATTING_POLICIES);
+const targetRelativeFormattingPolicy = (key) => TARGET_RELATIVE_FORMATTING_POLICIES[key];
+function pickPaintableFormatting(formatting) {
+	const result = {};
+	if (!formatting) return result;
+	for (const key of PAINTABLE_FORMATTING_KEYS) {
+		const value = formatting[key];
+		if (value !== void 0) Reflect.set(result, key, value);
 	}
-	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 result;
+}
+function resolveEffectiveFormatting({ context, marks, styleResolver }) {
+	const authoredFormatting = readAuthoredRunFormatting({
+		context,
+		marks,
+		styleResolver
 	});
-	return existingOverride ? marks.map((mark) => mark === existingOverride ? override : mark) : [...marks, override];
+	const effectiveFormatting = mergeTextFormatting(resolveEffectiveRunStyleFormatting({
+		marks,
+		paragraphFormatting: paragraphFormattingForRun({
+			context,
+			directFormatting: authoredFormatting,
+			marks
+		}),
+		styleResolver
+	}), authoredFormatting) ?? {};
+	if (authoredFormatting.shading?.pattern === "nil") effectiveFormatting.shading = authoredFormatting.shading;
+	if (authoredFormatting.underline?.style === "none") effectiveFormatting.underline = authoredFormatting.underline;
+	return pickPaintableFormatting(effectiveFormatting);
 }
-/**
-* 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
-* yields the formatting of its leading run.
-*/
-function firstTextMarks(state, from, to) {
-	let marks = null;
-	state.doc.nodesBetween(from, to, (node) => {
-		if (marks) return false;
+function resolveCopiedStyleFormatting({ context, marks, styleResolver }) {
+	if (marks.some((mark) => mark.type.name === "characterStyle") && !styleResolver) return null;
+	return pickPaintableFormatting(resolveEffectiveRunStyleFormatting({
+		marks,
+		paragraphFormatting: paragraphFormattingForRun({
+			context,
+			marks
+		}),
+		styleResolver
+	}));
+}
+function sameFormattingValue(left, right) {
+	if (Object.is(left, right)) return true;
+	if (left === null || right === null || typeof left !== "object" || typeof right !== "object") return false;
+	if (Array.isArray(left) || Array.isArray(right)) return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, index) => sameFormattingValue(value, right.at(index)));
+	const leftEntries = Object.entries(left);
+	const rightKeys = Object.keys(right);
+	return leftEntries.length === rightKeys.length && leftEntries.every(([property, value]) => Object.hasOwn(right, property) && sameFormattingValue(value, Reflect.get(right, property)));
+}
+function policyValue(formatting, key, policy) {
+	const own = formatting[key];
+	const value = own ?? (policy.type !== "sentinel" ? formatting[policy.fallback ?? key] : own);
+	if (policy.type !== "sentinel") return value;
+	if (policy.projection === "style") return typeof value === "object" && value !== null ? Reflect.get(value, "style") : void 0;
+	if (policy.projection === "shading") {
+		if (typeof value !== "object" || value === null) return;
+		return Reflect.get(value, "pattern") === "nil" ? "nil" : value;
+	}
+	if (key === "color") return typeof value === "object" && value !== null && Reflect.get(value, "auto") === true ? "auto" : value;
+	return value;
+}
+function materializeTargetRelativeMarks({ captured, context, node, styleResolver }) {
+	const targetStyleFormatting = resolveCopiedStyleFormatting({
+		context,
+		marks: captured.marks,
+		styleResolver
+	});
+	if (!targetStyleFormatting) return null;
+	const targetRelativeFormatting = {};
+	for (const key of PAINTABLE_FORMATTING_KEYS) {
+		const policy = targetRelativeFormattingPolicy(key);
+		const sourceValue = policyValue(captured.effectiveFormatting, key, policy);
+		const targetValue = policyValue(targetStyleFormatting, key, policy);
+		if ((key === "boldCs" || key === "italicCs" || key === "fontSizeCs") && captured.effectiveFormatting[key] === void 0 && targetStyleFormatting[key] === void 0) continue;
+		if (policy.type === "source-value-required") {
+			if (sourceValue === void 0 && targetValue !== void 0) return null;
+			if (sourceValue !== void 0 && !sameFormattingValue(sourceValue, targetValue)) Reflect.set(targetRelativeFormatting, key, sourceValue);
+			continue;
+		}
+		if (policy.type === "boolean") {
+			const sourceIsOn = sourceValue === true;
+			if (sourceIsOn !== (targetValue === true)) Reflect.set(targetRelativeFormatting, policy.override, sourceIsOn);
+			continue;
+		}
+		const sourceIsInactive = sourceValue === void 0 || sourceValue === policy.inactive;
+		const targetIsInactive = targetValue === void 0 || targetValue === policy.inactive;
+		if (sourceIsInactive) {
+			if (!targetIsInactive) Reflect.set(targetRelativeFormatting, policy.override, captured.effectiveFormatting[key] ?? policy.cancellation);
+			continue;
+		}
+		if (!sameFormattingValue(sourceValue, targetValue)) {
+			const formattingValue = captured.effectiveFormatting[key];
+			if (formattingValue === void 0) return null;
+			Reflect.set(targetRelativeFormatting, policy.override, formattingValue);
+		}
+	}
+	const characterStyle = captured.marks.find((mark) => mark.type.name === "characterStyle");
+	const characterStyleId = characterStyle ? expectCharacterStyleMarkAttrs(characterStyle).styleId : void 0;
+	return reconcileRunFormattingMarks({
+		authoredFormatting: {
+			...targetRelativeFormatting,
+			...characterStyleId !== void 0 ? { styleId: characterStyleId } : {}
+		},
+		context,
+		node,
+		styleResolver
+	}).filter(isPaintableMark);
+}
+function firstTextFormatting(state, from, to) {
+	let formatting = null;
+	state.doc.nodesBetween(from, to, (node, position) => {
+		if (formatting) return false;
 		if (node.isText) {
-			marks = node.marks;
+			formatting = {
+				marks: node.marks,
+				position: state.doc.resolve(position)
+			};
 			return false;
 		}
 		return true;
 	});
-	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;
-	}
+	return formatting;
 }
 /**
-* Capture the paintable character marks active over the current selection.
-* Returns the marks (with their attrs) to hand to `applyFormatMarks`. An empty
-* selection reads the stored/insertion marks; a range reads its leading run.
-* Returns an empty array when the source carries no direct character formatting.
+* Capture the paintable character formatting active over the current selection.
+* An empty selection reads the stored/insertion marks; a range reads its leading
+* run. The discriminated result deliberately represents an effectively plain run:
+* `null` belongs to the host's “nothing captured” state, not this command.
 */
 function captureFormatMarks(state) {
 	const { empty, $from, from, to } = state.selection;
-	const source = empty ? state.storedMarks ?? $from.marks() : firstTextMarks(state, from, to);
+	const firstText = empty ? null : firstTextFormatting(state, from, to);
+	const source = empty ? state.storedMarks ?? $from.marks() : firstText?.marks ?? [];
 	const captured = [];
 	for (const mark of source) {
 		if (!isPaintableMark(mark)) continue;
@@ -141,31 +357,71 @@ function captureFormatMarks(state) {
 		}
 		captured.push(mark);
 	}
-	return materializeStyleToggleNegatives({
-		inheritedFormatting: paragraphDefaultTextFormatting($from),
-		marks: captured
+	const styleResolver = getDocumentStyleResolver(state);
+	return {
+		effectiveFormatting: resolveEffectiveFormatting({
+			context: paragraphRunStyleContextAt({
+				doc: state.doc,
+				pos: (firstText?.position ?? $from).pos,
+				styleResolver
+			}),
+			marks: captured,
+			styleResolver
+		}),
+		marks: captured,
+		type: "capturedTextFormatting"
+	};
+}
+function targetParagraphSegments(state, from, to, styleResolver) {
+	const segments = [];
+	state.doc.nodesBetween(from, to, (node, position) => {
+		if (node.type.name !== "paragraph") return true;
+		const contentFrom = position + 1;
+		const segmentFrom = Math.max(from, contentFrom);
+		const segmentTo = Math.min(to, contentFrom + node.content.size);
+		if (segmentTo > segmentFrom) segments.push({
+			context: paragraphRunStyleContext(node, styleResolver),
+			from: segmentFrom,
+			to: segmentTo
+		});
+		return false;
 	});
+	return segments;
 }
 /**
 * Apply captured marks onto the current selection's range: clear every paintable
 * mark type first (replace, not merge — so painting Georgia-12-bold onto
 * Arial-10 leaves only Georgia-12-bold), then lay down the captured marks.
 *
-* Best-effort: a collapsed selection or an empty capture is a no-op (returns
-* false so a keymap binding stays unclaimed and the keystroke passes through).
-* Never throws.
+* Best-effort: a collapsed selection, no capture, or a target-relative delta
+* that cannot be represented without guessing document defaults is a no-op.
+* Returns false so a keymap binding stays unclaimed; never partially mutates.
 */
-function applyFormatMarks(marks) {
+function applyFormatMarks(captured) {
 	return (state, dispatch) => {
 		const { from, to, empty } = state.selection;
-		if (empty || marks.length === 0) return false;
+		if (empty || captured?.type !== "capturedTextFormatting") return false;
+		const styleResolver = getDocumentStyleResolver(state);
+		const segments = targetParagraphSegments(state, from, to, styleResolver);
+		const node = state.schema.text("format-painter");
+		const targetMarks = segments.map((segment) => materializeTargetRelativeMarks({
+			captured,
+			context: segment.context,
+			node,
+			styleResolver
+		}));
+		if (segments.length === 0 || targetMarks.some((marks) => marks === null)) return false;
 		if (!dispatch) return true;
 		let tr = state.tr;
 		for (const name of PAINTABLE_MARK_NAMES) {
 			const markType = state.schema.marks[name];
 			if (markType) tr = tr.removeMark(from, to, markType);
 		}
-		for (const mark of marks) tr = tr.addMark(from, to, mark);
+		for (const [index, segment] of segments.entries()) {
+			const marks = targetMarks[index];
+			if (!marks) continue;
+			for (const mark of marks) tr = tr.addMark(segment.from, segment.to, mark);
+		}
 		dispatch(tr.scrollIntoView());
 		return true;
 	};

package/dist/prosemirror/commands/index.d.ts

@@ -1,7 +1,7 @@
 import { ResolvedStyleAttrs, getParagraphAlignment, getParagraphBidi, getStyleId } from "../extensions/core/ParagraphExtension.js";
 import { BorderPreset, TableBorderPreset, TableContextInfo, getTableContext, isInTable as isInTableCell } from "../extensions/nodes/TableExtension.js";
 import { AcceptSuggestionOptions, FolioSuggestion, SuggestionAppliedAs, SuggestionKind, acceptAIEditRevision, acceptAllChanges, acceptAllSuggestions, acceptChange, acceptSuggestion, addCommentMark, findAIEditRevisionRange, findNextChange, findPreviousChange, findSuggestionRange, getSuggestions, rejectAIEditRevision, rejectAllChanges, rejectAllSuggestions, rejectChange, rejectSuggestion, removeCommentMark } from "./comments.js";
-import { PAINTABLE_MARK_NAMES, applyFormatMarks, captureFormatMarks } from "./formatPainter.js";
+import { CapturedTextFormatting, PAINTABLE_MARK_NAMES, applyFormatMarks, captureFormatMarks } from "./formatPainter.js";
 import { clearFormatting, createRemoveMarkCommand, createSetMarkCommand, getMarkAttr, isMarkActive } from "../extensions/marks/markUtils.js";
 import { getHyperlinkAttrs, getSelectedText, isHyperlinkActive } from "../extensions/marks/HyperlinkExtension.js";
 import { clearFontFamily, clearFontSize, clearHighlight, clearTextColor, insertHyperlink, removeHyperlink, setFontFamily, setFontSize, setHighlight, setHyperlink, setTextColor, setUnderlineStyle, toggleBold, toggleItalic, toggleStrike, toggleSubscript, toggleSuperscript, toggleUnderline } from "./formatting.js";
@@ -10,4 +10,4 @@ import { addTabStop, alignCenter, alignJustify, alignLeft, alignRight, applyStyl
 import { addColumnLeft, addColumnRight, addRowAbove, addRowBelow, applyTableStyle, autoFitContents, deleteColumn, deleteRow, deleteTable, distributeColumns, insertTable, mergeCells, removeTableBorders, selectColumn, selectRow, selectTable, setAllTableBorders, setCellBorder, setCellFillColor, setCellMargins, setCellTextDirection, setCellVerticalAlign, setInsideTableBorders, setOutsideTableBorders, setRowHeight, setTableBorderColor, setTableBorderPreset, setTableBorderWidth, setTableBorders, setTableProperties, splitCell, toggleHeaderRow, toggleNoWrap } from "./table.js";
 import { insertPageBreak } from "./pageBreak.js";
 import { CLIPBOARD_READ_ERROR_EVENT, buildPlainTextSlice, pasteWithoutFormatting } from "./pastePlainText.js";
-export { type AcceptSuggestionOptions, type BorderPreset, CLIPBOARD_READ_ERROR_EVENT, type FolioSuggestion, PAINTABLE_MARK_NAMES, type ResolvedStyleAttrs, type SuggestionAppliedAs, type SuggestionKind, type TableBorderPreset, type TableContextInfo, acceptAIEditRevision, acceptAllChanges, acceptAllSuggestions, acceptChange, acceptSuggestion, addColumnLeft, addColumnRight, addCommentMark, addRowAbove, addRowBelow, addTabStop, alignCenter, alignJustify, alignLeft, alignRight, applyFormatMarks, applyStyle, applyTableStyle, autoFitContents, buildPlainTextSlice, captureFormatMarks, clearFontFamily, clearFontSize, clearFormatting, clearHighlight, clearStyle, clearTextColor, createRemoveMarkCommand, createSetMarkCommand, decreaseIndent, decreaseListLevel, deleteColumn, deleteRow, deleteTable, distributeColumns, doubleSpacing, findAIEditRevisionRange, findNextChange, findPreviousChange, findSuggestionRange, generateTOC, getHyperlinkAttrs, getListInfo, getMarkAttr, getParagraphAlignment, getParagraphBidi, getSelectedText, getStyleId, getSuggestions, getTableContext, increaseIndent, increaseListLevel, insertHyperlink, insertPageBreak, insertTable, isHyperlinkActive, isInList, isInTableCell as isInTable, isMarkActive, mergeCells, oneAndHalfSpacing, pasteWithoutFormatting, rejectAIEditRevision, rejectAllChanges, rejectAllSuggestions, rejectChange, rejectSuggestion, removeCommentMark, removeHyperlink, removeList, removeTabStop, removeTableBorders, selectColumn, selectRow, selectTable, setAlignment, setAllTableBorders, setCellBorder, setCellFillColor, setCellMargins, setCellTextDirection, setCellVerticalAlign, setFontFamily, setFontSize, setHighlight, setHyperlink, setIndentFirstLine, setIndentLeft, setIndentRight, setInsideTableBorders, setLineSpacing, setLtr, setOutsideTableBorders, setRowHeight, setRtl, setSpaceAfter, setSpaceBefore, setTableBorderColor, setTableBorderPreset, setTableBorderWidth, setTableBorders, setTableProperties, setTextColor, setUnderlineStyle, singleSpacing, splitCell, toggleBidi, toggleBold, toggleBulletList, toggleHeaderRow, toggleItalic, toggleNoWrap, toggleNumberedList, toggleStrike, toggleSubscript, toggleSuperscript, toggleUnderline };
+export { type AcceptSuggestionOptions, type BorderPreset, CLIPBOARD_READ_ERROR_EVENT, type CapturedTextFormatting, type FolioSuggestion, PAINTABLE_MARK_NAMES, type ResolvedStyleAttrs, type SuggestionAppliedAs, type SuggestionKind, type TableBorderPreset, type TableContextInfo, acceptAIEditRevision, acceptAllChanges, acceptAllSuggestions, acceptChange, acceptSuggestion, addColumnLeft, addColumnRight, addCommentMark, addRowAbove, addRowBelow, addTabStop, alignCenter, alignJustify, alignLeft, alignRight, applyFormatMarks, applyStyle, applyTableStyle, autoFitContents, buildPlainTextSlice, captureFormatMarks, clearFontFamily, clearFontSize, clearFormatting, clearHighlight, clearStyle, clearTextColor, createRemoveMarkCommand, createSetMarkCommand, decreaseIndent, decreaseListLevel, deleteColumn, deleteRow, deleteTable, distributeColumns, doubleSpacing, findAIEditRevisionRange, findNextChange, findPreviousChange, findSuggestionRange, generateTOC, getHyperlinkAttrs, getListInfo, getMarkAttr, getParagraphAlignment, getParagraphBidi, getSelectedText, getStyleId, getSuggestions, getTableContext, increaseIndent, increaseListLevel, insertHyperlink, insertPageBreak, insertTable, isHyperlinkActive, isInList, isInTableCell as isInTable, isMarkActive, mergeCells, oneAndHalfSpacing, pasteWithoutFormatting, rejectAIEditRevision, rejectAllChanges, rejectAllSuggestions, rejectChange, rejectSuggestion, removeCommentMark, removeHyperlink, removeList, removeTabStop, removeTableBorders, selectColumn, selectRow, selectTable, setAlignment, setAllTableBorders, setCellBorder, setCellFillColor, setCellMargins, setCellTextDirection, setCellVerticalAlign, setFontFamily, setFontSize, setHighlight, setHyperlink, setIndentFirstLine, setIndentLeft, setIndentRight, setInsideTableBorders, setLineSpacing, setLtr, setOutsideTableBorders, setRowHeight, setRtl, setSpaceAfter, setSpaceBefore, setTableBorderColor, setTableBorderPreset, setTableBorderWidth, setTableBorders, setTableProperties, setTextColor, setUnderlineStyle, singleSpacing, splitCell, toggleBidi, toggleBold, toggleBulletList, toggleHeaderRow, toggleItalic, toggleNoWrap, toggleNumberedList, toggleStrike, toggleSubscript, toggleSuperscript, toggleUnderline };

package/dist/prosemirror/commands/pageBreak.d.ts

@@ -1,8 +1,11 @@
 import { Command } from "prosemirror-state";
 //#region src/prosemirror/commands/pageBreak.d.ts
 /**
- * Insert a page break at the current cursor position.
- * Always ensures a paragraph follows the page break and places the cursor there.
+ * Insert a page-break run at the current text cursor.
+ *
+ * Keeping the atom inline preserves its authored run, revision marks, and exact
+ * position among neighbouring run content. Block-level `pageBreak` remains a
+ * legacy input boundary and is never emitted by this command.
  */
 declare const insertPageBreak: Command;
 //#endregion

package/dist/prosemirror/commands/pageBreak.js

@@ -1,45 +1,27 @@
-import { Fragment } from "prosemirror-model";
-import { TextSelection } from "prosemirror-state";
+import { pageBreakRunParagraphProjectionDisposition } from "../pageBreakRunProjection.js";
 //#region src/prosemirror/commands/pageBreak.ts
+const UNSUPPORTED_PAGE_BREAK_RUN_ANCESTORS = /* @__PURE__ */ new Set([
+	"tableCell",
+	"tableHeader",
+	"textBox"
+]);
 /**
-* Page Break Commands
-*/
-/**
-* Insert a page break at the current cursor position.
-* Always ensures a paragraph follows the page break and places the cursor there.
+* Insert a page-break run at the current text cursor.
+*
+* Keeping the atom inline preserves its authored run, revision marks, and exact
+* position among neighbouring run content. Block-level `pageBreak` remains a
+* legacy input boundary and is never emitted by this command.
 */
 const insertPageBreak = (state, dispatch) => {
 	const { schema } = state;
-	const pageBreakType = schema.nodes["pageBreak"];
-	const paragraphType = schema.nodes["paragraph"];
-	if (!pageBreakType || !paragraphType) return false;
+	const pageBreakRunType = schema.nodes["pageBreakRun"];
+	const { $from } = state.selection;
+	if (!pageBreakRunType || !state.selection.empty || !$from.parent.isTextblock) return false;
+	for (let depth = $from.depth; depth >= 0; depth--) if (UNSUPPORTED_PAGE_BREAK_RUN_ANCESTORS.has($from.node(depth).type.name)) return false;
+	if ($from.parent.type.name !== "paragraph" || pageBreakRunParagraphProjectionDisposition($from.parent).status === "unsupported") return false;
 	if (dispatch) {
-		const { $from } = state.selection;
-		const tr = state.tr;
-		const pbNode = pageBreakType.create();
-		const pbSize = pbNode.nodeSize;
-		let cursorPos;
-		if ($from.parent.isTextblock) if ($from.parentOffset > 0 && $from.parentOffset < $from.parent.content.size) {
-			tr.split($from.pos);
-			const mappedPos = tr.mapping.map($from.pos);
-			tr.insert(mappedPos, Fragment.from([pbNode, paragraphType.create()]));
-			cursorPos = mappedPos + pbSize + 1;
-		} else if ($from.parentOffset === $from.parent.content.size) {
-			const after = $from.after();
-			tr.insert(after, Fragment.from([pbNode, paragraphType.create()]));
-			cursorPos = after + pbSize + 1;
-		} else {
-			const before = $from.before();
-			tr.insert(before, pbNode);
-			cursorPos = before + pbSize + 1;
-		}
-		else {
-			const pos = $from.pos;
-			tr.insert(pos, Fragment.from([pbNode, paragraphType.create()]));
-			cursorPos = pos + pbSize + 1;
-		}
-		tr.setSelection(TextSelection.create(tr.doc, cursorPos));
-		dispatch(tr.scrollIntoView());
+		const pageBreak = pageBreakRunType.create();
+		dispatch(state.tr.replaceSelectionWith(pageBreak).scrollIntoView());
 	}
 	return true;
 };