@stll/folio-core 0.66.0 → 0.66.2

package/dist/prosemirror/paragraphPropertyCarry.js

@@ -18,8 +18,6 @@ import { panic } from "better-result";
 * revision, so accepting reads as the direct edit and rejecting restores the
 * second's own.
 */
-/** The exact formatting transfer, shared with pre-mutation capacity checks. */
-const carriedParagraphProperties = ({ source, target, keep }) => Object.fromEntries([...Object.entries(paragraphPropertiesSnapshot(source)).filter(([key]) => !keep?.has(key)), ...Object.entries(paragraphPropertiesSnapshot(target)).filter(([key]) => keep?.has(key))]);
 /**
 * Give a paragraph another one's properties: the pPr a property change
 * covers. Its identity, mark, mark run properties and section stay its own,
@@ -27,7 +25,7 @@ const carriedParagraphProperties = ({ source, target, keep }) => Object.fromEntr
 * change now records what it had: a paragraph holds one, and a pending one
 * already records it.
 */
-const carryParagraphProperties = ({ tr, position, source, styleResolver, numbering, revision, keep }) => {
+const carryParagraphProperties = ({ tr, position, source, styleResolver, numbering, revision }) => {
 	const target = tr.doc.nodeAt(position);
 	if (!target || target.type !== source.type) return {
 		tr,
@@ -35,11 +33,7 @@ const carryParagraphProperties = ({ tr, position, source, styleResolver, numberi
 		tracked: false
 	};
 	const previousFormatting = paragraphPropertiesSnapshot(target);
-	const formatting = carriedParagraphProperties({
-		source,
-		target,
-		...keep === void 0 ? {} : { keep }
-	});
+	const formatting = paragraphPropertiesSnapshot(source);
 	if (JSON.stringify(previousFormatting) === JSON.stringify(formatting)) return {
 		tr,
 		changed: false,
@@ -74,7 +68,7 @@ const carryParagraphProperties = ({ tr, position, source, styleResolver, numberi
 	}] : []];
 	tr.setNodeMarkup(position, void 0, {
 		...carried,
-		...carriedNumberingProvenance(source, target, keep),
+		numPrFromStyle: expectParagraphAttrs(source).numPrFromStyle,
 		_sectionProperties: target.attrs["_sectionProperties"],
 		_propertyChanges: changes.length > 0 ? changes : null
 	});
@@ -91,12 +85,6 @@ const carryParagraphProperties = ({ tr, position, source, styleResolver, numberi
 	};
 };
 /**
-* Whether the carried numbering is the paragraph's own or its style's: the
-* record holds only stated numbering, and a style's numbering
-* stays the style's rather than becoming the paragraph's own `w:numPr`.
-*/
-const carriedNumberingProvenance = (source, target, keep) => ({ numPrFromStyle: expectParagraphAttrs(keep?.has("numPr") ? target : source).numPrFromStyle });
-/**
 * The paragraph left once the break of the paragraph at `paragraphPos` goes:
 * the next one, or, when its own break is pending deletion too, the first
 * paragraph after it whose break stays. Null when no paragraph follows.
@@ -143,16 +131,4 @@ const recordReplacedParagraphProperties = ({ tr, position, replaced, revision })
 	}]);
 	return true;
 };
-/**
-* The properties a batch's own property change set on a paragraph: the ones
-* whose value differs from what that change records as before.
-*/
-const propertiesSetInBatch = (node, batchRevisionIds) => {
-	const changes = expectParagraphAttrs(node)._propertyChanges;
-	const change = Array.isArray(changes) ? changes.find(({ info }) => batchRevisionIds.has(info.id)) : void 0;
-	if (change === void 0) return /* @__PURE__ */ new Set();
-	const before = change.previousFormatting ?? {};
-	const now = paragraphPropertiesSnapshot(node);
-	return new Set([.../* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(now)])].filter((key) => JSON.stringify(before[key]) !== JSON.stringify(now[key])));
-};
-export { carriedParagraphProperties, carryParagraphProperties, paragraphLeftAfter, propertiesSetInBatch, recordReplacedParagraphProperties };
+export { carryParagraphProperties, paragraphLeftAfter, recordReplacedParagraphProperties };

package/dist/prosemirror/plugins/suggestionMode.js

@@ -531,6 +531,17 @@ function applySuggestionInsert(view, from, to, text, pluginState) {
 	if (selectsAll) {
 		from = Math.max(from, Selection.atStart(view.state.doc).from);
 		to = Math.min(to, Selection.atEnd(view.state.doc).to);
+	} else if (typesOverSelection && selection instanceof CellSelection) {
+		const cellDeletion = view.state.schema.marks["deletion"];
+		if (cellDeletion) {
+			const ranges = selection.ranges.toSorted((a, b) => b.$from.pos - a.$from.pos);
+			for (const range of ranges) markRangeAsDeleted(tr, view.state.doc, range.$from.pos, range.$to.pos, cellDeletion, pluginState, view.state);
+		}
+		const last = Selection.findFrom(view.state.doc.resolve(to), -1, true);
+		if (last && last.to >= from) {
+			from = last.to;
+			to = last.to;
+		}
 	}
 	const replacedFormatting = selectsAll ? (view.state.doc.resolve(from).nodeAfter?.marks ?? []).filter(({ type }) => RUN_FORMATTING_MARK_NAMES.has(type.name)) : null;
 	const insertAttrs = findAdjacentRevision(view.state.doc, from, "insertion", pluginState.author) || makeMarkAttrs(pluginState);
@@ -545,16 +556,18 @@ function applySuggestionInsert(view, from, to, text, pluginState) {
 		to
 	});
 	if (formattingMarks !== void 0) tr.setStoredMarks(formattingMarks);
+	const typedFrom = tr.doc.resolve(insertAt).parent.inlineContent ? insertAt : insertAt + 1;
+	const typedTo = typedFrom + text.length;
 	tr.insertText(text, insertAt, insertAt);
 	const deletionType = view.state.schema.marks["deletion"];
-	if (deletionType) tr.removeMark(insertAt, insertAt + text.length, deletionType);
-	tr.addMark(insertAt, insertAt + text.length, insertionType.create(insertAttrs));
+	if (deletionType) tr.removeMark(typedFrom, typedTo, deletionType);
+	tr.addMark(typedFrom, typedTo, insertionType.create(insertAttrs));
 	if (replacedFormatting) {
-		for (const mark of tr.doc.resolve(insertAt).nodeAfter?.marks ?? []) if (RUN_FORMATTING_MARK_NAMES.has(mark.type.name)) tr.removeMark(insertAt, insertAt + text.length, mark.type);
-		for (const mark of replacedFormatting) tr.addMark(insertAt, insertAt + text.length, mark);
+		for (const mark of tr.doc.resolve(typedFrom).nodeAfter?.marks ?? []) if (RUN_FORMATTING_MARK_NAMES.has(mark.type.name)) tr.removeMark(typedFrom, typedTo, mark.type);
+		for (const mark of replacedFormatting) tr.addMark(typedFrom, typedTo, mark);
 	}
-	separateSplitStretch(tr, insertAt, insertAt + text.length, insertAttrs.revisionId);
-	if (typesOverSelection) tr.setSelection(TextSelection.create(tr.doc, insertAt + text.length));
+	separateSplitStretch(tr, typedFrom, typedTo, insertAttrs.revisionId);
+	if (typesOverSelection) tr.setSelection(TextSelection.create(tr.doc, typedTo));
 	view.dispatch(tr.scrollIntoView());
 	return true;
 }

package/dist/prosemirror/replacedAnnotations.d.ts

@@ -12,6 +12,7 @@ export declare const NON_INCLUSIVE_MARK_DISPOSITION: {
   readonly hyperlink: "carry";
   readonly footnoteRef: "followsTheText";
   readonly runIdentity: "followsTheText";
+  readonly hyphenElement: "followsTheText";
   readonly insertion: "followsTheText";
   readonly deletion: "followsTheText";
   readonly runPropertyChange: "followsTheText";

package/dist/prosemirror/replacedAnnotations.js

@@ -84,6 +84,7 @@ const NON_INCLUSIVE_MARK_DISPOSITION = {
 	hyperlink: "carry",
 	footnoteRef: "followsTheText",
 	runIdentity: "followsTheText",
+	hyphenElement: "followsTheText",
 	insertion: "followsTheText",
 	deletion: "followsTheText",
 	runPropertyChange: "followsTheText",

package/dist/prosemirror/sectionCarrier.d.ts

@@ -14,6 +14,14 @@ export type SectionBreakType = (typeof SECTION_BREAK_TYPES)[number];
 export declare const parseSectionBreakType: (value: unknown) => SectionBreakType | null;
 /** The section record a paragraph holds, or `null` when it ends no section. */
 export declare const sectionPropertiesOf: (paragraph: Node) => document_d_exports.SectionProperties | null;
+/**
+ * The positions of paragraphs that hold only a copy of a section record: every
+ * carrier of a record but its last. The from-leg writes the record on the last
+ * carrier alone (`keepTheSectionBreakOnTheLastParagraphThatCarriesIt`), so a
+ * resolution that lets the last carrier's mark go must not leave a copy to
+ * inherit the section a saved package no longer has.
+ */
+export declare const sectionRecordCopyPositions: (doc: Node) => number[];
 /**
  * The break type a section record states, or `null` when it states none.
  *

package/dist/prosemirror/sectionCarrier.js

@@ -19,6 +19,34 @@ const parseSectionBreakType = (value) => isSectionBreakType(value) ? value : nul
 /** The section record a paragraph holds, or `null` when it ends no section. */
 const sectionPropertiesOf = (paragraph) => paragraph.attrs["_sectionProperties"] ?? null;
 /**
+* The positions of paragraphs that hold only a copy of a section record: every
+* carrier of a record but its last. The from-leg writes the record on the last
+* carrier alone (`keepTheSectionBreakOnTheLastParagraphThatCarriesIt`), so a
+* resolution that lets the last carrier's mark go must not leave a copy to
+* inherit the section a saved package no longer has.
+*/
+const sectionRecordCopyPositions = (doc) => {
+	const lastCarrier = /* @__PURE__ */ new Map();
+	const copies = [];
+	const visit = (parent, parentStart) => {
+		parent.forEach((node, offset) => {
+			const position = parentStart + offset;
+			if (!node.isTextblock) {
+				if (!node.isLeaf) visit(node, position + 1);
+				return;
+			}
+			if (node.type.name !== "paragraph") return;
+			const record = sectionPropertiesOf(node);
+			if (record === null) return;
+			const earlier = lastCarrier.get(record);
+			if (earlier !== void 0) copies.push(earlier);
+			lastCarrier.set(record, position);
+		});
+	};
+	visit(doc, 0);
+	return copies;
+};
+/**
 * The break type a section record states, or `null` when it states none.
 *
 * The single derivation every reader goes through. Every producer of a record
@@ -36,4 +64,4 @@ const sectionBreakTypeOf = (properties) => properties?.sectionStart ?? null;
 * package does with a `w:sectPr` that omits them.
 */
 const mintSectionProperties = (breakType) => ({ sectionStart: breakType });
-export { SECTION_BREAK_TYPES, mintSectionProperties, parseSectionBreakType, sectionBreakTypeOf, sectionPropertiesOf };
+export { SECTION_BREAK_TYPES, mintSectionProperties, parseSectionBreakType, sectionBreakTypeOf, sectionPropertiesOf, sectionRecordCopyPositions };

package/dist/prosemirror/styles/paragraphStyleCascade.d.ts

@@ -13,6 +13,16 @@ export type ParagraphCascadeResolver = Pick<StyleEngine, "getStyle" | "getDocDef
  */
 type ParagraphDefaultFormattingResolver = Pick<StyleEngine, "getStyle" | "getDocDefaults" | "getDefaultParagraphStyle" | "getDefaultCharacterStyle" | "getRunStyleOwnProperties">;
 export declare function resolveRunFormattingWithoutDefaults(formatting: document_d_exports.TextFormatting | undefined, styleResolver: ParagraphDefaultFormattingResolver | null): document_d_exports.TextFormatting | undefined;
+/**
+ * What a paragraph's mark lends its body runs: nothing when the paragraph has a
+ * style, and never the font or the mark-only decorations. One rule for a
+ * document read and for a paragraph whose properties a review restores.
+ */
+export declare const inheritableParagraphMarkFormatting: ({ runProperties, styleId, styleResolver }: {
+  runProperties: document_d_exports.TextFormatting | undefined;
+  styleId: string | undefined;
+  styleResolver: Parameters<typeof resolveRunFormattingWithoutDefaults>[1];
+}) => document_d_exports.TextFormatting | undefined;
 /** @internal Recompute a paragraph's inherited run defaults from authored package state. */
 export declare function resolveParagraphDefaultTextFormatting(styleId: string | undefined, formatting: document_d_exports.Paragraph["formatting"] | undefined, styleResolver: ParagraphDefaultFormattingResolver, options?: {
   includeParagraphMarkRunProperties?: boolean;

package/dist/prosemirror/styles/paragraphStyleCascade.js

@@ -5,7 +5,7 @@ import { paragraphNumberingAttr } from "../numberingAttr.js";
 import { directionFromBidi } from "../paragraphDirection.js";
 import { styleResolvedParagraphFormatting } from "../paragraphFormattingProvenance.js";
 import { lineSpacingProvenanceFromSpacing } from "../paragraphSpacing.js";
-import { stripParagraphMarkOnlyFormatting } from "../runStyleFormatting.js";
+import { stripParagraphMarkFormattingForBodyRuns, stripParagraphMarkOnlyFormatting } from "../runStyleFormatting.js";
 import { cascadeStyleTextFormatting } from "./styleToggleCascade.js";
 // src/prosemirror/styles/paragraphStyleCascade.ts
 /**
@@ -30,6 +30,16 @@ function resolveRunFormattingWithoutDefaults(formatting, styleResolver) {
 		type: "direct"
 	}]).formatting;
 }
+/**
+* What a paragraph's mark lends its body runs: nothing when the paragraph has a
+* style, and never the font or the mark-only decorations. One rule for a
+* document read and for a paragraph whose properties a review restores.
+*/
+const inheritableParagraphMarkFormatting = ({ runProperties, styleId, styleResolver }) => {
+	if (styleId !== void 0) return void 0;
+	const formatting = resolveRunFormattingWithoutDefaults(runProperties, styleResolver);
+	return formatting ? stripParagraphMarkFormattingForBodyRuns(formatting) : void 0;
+};
 /** @internal Recompute a paragraph's inherited run defaults from authored package state. */
 function resolveParagraphDefaultTextFormatting(styleId, formatting, styleResolver, options = {}) {
 	const style = styleId ? styleResolver.getStyle(styleId) ?? styleResolver.getDefaultParagraphStyle() : styleResolver.getDefaultParagraphStyle();
@@ -155,4 +165,4 @@ function tableCellParagraphOverlay(styleResolver, tableStyleId, regions) {
 	}
 	return overlay;
 }
-export { extractTableParagraphOverlay, paragraphStyleCascadeAttrs, resolveParagraphDefaultTextFormatting, resolveRunFormattingWithoutDefaults, tableCellParagraphOverlay };
+export { extractTableParagraphOverlay, inheritableParagraphMarkFormatting, paragraphStyleCascadeAttrs, resolveParagraphDefaultTextFormatting, resolveRunFormattingWithoutDefaults, tableCellParagraphOverlay };

package/dist/prosemirror/tableRunIn.d.ts

@@ -1,20 +1,26 @@
 import { RunStyleResolver } from "./runStyleFormatting.js";
 import { ParagraphPropertySourceTransfer } from "../docx/paragraphPropertySource.js";
-import { MarkType, Node } from "prosemirror-model";
+import { Node } from "prosemirror-model";
 import { StepMap, Transform } from "prosemirror-transform";
+type ResolutionMode = "accept" | "reject";
 /**
  * Whether the cell a paragraph's words would run into is itself pending: its
  * row or the cell (through nested tables' first cells) is inserted, deleted
- * or merged, so resolving may not keep it. Pending rows or cells elsewhere in
- * the table leave that cell where it is.
+ * or merged, so resolving may not keep it. A deletion is not pending for a
+ * rejection of every change. Pending rows or cells elsewhere in the table leave
+ * that cell where it is.
  */
-export declare const runInCellPending: (table: Node) => boolean;
+export declare const runInCellPending: (table: Node, everyChange?: ResolutionMode) => boolean;
 type RunParagraphIntoTableOptions = {
   tr: Transform;
   paragraphPos: number;
   styleResolver: RunStyleResolver | null;
-  /** Content a resolution in progress removes: it does not count as words left. */
-  removedMark?: MarkType | undefined;
+  /**
+   * Set when every change of the story resolves this way, not only some: what
+   * it removes does not count as words left, and a rejection takes a deleted
+   * row as staying.
+   */
+  everyChange?: ResolutionMode | undefined;
 };
 /**
  * Run the paragraph at `paragraphPos` on into the table right after it.
@@ -22,7 +28,7 @@ type RunParagraphIntoTableOptions = {
  * paragraph-property source it hands over, or null when it did not run in and
  * the caller keeps its own handling.
  */
-export declare const runParagraphIntoTable: ({ tr, paragraphPos, styleResolver, removedMark }: RunParagraphIntoTableOptions) => {
+export declare const runParagraphIntoTable: ({ tr, paragraphPos, styleResolver, everyChange }: RunParagraphIntoTableOptions) => {
   position: number;
   map: StepMap;
   transfer: ParagraphPropertySourceTransfer;
@@ -34,8 +40,17 @@ export declare const runParagraphIntoTable: ({ tr, paragraphPos, styleResolver,
 type RunsIntoFollowingTableOptions = {
   parent: Node;
   index: number;
-  mode: "accept" | "reject";
+  mode: ResolutionMode;
 };
+/**
+ * Whether what stands right after a paragraph whose mark goes is itself removed
+ * by this resolution, so the paragraph runs on into what stands after that, as
+ * it would had the removed block never been there: a table it removes, or, when
+ * rejecting, an inserted paragraph it empties with a table after it. (Accepted,
+ * a deleted paragraph did stand there, and the join ended at it. Paragraphs join
+ * among themselves without help.)
+ */
+export declare const paragraphBeforeRemovedBlock: ({ parent, index, mode }: RunsIntoFollowingTableOptions) => boolean;
 export declare const runsIntoFollowingTable: ({ parent, index, mode }: RunsIntoFollowingTableOptions) => boolean;
 /**
  * Before every change in a story is resolved: run each paragraph whose mark
@@ -43,7 +58,7 @@ export declare const runsIntoFollowingTable: ({ parent, index, mode }: RunsIntoF
  * paragraph that took words (its position after the step count given) and
  * the paragraph-property sources handed over.
  */
-export declare const runParagraphsIntoTables: (tr: Transform, mode: "accept" | "reject", styleResolver: RunStyleResolver | null) => {
+export declare const runParagraphsIntoTables: (tr: Transform, mode: ResolutionMode, styleResolver: RunStyleResolver | null) => {
   targets: {
     position: number;
     step: number;

package/dist/prosemirror/tableRunIn.js

@@ -1,11 +1,12 @@
 import { getProseParagraphPropertySourceToken, recreateProseNodeWithParagraphPropertySource } from "../docx/paragraphPropertySource.js";
 import { expectParagraphAttrs } from "./attrs/index.js";
-import { paragraphRemainsOf } from "./keptRangeBoundaries.js";
+import { REVISION_MARK_NAMES, paragraphRemainsOf, revisionLayerRemovesContent } from "./keptRangeBoundaries.js";
 import { rebaseParagraphRuns } from "./rebaseParagraphRunFormatting.js";
 import { paragraphRunStyleContext } from "./runStyleFormatting.js";
+import { trackedRevisionPathOf } from "./trackedRevisionPath.js";
 import { paragraphContentOf } from "./zeroWidthAnchors.js";
 import { Fragment, Slice } from "prosemirror-model";
-import { ReplaceAroundStep, StepMap } from "prosemirror-transform";
+import { ReplaceAroundStep, ReplaceStep, StepMap } from "prosemirror-transform";
 import { paragraphMarkOutcome } from "@stll/docx-core/ops";
 // src/prosemirror/tableRunIn.ts
 /**
@@ -19,35 +20,53 @@ import { paragraphMarkOutcome } from "@stll/docx-core/ops";
 *
 * A paragraph with nothing left to carry is simply removed by the resolvers;
 * one that ends a section keeps its place, as does one before a table whose
-* rows or cells are themselves pending.
+* first row or cell may not stay. Rejecting every change gives the document
+* before back, so a deleted row stays for it. A table that resolving every
+* change removes never stood in the way: the paragraph runs on into what follows
+* that table.
 */
 /**
 * Whether the cell a paragraph's words would run into is itself pending: its
 * row or the cell (through nested tables' first cells) is inserted, deleted
-* or merged, so resolving may not keep it. Pending rows or cells elsewhere in
-* the table leave that cell where it is.
+* or merged, so resolving may not keep it. A deletion is not pending for a
+* rejection of every change. Pending rows or cells elsewhere in the table leave
+* that cell where it is.
 */
-const runInCellPending = (table) => {
+const runInCellPending = (table, everyChange) => {
+	const deletionStays = everyChange === "reject";
 	let node = table;
 	while (node?.type.spec["tableRole"] === "table") {
 		const row = node.firstChild;
 		if (!row) return false;
-		if (row.attrs["trIns"] != null || row.attrs["trDel"] != null) return true;
+		if (row.attrs["trIns"] != null) return true;
+		if (row.attrs["trDel"] != null && !deletionStays) return true;
 		const cell = row.firstChild;
 		if (!cell) return false;
-		if (cell.attrs["cellMarker"] != null) return true;
+		const marker = cell.attrs["cellMarker"];
+		if (marker != null && !(deletionStays && marker.kind === "del")) return true;
 		node = cell.firstChild;
 	}
 	return false;
 };
+/**
+* Whether resolving every change takes this row out with what it records. The
+* table it stands in goes when all its rows do.
+*/
+const rowGoes = (row, mode) => row.attrs[mode === "accept" ? "trDel" : "trIns"] != null;
+/** Whether resolving every change in `mode` removes the whole table. */
+const tableGoes = (table, mode) => {
+	if (table.type.spec["tableRole"] !== "table" || table.childCount === 0) return false;
+	for (let index = 0; index < table.childCount; index++) if (!rowGoes(table.child(index), mode)) return false;
+	return true;
+};
 /** The first paragraph of a table's first cell, descending into nested tables. */
-const runInTarget = (doc, tablePos) => {
+const runInTarget = (doc, tablePos, everyChange) => {
 	let node = doc.nodeAt(tablePos);
 	let pos = tablePos;
 	const table = node;
 	const firstRow = table?.firstChild;
 	if (!table || table.type.spec["tableRole"] !== "table" || !firstRow) return null;
-	if (runInCellPending(table)) return null;
+	if (runInCellPending(table, everyChange)) return null;
 	while (node && node.type.name !== "paragraph") {
 		const child = node.firstChild;
 		if (!child || child.isInline) return null;
@@ -59,22 +78,22 @@ const runInTarget = (doc, tablePos) => {
 		node
 	} : null;
 };
-const paragraphAfterContentRemoval = (paragraph, removedMark) => removedMark ? paragraph.copy(Fragment.fromArray(paragraph.children.filter((child) => !removedMark.isInSet(child.marks)))) : paragraph;
+const paragraphAfterContentRemoval = (paragraph, everyChange) => everyChange ? paragraph.copy(Fragment.fromArray(paragraph.children.filter((child) => !child.marks.some((mark) => REVISION_MARK_NAMES.has(mark.type.name) && trackedRevisionPathOf(mark).some((layer) => revisionLayerRemovesContent(layer, everyChange)))))) : 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
 * paragraph-property source it hands over, or null when it did not run in and
 * the caller keeps its own handling.
 */
-const runParagraphIntoTable = ({ tr, paragraphPos, styleResolver, removedMark }) => {
+const runParagraphIntoTable = ({ tr, paragraphPos, styleResolver, everyChange }) => {
 	const paragraph = tr.doc.nodeAt(paragraphPos);
 	if (paragraph?.type.name !== "paragraph") return null;
 	if (expectParagraphAttrs(paragraph)._sectionProperties !== void 0) return null;
-	const left = paragraphAfterContentRemoval(paragraph, removedMark);
+	const left = paragraphAfterContentRemoval(paragraph, everyChange);
 	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);
+	const target = runInTarget(tr.doc, tablePos, everyChange);
 	if (!target) return null;
 	const $target = tr.doc.resolve(target.pos + 1);
 	const containerDepth = tr.doc.resolve(paragraphPos).depth;
@@ -118,6 +137,36 @@ const markGoes = (paragraph, mode) => {
 	if (!mark) return false;
 	return (mark.kind === "ins" || mark.kind === "moveTo") !== (mode === "accept");
 };
+/** Whether resolving every change in `mode` leaves nothing of this paragraph. */
+const paragraphGoes = (paragraph, mode) => {
+	if (paragraph.type.name !== "paragraph" || !markGoes(paragraph, mode) || expectParagraphAttrs(paragraph)._sectionProperties != null) return false;
+	const left = paragraphAfterContentRemoval(paragraph, mode);
+	if (paragraphContentOf(left)) return false;
+	const remains = paragraphRemainsOf(left);
+	return remains.blocks.length === 0 && remains.comments.length === 0 && remains.inline.length === 0;
+};
+/**
+* Whether what stands right after a paragraph whose mark goes is itself removed
+* by this resolution, so the paragraph runs on into what stands after that, as
+* it would had the removed block never been there: a table it removes, or, when
+* rejecting, an inserted paragraph it empties with a table after it. (Accepted,
+* a deleted paragraph did stand there, and the join ended at it. Paragraphs join
+* among themselves without help.)
+*/
+const paragraphBeforeRemovedBlock = ({ parent, index, mode }) => {
+	const paragraph = parent.child(index);
+	const next = parent.maybeChild(index + 1);
+	if (paragraph.type.name !== "paragraph" || !next || !markGoes(paragraph, mode)) return false;
+	if (tableGoes(next, mode)) return true;
+	if (mode !== "reject" || paragraphGoes(paragraph, mode)) return false;
+	let following = index + 1;
+	while (following < parent.childCount) {
+		const block = parent.child(following);
+		if (!paragraphGoes(block, mode)) break;
+		following += 1;
+	}
+	return following > index + 1 && parent.maybeChild(following)?.type.spec["tableRole"] === "table";
+};
 const runsIntoFollowingTable = ({ parent, index, mode }) => {
 	const paragraph = parent.child(index);
 	const next = parent.maybeChild(index + 1);
@@ -125,7 +174,6 @@ const runsIntoFollowingTable = ({ parent, index, mode }) => {
 	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);
@@ -134,7 +182,7 @@ const runsIntoFollowingTable = ({ parent, index, mode }) => {
 			hasPrecedingCommentHost = true;
 			break;
 		}
-		const retained = paragraphAfterContentRemoval(previous, removedMark);
+		const retained = paragraphAfterContentRemoval(previous, mode);
 		if (paragraphContentOf(retained)) break;
 		if (paragraphRemainsOf(retained).blocks.length > 0) {
 			hasPrecedingCommentHost = true;
@@ -146,22 +194,60 @@ const runsIntoFollowingTable = ({ parent, index, mode }) => {
 		holdsContent,
 		markWasAdded: expectParagraphAttrs(paragraph).pPrMark?.kind === "ins" || expectParagraphAttrs(paragraph).pPrMark?.kind === "moveTo",
 		containerStillEndsWithParagraph: false,
-		followingTableCanReceiveRunIn: expectParagraphAttrs(paragraph)._sectionProperties === void 0 && !runInCellPending(next),
+		followingTableCanReceiveRunIn: expectParagraphAttrs(paragraph)._sectionProperties === void 0 && !runInCellPending(next, mode),
 		needsFollowingCommentHost: needsCommentHost && !hasPrecedingCommentHost
 	}).kind === "run-in";
 };
 /**
+* Stand each block this resolution removes before the paragraph whose mark goes
+* right before it, so that paragraph meets what it will run on into. The block
+* is going, so where it goes from does not show; the paragraph's words keep
+* mapping to themselves.
+*/
+const moveRemovedBlocksBeforeParagraphs = (tr, mode) => {
+	const maps = [];
+	for (;;) {
+		let move = null;
+		tr.doc.descendants((node, position, parent, index) => {
+			if (move !== null) return false;
+			if (node.type.name !== "paragraph") return !node.isTextblock;
+			const block = parent?.maybeChild(index + 1);
+			if (parent && block && paragraphBeforeRemovedBlock({
+				parent,
+				index,
+				mode
+			})) move = {
+				position,
+				paragraph: node,
+				block
+			};
+			return false;
+		});
+		if (move === null) return maps;
+		const { position, paragraph, block } = move;
+		const blockPosition = position + paragraph.nodeSize;
+		tr.step(new ReplaceStep(position, blockPosition + block.nodeSize, new Slice(Fragment.fromArray([block, paragraph]), 0, 0)));
+		maps.push(new StepMap([
+			position,
+			0,
+			block.nodeSize,
+			blockPosition,
+			block.nodeSize,
+			0
+		]));
+	}
+};
+/**
 * 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.
 */
 const runParagraphsIntoTables = (tr, mode, styleResolver) => {
-	const removedMark = tr.doc.type.schema.marks[mode === "accept" ? "deletion" : "insertion"];
 	const tried = /* @__PURE__ */ new Set();
 	const targets = [];
 	const transfers = [];
-	const maps = [];
+	const maps = moveRemovedBlocksBeforeParagraphs(tr, mode);
 	for (;;) {
 		let candidate = null;
 		tr.doc.descendants((node, pos, parent, index) => {
@@ -183,7 +269,7 @@ const runParagraphsIntoTables = (tr, mode, styleResolver) => {
 			tr,
 			paragraphPos: candidate,
 			styleResolver,
-			removedMark
+			everyChange: mode
 		});
 		if (ranIn !== null) {
 			targets.push({
@@ -196,4 +282,4 @@ const runParagraphsIntoTables = (tr, mode, styleResolver) => {
 		}
 	}
 };
-export { runInCellPending, runParagraphIntoTable, runParagraphsIntoTables, runsIntoFollowingTable };
+export { paragraphBeforeRemovedBlock, runInCellPending, runParagraphIntoTable, runParagraphsIntoTables, runsIntoFollowingTable };

package/dist/prosemirror/textInput.js

@@ -30,8 +30,10 @@ const dispatchEditorTextInput = (view, input) => {
 			});
 			const tr = view.state.tr;
 			if (formattingMarks !== void 0) tr.setStoredMarks(formattingMarks);
+			const typesOverSelection = !selection.empty && selection.from === from && selection.to === to;
+			if (typesOverSelection && !selection.$from.parent.inlineContent) return tr.insertText(text);
 			tr.insertText(text, from, to);
-			return !selection.empty && selection.from === from && selection.to === to ? tr.setSelection(TextSelection.create(tr.doc, from + text.length)) : tr;
+			return typesOverSelection ? tr.setSelection(TextSelection.create(tr.doc, from + text.length)) : tr;
 		}
 		const start = Selection.atStart(view.state.doc);
 		const end = Selection.atEnd(view.state.doc);

package/dist/prosemirror/validation.js

@@ -3,7 +3,9 @@ import { readBlockCustomXmlAttrs, readBlockSdtAttrs, readCharacterSpacingMarkAtt
 import { readBookmarkBoundaryAttrs } from "./bookmarkBoundaryAttrs.js";
 import { readCommentRangeBoundaryAttrs } from "./commentRangeBoundaryAttrs.js";
 import { readCommentReferenceAttrs } from "./commentReferenceAttrs.js";
+import { HYPHEN_ELEMENT_MARK_NAME } from "./conversion/hyphenTextCarriers.js";
 import { fieldRequiresStructuredContent } from "./fieldRepresentation.js";
+import { readHyphenElementMarkAttrs } from "./hyphenElementAttrs.js";
 import { readMoveRangeBoundaryAttrs } from "./moveRangeBoundaryAttrs.js";
 import { readRangeAnchorAttrs } from "./rangeAnchorAttrs.js";
 import { isRunContentInlineNodeName } from "./runContentProjection.js";
@@ -15,6 +17,7 @@ import { readTextBoxAnchorAttrs } from "./textBoxAnchorAttrs.js";
 const COMPLEX_FIELD_RESULT_MARK_NAMES = /* @__PURE__ */ new Set([
 	...RUN_FORMATTING_MARK_NAMES,
 	RUN_IDENTITY_MARK_NAME,
+	HYPHEN_ELEMENT_MARK_NAME,
 	"runPropertyChange",
 	"footnoteRef"
 ]);
@@ -352,6 +355,9 @@ const validateMark = (mark, markPath, issues) => {
 		case "textShadow":
 		case "textOutline":
 		case "rtl": return;
+		case "hyphenElement":
+			appendAttrIssues(markPath, readHyphenElementMarkAttrs(mark), issues);
+			return;
 		case "textEffect":
 			appendAttrIssues(markPath, readTextEffectMarkAttrs(mark), issues);
 			return;

package/dist/utils/createDocument.js

@@ -5,6 +5,7 @@ import { formatParseWarnings } from "../docx/parseWarningMessage.js";
 import { DEFAULT_TAB_STOP_TWIPS as DEFAULT_TAB_STOP_TWIPS$1 } from "../docx/settingsParser.js";
 import { STYLE_SET_PART, normalizeDocumentStyleSet } from "../style-sets/styleSetNormalization.js";
 import "../style-sets/types.js";
+import { generateHexId } from "./hexId.js";
 import { panic } from "better-result";
 import { DOCX_CONFORMANCE_CLASSES } from "@stll/docx-core/model";
 // src/utils/createDocument.ts
@@ -368,17 +369,19 @@ function createEmptyDocument(options = {}) {
 	if (options.marginLeft !== void 0) sectionProps.marginLeft = Math.round(options.marginLeft);
 	if (options.marginRight !== void 0) sectionProps.marginRight = Math.round(options.marginRight);
 	const initialText = options.initialText ?? "";
+	const run = {
+		type: "run",
+		content: initialText ? [{
+			type: "text",
+			text: initialText
+		}] : [],
+		formatting: {}
+	};
 	const documentBody = {
 		content: [{
 			type: "paragraph",
-			content: [{
-				type: "run",
-				content: initialText ? [{
-					type: "text",
-					text: initialText
-				}] : [],
-				formatting: {}
-			}],
+			paraId: generateHexId(),
+			content: [run],
 			formatting: { styleId: styleSet?.initialParagraphStyleId ?? "Normal" }
 		}],
 		finalSectionProperties: sectionProps

package/dist/utils/fontLoader.d.ts

@@ -2,7 +2,7 @@
  * Font Loader
  *
  * Manages font availability for the DOCX editor. Fonts are bundled via
- * fontsource packages (WOFF2, no external requests). This module
+ * `@stll/folio-fonts` (WOFF2, no external requests). This module
  * tracks which fonts are loaded and provides callbacks for re-rendering
  * when fonts become available.
  */