@stll/folio-core 0.62.0 → 0.63.1

package/dist/prosemirror/tableResize.js

@@ -1,11 +1,24 @@
-import { mergeTableCellAttrs } from "./attrs/index.js";
+import { expectTableAttrs, expectTableCellAttrs, mergeTableAttrs, mergeTableCellAttrs } from "./attrs/index.js";
+import { panic } from "better-result";
 //#region src/prosemirror/tableResize.ts
+/**
+* Table-resize commit + width-read helpers shared by the React and Vue
+* adapters. Pure `(view, …) → result` over the PM doc — the gesture state
+* machines (which DOM handle is grabbed, pixel deltas, listener wiring) stay
+* in each adapter.
+*
+* Widths and heights are stored in twips (1/20 of a point) on the PM doc,
+* matching OOXML's `w:tblGrid` and `w:tcW` units.
+*/
 /** 1px ≈ 15 twips at 96dpi (20 twips/pt × 72pt/in ÷ 96px/in). */
 const TWIPS_PER_PIXEL = 15;
 /** Minimum column width (~0.2"). */
 const MIN_CELL_WIDTH_TWIPS = 300;
 /** Minimum row height (~0.14"). */
 const MIN_ROW_HEIGHT_TWIPS = 200;
+function clampRowResizeDelta({ currentHeight, delta, minimumHeight }) {
+	return Math.max(minimumHeight - currentHeight, delta);
+}
 /** Walk up from `pmStart + 1` to find the enclosing table node. */
 function findTableAt(view, pmStart) {
 	try {
@@ -63,44 +76,60 @@ function readColumnWidthAt(view, pmStart, colIndex) {
 	if (width === void 0) return null;
 	return width;
 }
-/**
-* Bake a column-resize into the PM doc: update the table's `columnWidths`
-* attr and every cell at `colIdx` / `colIdx + 1` in every row.
-*/
-function commitColumnResize(view, opts) {
-	const { pmStart, colIdx, newLeft, newRight } = opts;
-	const found = findTableAt(view, pmStart);
-	if (!found) return;
-	const { node, tablePos } = found;
+const commitGridResize = ({ view, table: { node, tablePos }, widths, firstColumn, lastColumn }) => {
 	const tr = view.state.tr;
-	const widths = [...node.attrs["columnWidths"] ?? []];
-	widths[colIdx] = newLeft;
-	widths[colIdx + 1] = newRight;
-	tr.setNodeMarkup(tablePos, void 0, {
-		...node.attrs,
+	tr.setNodeMarkup(tablePos, void 0, mergeTableAttrs(node, {
 		columnWidths: widths,
-		tableLayout: "fixed"
-	});
+		_originalFormatting: {
+			...expectTableAttrs(node)._originalFormatting,
+			layout: "fixed"
+		}
+	}));
 	let rowOffset = tablePos + 1;
 	node.forEach((row) => {
 		let cellOffset = rowOffset + 1;
-		let cellColIdx = 0;
+		let cellColumn = 0;
 		row.forEach((cell) => {
-			const colspan = cell.attrs["colspan"] || 1;
-			if (cellColIdx === colIdx || cellColIdx === colIdx + 1) {
-				const newWidth = cellColIdx === colIdx ? newLeft : newRight;
-				tr.setNodeMarkup(tr.mapping.map(cellOffset), void 0, mergeTableCellAttrs(cell, {
-					width: newWidth,
+			const { colspan } = expectTableCellAttrs(cell);
+			if (!Number.isInteger(colspan) || colspan < 1) panic("A resized table cell must span a positive number of columns.");
+			const endColumn = cellColumn + colspan;
+			if (cellColumn <= lastColumn && endColumn > firstColumn) {
+				let width = 0;
+				for (let column = cellColumn; column < endColumn; column++) {
+					const coveredWidth = widths[column];
+					if (coveredWidth === void 0 || !Number.isFinite(coveredWidth) || coveredWidth <= 0) panic("A resized table cell must cover valid grid columns.");
+					width += coveredWidth;
+				}
+				tr.setNodeMarkup(cellOffset, void 0, mergeTableCellAttrs(cell, {
+					width,
 					widthType: "dxa",
 					colwidth: null
 				}));
 			}
 			cellOffset += cell.nodeSize;
-			cellColIdx += colspan;
+			cellColumn = endColumn;
 		});
 		rowOffset += row.nodeSize;
 	});
 	view.dispatch(tr);
+};
+/** Commit a column-pair resize, preserving each spanning cell's full grid width. */
+function commitColumnResize(view, opts) {
+	const { pmStart, colIdx, newLeft, newRight } = opts;
+	const found = findTableAt(view, pmStart);
+	if (!found) return;
+	const sourceWidths = expectTableAttrs(found.node).columnWidths;
+	if (!sourceWidths || sourceWidths[colIdx] === void 0 || sourceWidths[colIdx + 1] === void 0) return;
+	const widths = [...sourceWidths];
+	widths[colIdx] = newLeft;
+	widths[colIdx + 1] = newRight;
+	commitGridResize({
+		view,
+		table: found,
+		widths,
+		firstColumn: colIdx,
+		lastColumn: colIdx + 1
+	});
 }
 /** Bake a row-resize into the PM doc: update the target row's `height` + `heightRule`. */
 function commitRowResize(view, opts) {
@@ -122,40 +151,22 @@ function commitRowResize(view, opts) {
 	});
 	view.dispatch(tr);
 }
-/**
-* Bake a right-edge resize into the PM doc: grow only the last column.
-* Updates `columnWidths[colIdx]` and the cell at `colIdx` in every row.
-*/
+/** Commit a right-edge resize, including cells that span the resized column. */
 function commitRightEdgeResize(view, opts) {
 	const { pmStart, colIdx, newWidth } = opts;
 	const found = findTableAt(view, pmStart);
 	if (!found) return;
-	const { node, tablePos } = found;
-	const tr = view.state.tr;
-	const widths = [...node.attrs["columnWidths"] ?? []];
+	const sourceWidths = expectTableAttrs(found.node).columnWidths;
+	if (!sourceWidths || sourceWidths[colIdx] === void 0) return;
+	const widths = [...sourceWidths];
 	widths[colIdx] = newWidth;
-	tr.setNodeMarkup(tablePos, void 0, {
-		...node.attrs,
-		columnWidths: widths,
-		tableLayout: "fixed"
+	commitGridResize({
+		view,
+		table: found,
+		widths,
+		firstColumn: colIdx,
+		lastColumn: colIdx
 	});
-	let rowOffset = tablePos + 1;
-	node.forEach((row) => {
-		let cellOffset = rowOffset + 1;
-		let cellColIdx = 0;
-		row.forEach((cell) => {
-			const colspan = cell.attrs["colspan"] || 1;
-			if (cellColIdx === colIdx) tr.setNodeMarkup(tr.mapping.map(cellOffset), void 0, mergeTableCellAttrs(cell, {
-				width: newWidth,
-				widthType: "dxa",
-				colwidth: null
-			}));
-			cellOffset += cell.nodeSize;
-			cellColIdx += colspan;
-		});
-		rowOffset += row.nodeSize;
-	});
-	view.dispatch(tr);
 }
 //#endregion
-export { MIN_CELL_WIDTH_TWIPS, MIN_ROW_HEIGHT_TWIPS, TWIPS_PER_PIXEL, commitColumnResize, commitRightEdgeResize, commitRowResize, readColumnWidthAt, readColumnWidths, readRowHeight };
+export { MIN_CELL_WIDTH_TWIPS, MIN_ROW_HEIGHT_TWIPS, TWIPS_PER_PIXEL, clampRowResizeDelta, commitColumnResize, commitRightEdgeResize, commitRowResize, readColumnWidthAt, readColumnWidths, readRowHeight };

package/dist/prosemirror/tableRunIn.d.ts

@@ -9,7 +9,7 @@ import { StepMap, Transform } from "prosemirror-transform";
  * or merged, so resolving may not keep it. Pending rows or cells elsewhere in
  * the table leave that cell where it is.
  */
-declare const runInCellPending: (table: Node) => boolean;
+export declare const runInCellPending: (table: Node) => boolean;
 type RunParagraphIntoTableOptions = {
   tr: Transform;
   paragraphPos: number;
@@ -23,7 +23,7 @@ type RunParagraphIntoTableOptions = {
  * paragraph-property source it hands over, or null when it did not run in and
  * the caller keeps its own handling.
  */
-declare const runParagraphIntoTable: ({ tr, paragraphPos, styleResolver, removedMark }: RunParagraphIntoTableOptions) => {
+export declare const runParagraphIntoTable: ({ tr, paragraphPos, styleResolver, removedMark }: RunParagraphIntoTableOptions) => {
   position: number;
   map: StepMap;
   transfer: ParagraphPropertySourceTransfer;
@@ -32,14 +32,19 @@ declare const runParagraphIntoTable: ({ tr, paragraphPos, styleResolver, removed
  * Whether resolving every change in `mode` runs `paragraph` on into `next`:
  * its mark goes and `next` is a table.
  */
-declare const runsIntoFollowingTable: (paragraph: Node, next: Node | null | undefined, mode: "accept" | "reject") => boolean;
+type RunsIntoFollowingTableOptions = {
+  parent: Node;
+  index: number;
+  mode: "accept" | "reject";
+};
+export declare const runsIntoFollowingTable: ({ parent, index, mode }: RunsIntoFollowingTableOptions) => boolean;
 /**
  * Before every change in a story is resolved: run each paragraph whose mark
  * goes and that sits right before a table on into that table. Returns each
  * paragraph that took words (its position after the step count given) and
  * the paragraph-property sources handed over.
  */
-declare const runParagraphsIntoTables: (tr: Transform, mode: "accept" | "reject", styleResolver: RunStyleResolver | null) => {
+export declare const runParagraphsIntoTables: (tr: Transform, mode: "accept" | "reject", styleResolver: RunStyleResolver | null) => {
   targets: {
     position: number;
     step: number;
@@ -48,4 +53,4 @@ declare const runParagraphsIntoTables: (tr: Transform, mode: "accept" | "reject"
   transfers: ParagraphPropertySourceTransfer[];
 };
 //#endregion
-export { runInCellPending, runParagraphIntoTable, runParagraphsIntoTables, runsIntoFollowingTable };
+export {};

package/dist/prosemirror/tableRunIn.js

@@ -1,10 +1,12 @@
 import { getProseParagraphPropertySourceToken, recreateProseNodeWithParagraphPropertySource } from "../docx/paragraphPropertySource.js";
 import { expectParagraphAttrs } from "./attrs/index.js";
+import { paragraphRemainsOf } from "./keptRangeBoundaries.js";
 import { rebaseParagraphRuns } from "./rebaseParagraphRunFormatting.js";
 import { paragraphRunStyleContext } from "./runStyleFormatting.js";
-import { holdsNoContent } from "./zeroWidthAnchors.js";
+import { paragraphContentOf } from "./zeroWidthAnchors.js";
 import { Fragment, Slice } from "prosemirror-model";
 import { ReplaceAroundStep, StepMap } from "prosemirror-transform";
+import { paragraphMarkOutcome } from "@stll/docx-core/ops";
 //#region src/prosemirror/tableRunIn.ts
 /**
 * A paragraph whose mark goes, right before a table.
@@ -57,6 +59,7 @@ const runInTarget = (doc, tablePos) => {
 		node
 	} : null;
 };
+const paragraphAfterContentRemoval = (paragraph, removedMark) => removedMark ? paragraph.copy(Fragment.fromArray(paragraph.children.filter((child) => !removedMark.isInSet(child.marks)))) : paragraph;
 /**
 * Run the paragraph at `paragraphPos` on into the table right after it.
 * Returns where the paragraph that took its words now starts and the
@@ -67,7 +70,9 @@ const runParagraphIntoTable = ({ tr, paragraphPos, styleResolver, removedMark })
 	const paragraph = tr.doc.nodeAt(paragraphPos);
 	if (paragraph?.type.name !== "paragraph") return null;
 	if (expectParagraphAttrs(paragraph)._sectionProperties !== void 0) return null;
-	if (holdsNoContent(removedMark ? paragraph.copy(Fragment.fromArray(paragraph.children.filter((child) => !removedMark.isInSet(child.marks)))) : paragraph)) return null;
+	const left = paragraphAfterContentRemoval(paragraph, removedMark);
+	const remains = paragraphRemainsOf(left);
+	if (!paragraphContentOf(left) && (remains.blocks.length > 0 || remains.comments.length === 0)) return null;
 	const tablePos = paragraphPos + paragraph.nodeSize;
 	const target = runInTarget(tr.doc, tablePos);
 	if (!target) return null;
@@ -113,11 +118,38 @@ const markGoes = (paragraph, mode) => {
 	if (!mark) return false;
 	return (mark.kind === "ins" || mark.kind === "moveTo") !== (mode === "accept");
 };
-/**
-* Whether resolving every change in `mode` runs `paragraph` on into `next`:
-* its mark goes and `next` is a table.
-*/
-const runsIntoFollowingTable = (paragraph, next, mode) => paragraph.type.name === "paragraph" && next?.type.spec["tableRole"] === "table" && markGoes(paragraph, mode);
+const runsIntoFollowingTable = ({ parent, index, mode }) => {
+	const paragraph = parent.child(index);
+	const next = parent.maybeChild(index + 1);
+	if (paragraph.type.name !== "paragraph" || next?.type.spec["tableRole"] !== "table" || !markGoes(paragraph, mode)) return false;
+	const remains = paragraphRemainsOf(paragraph);
+	const holdsContent = paragraphContentOf(paragraph);
+	const needsCommentHost = !holdsContent && remains.blocks.length === 0 && remains.comments.length > 0;
+	const removedMark = paragraph.type.schema.marks[mode === "accept" ? "deletion" : "insertion"];
+	let hasPrecedingCommentHost = false;
+	for (let previousIndex = needsCommentHost ? index - 1 : -1; previousIndex >= 0; previousIndex -= 1) {
+		const previous = parent.child(previousIndex);
+		if (previous.type.name !== "paragraph") break;
+		if (!markGoes(previous, mode) || expectParagraphAttrs(previous)._sectionProperties !== void 0) {
+			hasPrecedingCommentHost = true;
+			break;
+		}
+		const retained = paragraphAfterContentRemoval(previous, removedMark);
+		if (paragraphContentOf(retained)) break;
+		if (paragraphRemainsOf(retained).blocks.length > 0) {
+			hasPrecedingCommentHost = true;
+			break;
+		}
+	}
+	return paragraphMarkOutcome({
+		follows: "table",
+		holdsContent,
+		markWasAdded: expectParagraphAttrs(paragraph).pPrMark?.kind === "ins" || expectParagraphAttrs(paragraph).pPrMark?.kind === "moveTo",
+		containerStillEndsWithParagraph: false,
+		followingTableCanReceiveRunIn: expectParagraphAttrs(paragraph)._sectionProperties === void 0 && !runInCellPending(next),
+		needsFollowingCommentHost: needsCommentHost && !hasPrecedingCommentHost
+	}).kind === "run-in";
+};
 /**
 * Before every change in a story is resolved: run each paragraph whose mark
 * goes and that sits right before a table on into that table. Returns each
@@ -134,8 +166,11 @@ const runParagraphsIntoTables = (tr, mode, styleResolver) => {
 		let candidate = null;
 		tr.doc.descendants((node, pos, parent, index) => {
 			if (node.type.name !== "paragraph") return !node.isTextblock;
-			const next = parent?.maybeChild(index + 1);
-			if (runsIntoFollowingTable(node, next, mode) && !tried.has(pos)) candidate = pos;
+			if (parent && runsIntoFollowingTable({
+				parent,
+				index,
+				mode
+			}) && !tried.has(pos)) candidate = pos;
 			return false;
 		});
 		if (candidate === null) return {

package/dist/prosemirror/textBoxAnchorAttrs.d.ts

@@ -3,7 +3,6 @@ import { ReadProseMirrorAttrsResult } from "../internal/prosemirrorAttrBoundary.
 import "./attrs/index.js";
 import { Node } from "prosemirror-model";
 //#region src/prosemirror/textBoxAnchorAttrs.d.ts
-declare const readTextBoxAnchorAttrs: (node: Node) => ReadProseMirrorAttrsResult<TextBoxAnchorAttrs>;
-declare const expectTextBoxAnchorAttrs: (node: Node) => TextBoxAnchorAttrs;
-//#endregion
-export { expectTextBoxAnchorAttrs, readTextBoxAnchorAttrs };
+export declare const readTextBoxAnchorAttrs: (node: Node) => ReadProseMirrorAttrsResult<TextBoxAnchorAttrs>;
+export declare const expectTextBoxAnchorAttrs: (node: Node) => TextBoxAnchorAttrs;
+//#endregion

package/dist/prosemirror/textBoxAnchorAttrs.js

@@ -25,7 +25,10 @@ const expectTextBoxAnchorAttrs = (node) => {
 	const cached = attrsCache.get(node);
 	if (cached) return cached;
 	const result = readTextBoxAnchorAttrs(node);
-	if (!result.ok) panic(`Invalid ProseMirror text box anchor attrs:\n${result.issues.map((issue) => `${issue.path}: ${issue.message}`).join("\n")}`);
+	if (!result.ok) {
+		const details = result.issues.map((issue) => `${issue.path}: ${issue.message}`).join("\n");
+		panic(`Invalid ProseMirror text box anchor attrs:\n${details}`);
+	}
 	attrsCache.set(node, result.value);
 	return result.value;
 };

package/dist/prosemirror/textBoxHostCollapse.d.ts

@@ -0,0 +1,8 @@
+import { EditorState } from "prosemirror-state";
+//#region src/prosemirror/textBoxHostCollapse.d.ts
+/**
+ * `state` with every paragraph that hosts only text boxes folded into them,
+ * or `state` itself when there is none.
+ */
+export declare const collapseEmptyTextBoxHosts: (state: EditorState) => EditorState;
+//#endregion

package/dist/prosemirror/textBoxHostCollapse.js

@@ -0,0 +1,79 @@
+import { anchoredTextBoxId, endOfParagraphWithItsTextBoxes, textBoxAnchorIdOf } from "./anchoredTextBoxes.js";
+import { expectTextBoxAttrs } from "./attrs/index.js";
+import { hostParagraphAttrs } from "./conversion/toProseDoc.js";
+import { Fragment } from "prosemirror-model";
+//#region src/prosemirror/textBoxHostCollapse.ts
+/**
+* The projection of a paragraph that holds nothing but text boxes.
+*
+* Opening a package folds such a paragraph into its boxes: the parser keeps
+* the wrapper only when it carries a section break, a property change, a
+* bookmark or an empty hyperlink, and the first box then stands in for it
+* (`_docxPlacement: "standalone"`). A document edited in place can leave a
+* paragraph in that state without having been opened that way, for instance
+* once its text is rejected. Folding it the same way keeps the edited
+* document and the package it saves to one projection, positions included.
+*/
+const carriesValue = (value) => Array.isArray(value) ? value.length > 0 : value !== null && value !== void 0;
+/** Whether `node` is a paragraph of text box anchors that the parser would not keep. */
+const isEmptyTextBoxHost = (node) => {
+	if (node.type.name !== "paragraph" || node.childCount === 0) return false;
+	let onlyAnchors = true;
+	node.forEach((child) => {
+		if (textBoxAnchorIdOf(child) === void 0) onlyAnchors = false;
+	});
+	if (!onlyAnchors) return false;
+	return !(carriesValue(node.attrs["_sectionProperties"]) || carriesValue(node.attrs["_propertyChanges"]) || carriesValue(node.attrs["bookmarks"]) || carriesValue(node.attrs["_emptyHyperlinks"]) || carriesValue(node.attrs["pPrMark"]) || carriesValue(node.attrs["_suggestedInsert"]) || carriesValue(node.attrs["reviewCarrier"]));
+};
+/** The host folded into the boxes drawn in it, or `undefined` when it is not whole. */
+const foldedBoxes = (host, boxes) => {
+	const anchors = /* @__PURE__ */ new Set();
+	host.forEach((child) => {
+		const anchorId = textBoxAnchorIdOf(child);
+		if (anchorId !== void 0) anchors.add(anchorId);
+	});
+	const ids = boxes.map((box) => anchoredTextBoxId(box));
+	if (boxes.length === 0 || ids.some((id) => id === void 0 || !anchors.has(id)) || new Set(ids).size !== anchors.size) return;
+	return boxes.map((box, index) => {
+		const attrs = expectTextBoxAttrs(box);
+		const preserved = host.attrs["_preservedAttributes"];
+		return box.type.create({
+			...box.attrs,
+			_docxPlacement: "standalone",
+			...index === 0 ? {
+				_docxHostParagraph: hostParagraphAttrs(host.attrs),
+				...Array.isArray(preserved) && preserved.length > 0 ? { _preservedAttributes: preserved } : { _preservedAttributes: attrs._preservedAttributes }
+			} : {}
+		}, box.content, box.marks);
+	});
+};
+/**
+* `state` with every paragraph that hosts only text boxes folded into them,
+* or `state` itself when there is none.
+*/
+const collapseEmptyTextBoxHosts = (state) => {
+	const hosts = [];
+	state.doc.descendants((node, position) => {
+		if (!isEmptyTextBoxHost(node)) return !node.isTextblock;
+		const end = endOfParagraphWithItsTextBoxes(state.doc, position);
+		const boxes = [];
+		state.doc.nodesBetween(position + node.nodeSize, end, (child, at) => {
+			if (at >= position + node.nodeSize && child.type.name === "textBox") boxes.push(child);
+			return false;
+		});
+		const folded = foldedBoxes(node, boxes);
+		if (folded) hosts.push({
+			from: position,
+			to: end,
+			boxes: folded
+		});
+		return false;
+	});
+	if (hosts.length === 0) return state;
+	const tr = state.tr;
+	for (const { from, to, boxes } of hosts.toReversed()) tr.replaceWith(from, to, Fragment.fromArray(boxes));
+	tr.setMeta("addToHistory", false);
+	return state.apply(tr);
+};
+//#endregion
+export { collapseEmptyTextBoxHosts };

package/dist/prosemirror/textBoxHostParagraph.d.ts

@@ -8,6 +8,5 @@ import { Node } from "prosemirror-model";
  * Building the node runs the carried attributes through the paragraph schema,
  * so every consumer reads them with the validation any paragraph's get.
  */
-declare const textBoxHostParagraph: (textBox: Node) => Node | undefined;
-//#endregion
-export { textBoxHostParagraph };
+export declare const textBoxHostParagraph: (textBox: Node) => Node | undefined;
+//#endregion

package/dist/prosemirror/textInput.d.ts

@@ -1,3 +1,4 @@
+import { Mark } from "prosemirror-model";
 import { EditorState, Plugin, Transaction } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
 //#region src/prosemirror/textInput.d.ts
@@ -12,19 +13,25 @@ type TextInput = {
   from: number;
   to: number;
 };
-declare const dispatchEditorTextInput: <TView extends TextInputDispatchTarget<TView>>(view: TView, input: string | TextInput) => void;
-declare const getEditorInputTargetRange: (view: EditorView, event: InputEvent) => {
+type FormattingMarksBesideLockedControlOptions = {
+  state: EditorState;
+  from: number;
+  to: number;
+};
+export declare const formattingMarksBesideLockedControl: ({ state, from, to }: FormattingMarksBesideLockedControlOptions) => Mark[] | undefined;
+export declare const dispatchEditorTextInput: <TView extends TextInputDispatchTarget<TView>>(view: TView, input: string | TextInput) => void;
+export declare const getEditorInputTargetRange: (view: EditorView, event: InputEvent) => {
   from: number;
   to: number;
 } | null;
 /** Shared DOM boundary for editor runtimes and standalone suggestion views. */
-declare const handleEditorBeforeInput: (view: EditorView, event: InputEvent) => boolean;
+export declare const handleEditorBeforeInput: (view: EditorView, event: InputEvent) => boolean;
 /**
  * Plugin compositionend handlers run before ProseMirror queues its final DOM
  * flush. A second microtask runs after that flush and sees the committed state.
  */
-declare const afterNativeCompositionFlush: (callback: () => void) => void;
+export declare const afterNativeCompositionFlush: (callback: () => void) => void;
 /** Route committed text through the model before the browser mutates mark spans. */
-declare const createTextInputPlugin: () => Plugin<any>;
+export declare const createTextInputPlugin: () => Plugin;
 //#endregion
-export { afterNativeCompositionFlush, createTextInputPlugin, dispatchEditorTextInput, getEditorInputTargetRange, handleEditorBeforeInput };
+export {};

package/dist/prosemirror/textInput.js

@@ -1,12 +1,36 @@
+import { RUN_FORMATTING_MARK_NAMES } from "./runFormattingMarkNames.js";
 import { AllSelection, Plugin, Selection, TextSelection } from "prosemirror-state";
 //#region src/prosemirror/textInput.ts
+const LOCKED_CONTROL_LOCKS = /* @__PURE__ */ new Set(["contentLocked", "sdtContentLocked"]);
+const isLockedControl = (node) => node?.type.name === "sdt" && LOCKED_CONTROL_LOCKS.has(node.attrs["lock"]);
+const formattingMarksBesideLockedControl = ({ state, from, to }) => {
+	if (from !== to || state.storedMarks !== null) return void 0;
+	const $from = state.doc.resolve(from);
+	const { parent } = $from;
+	if (!parent.isTextblock) return void 0;
+	const before = $from.nodeBefore;
+	const control = [before, $from.nodeAfter].find(isLockedControl);
+	if (!control) return void 0;
+	const afterControl = before === control;
+	const controlIndex = afterControl ? $from.index() - 1 : $from.index();
+	const adjacent = parent.maybeChild(controlIndex + (afterControl ? 1 : -1)) ?? parent.maybeChild(controlIndex + (afterControl ? -1 : 1));
+	if (!adjacent?.isText || adjacent.marks.some((mark) => mark.type.name === "deletion" || mark.type.name === "moveFrom")) return [];
+	return adjacent.marks.filter((mark) => RUN_FORMATTING_MARK_NAMES.has(mark.type.name));
+};
 const dispatchEditorTextInput = (view, input) => {
 	const { from, to } = typeof input === "string" ? view.state.selection : input;
 	const text = typeof input === "string" ? input : input.text;
 	const defaultTransaction = () => {
 		const { selection } = view.state;
 		if (!(selection instanceof AllSelection)) {
-			const tr = view.state.tr.insertText(text, from, to);
+			const formattingMarks = formattingMarksBesideLockedControl({
+				state: view.state,
+				from,
+				to
+			});
+			const tr = view.state.tr;
+			if (formattingMarks !== void 0) tr.setStoredMarks(formattingMarks);
+			tr.insertText(text, from, to);
 			return !selection.empty && selection.from === from && selection.to === to ? tr.setSelection(TextSelection.create(tr.doc, from + text.length)) : tr;
 		}
 		const start = Selection.atStart(view.state.doc);
@@ -78,4 +102,4 @@ const createTextInputPlugin = () => {
 	} } });
 };
 //#endregion
-export { afterNativeCompositionFlush, createTextInputPlugin, dispatchEditorTextInput, getEditorInputTargetRange, handleEditorBeforeInput };
+export { afterNativeCompositionFlush, createTextInputPlugin, dispatchEditorTextInput, formattingMarksBesideLockedControl, getEditorInputTargetRange, handleEditorBeforeInput };

package/dist/prosemirror/trackedRevisionPath.d.ts

@@ -2,9 +2,9 @@ import { InlineWrapperLayer, TrackedRevisionAncestor } from "./schema/marks.js";
 import { Mark, Node } from "prosemirror-model";
 //#region src/prosemirror/trackedRevisionPath.d.ts
 /** The wrappers `node` sits inside, outermost first; empty when it sits in none. */
-declare const inlineWrapperStackOf: (node: Node) => readonly InlineWrapperLayer[];
+export declare const inlineWrapperStackOf: (node: Node) => readonly InlineWrapperLayer[];
 /** One layer of the path used to write and enumerate a tracked run. */
-declare const trackedRevisionLayerOf: (mark: Mark, node: Node) => TrackedRevisionAncestor;
+export declare const trackedRevisionLayerOf: (mark: Mark, node: Node) => TrackedRevisionAncestor;
 type EnclosingInsertionAncestorsOptions = {
   /** The insertion a deletion mark shares its text with, if any. */
   insertionMark: Mark | undefined;
@@ -12,10 +12,10 @@ type EnclosingInsertionAncestorsOptions = {
   node: Node;
 };
 /** The deletion's ancestor path, with the insertion it sits in as the outermost layer. */
-declare const enclosingInsertionAncestors: ({ insertionMark, ancestors, node }: EnclosingInsertionAncestorsOptions) => readonly TrackedRevisionAncestor[];
+export declare const enclosingInsertionAncestors: ({ insertionMark, ancestors, node }: EnclosingInsertionAncestorsOptions) => readonly TrackedRevisionAncestor[];
 /** The authored revision layers already owned by a mark, outermost first. */
-declare const trackedRevisionPathOf: (mark: Mark) => readonly TrackedRevisionAncestor[];
+export declare const trackedRevisionPathOf: (mark: Mark) => readonly TrackedRevisionAncestor[];
 /** Promote a surviving existing layer; callers cannot supply a fresh identity. */
-declare const retainedTrackedRevisionMark: (mark: Mark, keepLayer: (layer: TrackedRevisionAncestor) => boolean) => Mark | null;
+export declare const retainedTrackedRevisionMark: (mark: Mark, keepLayer: (layer: TrackedRevisionAncestor) => boolean) => Mark | null;
 //#endregion
-export { enclosingInsertionAncestors, inlineWrapperStackOf, retainedTrackedRevisionMark, trackedRevisionLayerOf, trackedRevisionPathOf };
+export {};

package/dist/prosemirror/trackedRevisionPath.js

@@ -26,9 +26,9 @@ const trackedRevisionLayerOf = (mark, node) => {
 /** The deletion's ancestor path, with the insertion it sits in as the outermost layer. */
 const enclosingInsertionAncestors = ({ insertionMark, ancestors, node }) => {
 	if (!insertionMark) return ancestors;
-	const attrs = expectTrackedChangeMarkAttrs(insertionMark);
-	if (ancestors.some(({ revisionId }) => revisionId === attrs.revisionId)) return ancestors;
-	return [trackedRevisionLayerOf(insertionMark, node), ...ancestors];
+	const layer = trackedRevisionLayerOf(insertionMark, node);
+	if (ancestors.some(({ revisionId, type }) => revisionId === layer.revisionId && type === layer.type)) return ancestors;
+	return [layer, ...ancestors];
 };
 const revisionLayerOf = (mark) => {
 	const attrs = expectTrackedChangeMarkAttrs(mark);
@@ -55,6 +55,8 @@ const retainedTrackedRevisionMark = (mark, keepLayer) => {
 	const name = active.type === "insertion" || active.type === "moveTo" ? "insertion" : "deletion";
 	const type = mark.type.schema.marks[name];
 	if (!type) panic("A nested tracked revision has no editor mark type");
+	const attrs = expectTrackedChangeMarkAttrs(mark);
+	const commentRangeBoundaries = attrs._docxCommentRangeBoundaries?.map((boundary) => Object.assign({}, boundary, { owner: boundary.owner === "revision" && active.revisionId !== attrs.revisionId ? "parent" : boundary.owner }));
 	return type.create({
 		revisionId: active.revisionId,
 		author: active.author,
@@ -64,7 +66,8 @@ const retainedTrackedRevisionMark = (mark, keepLayer) => {
 		moveKind: active.type === "moveTo" || active.type === "moveFrom" ? active.type : null,
 		_historicalFormatting: active.type === "deletion" || active.type === "moveFrom" ? true : null,
 		_docxOuterWrapperCount: active.outerWrapperCount,
-		_docxRevisionAncestors: remaining.length > 1 ? remaining.slice(0, -1) : null
+		_docxRevisionAncestors: remaining.length > 1 ? remaining.slice(0, -1) : null,
+		_docxCommentRangeBoundaries: commentRangeBoundaries && commentRangeBoundaries.length > 0 ? commentRangeBoundaries : void 0
 	});
 };
 //#endregion

package/dist/prosemirror/trackedRunInlineAtoms.d.ts

@@ -1,6 +1,6 @@
 import { Node } from "prosemirror-model";
 //#region src/prosemirror/trackedRunInlineAtoms.d.ts
-type TrackedRunInlineAtomDisposition = "carry" | "field-carrier" | "outside-wrapper" | "page-break-carrier" | "text-carrier" | "transparent";
+export type TrackedRunInlineAtomDisposition = "carry" | "field-carrier" | "outside-wrapper" | "page-break-carrier" | "text-carrier" | "transparent";
 /**
  * How every inline atom in the editor schema participates in an OOXML
  * run-level tracked-change wrapper.
@@ -9,9 +9,10 @@ type TrackedRunInlineAtomDisposition = "carry" | "field-carrier" | "outside-wrap
  * to its complete inline-atom set. The lookup also panics on a missing entry:
  * a new atom cannot silently lose revision ownership before that test runs.
  */
-declare const TRACKED_RUN_INLINE_ATOM_DISPOSITIONS: Readonly<{
+export declare const TRACKED_RUN_INLINE_ATOM_DISPOSITIONS: Readonly<{
   readonly bookmarkBoundary: "carry";
-  readonly commentReference: "transparent";
+  readonly commentReference: "carry";
+  readonly commentRangeBoundary: "carry";
   readonly field: "field-carrier";
   readonly hardBreak: "carry";
   readonly image: "carry";
@@ -20,7 +21,7 @@ declare const TRACKED_RUN_INLINE_ATOM_DISPOSITIONS: Readonly<{
   readonly noteMarker: "carry";
   readonly pageBreakRun: "page-break-carrier";
   readonly preservedXml: "carry";
-  readonly rangeAnchor: "transparent";
+  readonly rangeAnchor: "carry";
   readonly renderedPageBreak: "carry";
   readonly shape: "carry";
   readonly structuredField: "carry";
@@ -29,8 +30,7 @@ declare const TRACKED_RUN_INLINE_ATOM_DISPOSITIONS: Readonly<{
   readonly text: "text-carrier";
   readonly textBoxAnchor: "carry";
 }>;
-declare const trackedRunInlineAtomDisposition: (node: Node) => TrackedRunInlineAtomDisposition | null;
+export declare const trackedRunInlineAtomDisposition: (node: Node) => TrackedRunInlineAtomDisposition | null;
 /** Whether an editor node can own an insertion/deletion mark as one run carrier. */
-declare const canCarryTrackedRunMark: (node: Node) => boolean;
-//#endregion
-export { TRACKED_RUN_INLINE_ATOM_DISPOSITIONS, TrackedRunInlineAtomDisposition, canCarryTrackedRunMark, trackedRunInlineAtomDisposition };
+export declare const canCarryTrackedRunMark: (node: Node) => boolean;
+//#endregion

package/dist/prosemirror/trackedRunInlineAtoms.js

@@ -10,7 +10,8 @@ import { panic } from "better-result";
 */
 const TRACKED_RUN_INLINE_ATOM_DISPOSITIONS = Object.freeze({
 	bookmarkBoundary: "carry",
-	commentReference: "transparent",
+	commentReference: "carry",
+	commentRangeBoundary: "carry",
 	field: "field-carrier",
 	hardBreak: "carry",
 	image: "carry",
@@ -19,7 +20,7 @@ const TRACKED_RUN_INLINE_ATOM_DISPOSITIONS = Object.freeze({
 	noteMarker: "carry",
 	pageBreakRun: "page-break-carrier",
 	preservedXml: "carry",
-	rangeAnchor: "transparent",
+	rangeAnchor: "carry",
 	renderedPageBreak: "carry",
 	shape: "carry",
 	structuredField: "carry",