@stll/folio-core 0.53.0 → 0.54.0

package/dist/prosemirror/noteReferenceReview.js

@@ -0,0 +1,332 @@
+import { withoutLostCommentThreads } from "../ai-edits/comment-lifecycle.js";
+import { visitCommentMarkers } from "../docx/commentAnchorIndex.js";
+import { isSeparatorEndnote, isSeparatorFootnote } from "../docx/footnoteParser.js";
+import { pluginsForHeadlessRevisionResolution } from "../internal/headlessRevisionResolutionGuard.js";
+import { expectFootnoteRefMarkAttrs, expectParagraphAttrs } from "./attrs/index.js";
+import { rejectAIEditRevision } from "./commands/comments.js";
+import { proseDocToBlocks } from "./conversion/fromProseDoc.js";
+import { footnoteToProseDoc } from "./conversion/toProseDoc.js";
+import { createDocumentNumberingPlugin } from "./plugins/documentNumbering.js";
+import { createDocumentStylesPlugin } from "./plugins/documentStyles.js";
+import { mintRevisionId } from "./plugins/revisionIds.js";
+import { schema, singletonManager } from "./schema/index.js";
+import { Transform } from "prosemirror-transform";
+import { EditorState } from "prosemirror-state";
+//#region src/prosemirror/noteReferenceReview.ts
+const noteKey = (kind, id) => `${kind}:${id}`;
+/**
+* The notes a story's text refers to, and whether each reference is pending
+* deletion: a reference is deleted when every character of it is.
+*/
+const noteReferenceStates = (doc) => {
+	const states = /* @__PURE__ */ new Map();
+	doc.descendants((node) => {
+		if (!node.isText) return true;
+		const reference = node.marks.find((mark) => mark.type.name === "footnoteRef");
+		if (!reference) return false;
+		const { id, noteType } = expectFootnoteRefMarkAttrs(reference);
+		const key = noteKey(noteType === "endnote" ? "endnote" : "footnote", Number(id));
+		if (!node.marks.some((mark) => mark.type.name === "deletion") || states.get(key) === "live") states.set(key, "live");
+		else states.set(key, "deleted");
+		return false;
+	});
+	return states;
+};
+/** The notes whose reference a change took from pending deletion back to live. */
+const noteReferencesRestored = (before, after) => {
+	const was = noteReferenceStates(before);
+	return [...noteReferenceStates(after)].flatMap(([key, state]) => state === "live" && was.get(key) === "deleted" ? [key] : []);
+};
+/**
+* The revisions that deleted a note along with its reference: its text and
+* its paragraph marks, deleted by the reference deletion's author at its
+* date. A deletion in the note made some other time is a change of its own,
+* which resolving the reference leaves alone.
+*/
+const noteDeletionRevisions = (doc, reference) => {
+	const author = String(reference.attrs["author"] ?? "");
+	const date = String(reference.attrs["date"] ?? "");
+	const ids = /* @__PURE__ */ new Set();
+	doc.descendants((node) => {
+		if (node.type.name === "paragraph") {
+			const mark = expectParagraphAttrs(node).pPrMark;
+			if (mark?.kind === "del" && mark.info.author === author && mark.info.date === date) ids.add(mark.info.id);
+		}
+		for (const mark of node.marks) if (mark.type.name === "deletion" && String(mark.attrs["author"] ?? "") === author && String(mark.attrs["date"] ?? "") === date) {
+			const id = mark.attrs["revisionId"];
+			if (typeof id === "number") ids.add(id);
+		}
+		return true;
+	});
+	return [...ids];
+};
+const restoredNote = (note, document, reference) => {
+	const { styles, theme, numbering } = document.package;
+	const doc = footnoteToProseDoc(note.content, {
+		...styles !== void 0 && { styles },
+		...theme !== void 0 && { theme }
+	});
+	const revisions = noteDeletionRevisions(doc, reference);
+	if (revisions.length === 0) return note;
+	let state = EditorState.create({
+		schema,
+		doc,
+		plugins: [
+			...pluginsForHeadlessRevisionResolution(singletonManager.getPlugins()),
+			createDocumentStylesPlugin(styles),
+			createDocumentNumberingPlugin(numbering)
+		]
+	});
+	rejectAIEditRevision(revisions)(state, (transaction) => {
+		state = state.apply(transaction);
+	});
+	if (state.doc.eq(doc)) return note;
+	return {
+		...note,
+		content: proseDocToBlocks(state.doc, note.content, styles)
+	};
+};
+/**
+* The document with the named notes' deletions that went with their
+* reference rejected: the notes whose reference's deletion was rejected get
+* their text back. `before` is the body that still had those deletions.
+*/
+const restoreNotes = (document, keys, before) => {
+	const deletions = referenceDeletions(before);
+	const wanted = new Set([...keys].filter((key) => deletions.has(key)));
+	if (wanted.size === 0) return document;
+	const restore = (kind, notes) => {
+		if (!notes?.some((note) => wanted.has(noteKey(kind, note.id)))) return notes;
+		return notes.map((note) => {
+			const reference = deletions.get(noteKey(kind, note.id));
+			return reference ? restoredNote(note, document, reference) : note;
+		});
+	};
+	const footnotes = restore("footnote", document.package.footnotes);
+	const endnotes = restore("endnote", document.package.endnotes);
+	if (footnotes === document.package.footnotes && endnotes === document.package.endnotes) return document;
+	return {
+		...document,
+		package: {
+			...document.package,
+			...footnotes !== void 0 && { footnotes },
+			...endnotes !== void 0 && { endnotes }
+		}
+	};
+};
+/** The deletion each pending-deleted note reference carries. */
+const referenceDeletions = (doc) => {
+	const deletions = /* @__PURE__ */ new Map();
+	doc.descendants((node) => {
+		if (!node.isText) return true;
+		const reference = node.marks.find((mark) => mark.type.name === "footnoteRef");
+		const deletion = node.marks.find((mark) => mark.type.name === "deletion");
+		if (reference && deletion) {
+			const { id, noteType } = expectFootnoteRefMarkAttrs(reference);
+			deletions.set(noteKey(noteType === "endnote" ? "endnote" : "footnote", Number(id)), deletion);
+		}
+		return false;
+	});
+	return deletions;
+};
+/**
+* Delete a note's text and its paragraph marks along with its reference: by
+* the reference deletion's author at its date, so resolving the reference
+* resolves them too (see {@link noteDeletionRevisions}).
+*/
+const deleteNoteWithReference = (transform, reference) => {
+	const doc = transform.doc;
+	const markInfo = {
+		id: mintRevisionId(),
+		author: String(reference.attrs["author"] ?? ""),
+		date: String(reference.attrs["date"] ?? "")
+	};
+	const { utcDate, initials } = reference.attrs;
+	const deletion = (doc.type.schema.marks["deletion"] ?? reference.type).create({
+		revisionId: mintRevisionId(),
+		author: markInfo.author,
+		date: markInfo.date,
+		...utcDate != null && { utcDate },
+		...initials != null && { initials }
+	});
+	doc.descendants((node, position) => {
+		if (node.type.name === "paragraph" && expectParagraphAttrs(node).pPrMark == null) transform.setNodeAttribute(position, "pPrMark", {
+			kind: "del",
+			info: markInfo
+		});
+		if (node.isInline && !deletion.type.isInSet(node.marks)) transform.addMark(position, position + node.nodeSize, deletion);
+		return !node.isInline;
+	});
+	return transform;
+};
+/**
+* A note whose reference was deleted: its text and its paragraph marks are
+* deleted too, by the reference's author at the reference's date.
+*/
+const deletedNote = (note, document, reference) => {
+	const { styles, theme } = document.package;
+	const doc = footnoteToProseDoc(note.content, {
+		...styles !== void 0 && { styles },
+		...theme !== void 0 && { theme }
+	});
+	const transform = deleteNoteWithReference(new Transform(doc), reference);
+	if (!transform.docChanged) return note;
+	return {
+		...note,
+		content: proseDocToBlocks(transform.doc, note.content, styles)
+	};
+};
+const editNotes = (document, edits) => {
+	if (edits.size === 0) return document;
+	const edit = (kind, notes) => {
+		if (!notes?.some((note) => edits.has(noteKey(kind, note.id)))) return notes;
+		return notes.map((note) => edits.get(noteKey(kind, note.id))?.(note) ?? note);
+	};
+	const footnotes = edit("footnote", document.package.footnotes);
+	const endnotes = edit("endnote", document.package.endnotes);
+	if (footnotes === document.package.footnotes && endnotes === document.package.endnotes) return document;
+	return {
+		...document,
+		package: {
+			...document.package,
+			...footnotes !== void 0 && { footnotes },
+			...endnotes !== void 0 && { endnotes }
+		}
+	};
+};
+const createNoteReferenceFollower = () => {
+	let base = null;
+	const replaced = /* @__PURE__ */ new Map();
+	const pending = /* @__PURE__ */ new Map();
+	const recorded = (key, edit) => (note) => {
+		const result = edit(note);
+		if (result !== note) pending.set(key, {
+			from: note,
+			to: result
+		});
+		return result;
+	};
+	return {
+		noteBase: (before) => {
+			base ??= before;
+		},
+		reconcile: (document, body) => {
+			const before = base;
+			base = null;
+			if (!before) return document;
+			const was = noteReferenceStates(before);
+			const now = noteReferenceStates(body);
+			const deletions = referenceDeletions(body);
+			const rejected = referenceDeletions(before);
+			const edits = /* @__PURE__ */ new Map();
+			for (const [key, state] of now) {
+				const previous = was.get(key);
+				const rejectedDeletion = rejected.get(key);
+				if (state === "live" && previous === "deleted" && rejectedDeletion) edits.set(key, recorded(key, (note) => {
+					const restored = restoredNote(note, document, rejectedDeletion);
+					if (restored !== note) replaced.set(key, {
+						restored,
+						previous: note
+					});
+					return restored;
+				}));
+				const reference = deletions.get(key);
+				if (state === "deleted" && previous === "live" && reference) edits.set(key, recorded(key, (note) => {
+					const earlier = replaced.get(key);
+					replaced.delete(key);
+					return earlier?.restored === note ? earlier.previous : deletedNote(note, document, reference);
+				}));
+			}
+			return editNotes(document, edits);
+		},
+		withPending: (document) => {
+			const edits = /* @__PURE__ */ new Map();
+			for (const [key, { from, to }] of pending) edits.set(key, (note) => {
+				if (note !== from) pending.delete(key);
+				return note === from ? to : note;
+			});
+			return editNotes(document, edits);
+		},
+		reset: () => {
+			base = null;
+			replaced.clear();
+			pending.clear();
+		}
+	};
+};
+/** The notes model content refers to, live or pending deletion. */
+const noteKeysReferencedIn = (content) => {
+	const keys = /* @__PURE__ */ new Set();
+	const visit = (node) => {
+		if (Array.isArray(node)) {
+			for (const item of node) visit(item);
+			return;
+		}
+		if (node === null || typeof node !== "object") return;
+		const { type, id } = node;
+		if ((type === "footnoteRef" || type === "endnoteRef") && typeof id === "number") keys.add(noteKey(type === "footnoteRef" ? "footnote" : "endnote", id));
+		for (const value of Object.values(node)) visit(value);
+	};
+	visit(content);
+	return keys;
+};
+/**
+* The notes anything refers to, live or pending deletion: the main story, and
+* the stories the body does not hold (headers, footers, comments, notes).
+* References inside the `skipped` notes do not count: those notes are going.
+*/
+const referencedNotes = (document, skipped = /* @__PURE__ */ new Set()) => {
+	const { headers, footers, footnotes, endnotes } = document.package;
+	const kept = (kind) => (note) => !skipped.has(noteKey(kind, note.id));
+	return noteKeysReferencedIn([
+		document.package.document.content,
+		[...headers?.values() ?? [], ...footers?.values() ?? []],
+		document.package.document.comments ?? [],
+		(footnotes ?? []).filter(kept("footnote")),
+		(endnotes ?? []).filter(kept("endnote"))
+	]);
+};
+/** Ids of the comments anchored anywhere in these stories. */
+const anchoredComments = (stories) => {
+	const ids = /* @__PURE__ */ new Set();
+	for (const blocks of stories) visitCommentMarkers(blocks, ({ item }) => ids.add(item.id));
+	return ids;
+};
+/**
+* The document without the notes nothing refers to any more: a note goes
+* with its reference, so accepting the reference's deletion leaves a note no
+* reader can reach, and saving drops it, with the comments anchored only in
+* it. Separators stay.
+*/
+const withoutUnreferencedNotes = (document) => {
+	const referenced = referencedNotes(document);
+	const { footnotes, endnotes, headers, footers } = document.package;
+	const keeps = (kind) => (note) => (kind === "footnote" ? isSeparatorFootnote(note) : isSeparatorEndnote(note)) || referenced.has(noteKey(kind, note.id));
+	const keptFootnotes = footnotes?.filter(keeps("footnote"));
+	const keptEndnotes = endnotes?.filter(keeps("endnote"));
+	if (keptFootnotes?.length === footnotes?.length && keptEndnotes?.length === endnotes?.length) return document;
+	const removed = [...(footnotes ?? []).filter((note) => !keeps("footnote")(note)), ...(endnotes ?? []).filter((note) => !keeps("endnote")(note))];
+	const comments = document.package.document.comments;
+	const keptComments = comments ? withoutLostCommentThreads(comments, {
+		anchoredBefore: anchoredComments(removed.map((note) => note.content)),
+		anchoredNow: anchoredComments([
+			document.package.document.content,
+			...[...headers?.values() ?? [], ...footers?.values() ?? []].map((part) => part.content),
+			...[...keptFootnotes ?? [], ...keptEndnotes ?? []].map((note) => note.content)
+		])
+	}) : void 0;
+	return {
+		...document,
+		package: {
+			...document.package,
+			...keptFootnotes !== void 0 && { footnotes: keptFootnotes },
+			...keptEndnotes !== void 0 && { endnotes: keptEndnotes },
+			...keptComments !== void 0 && keptComments.length !== comments?.length && { document: {
+				...document.package.document,
+				comments: keptComments
+			} }
+		}
+	};
+};
+//#endregion
+export { createNoteReferenceFollower, deleteNoteWithReference, noteDeletionRevisions, noteKeysReferencedIn, noteReferenceStates, noteReferencesRestored, referenceDeletions, referencedNotes, restoreNotes, withoutUnreferencedNotes };

package/dist/prosemirror/paragraphIndentation.js

@@ -1,3 +1,4 @@
+import { paragraphNumberingReferenceId } from "../docx/numberingReference.js";
 import { panic } from "better-result";
 //#region src/prosemirror/paragraphIndentation.ts
 const DIRECT_PARAGRAPH_INDENTATION_KEYS = [
@@ -49,12 +50,14 @@ const PARAGRAPH_INDENTATION_VALUE_KEYS = [
 const directParagraphIndentation = (attrs) => {
 	const original = attrs._originalFormatting ?? void 0;
 	const resolved = attrs._resolvedFormatting;
+	const numbered = paragraphNumberingReferenceId(attrs.numPr ?? void 0) !== void 0;
 	const indentation = {};
 	for (const key of PARAGRAPH_INDENTATION_VALUE_KEYS) {
 		const value = attrs[key];
 		if (typeof value !== "number") continue;
 		const stated = original?.[key] !== void 0;
-		const inherited = resolved?.[key] === value || original === void 0 && value === 0;
+		const zeroIsDefault = key === "indentRight" || !numbered;
+		const inherited = resolved?.[key] === value || original === void 0 && value === 0 && zeroIsDefault;
 		if (stated || !inherited) copyIndentationValue({
 			target: indentation,
 			key,
@@ -65,7 +68,7 @@ const directParagraphIndentation = (attrs) => {
 		const hanging = attrs.hangingIndent === true;
 		indentation.hangingIndent = hanging;
 		if (hanging) indentation.indentFirstLine = -Math.abs(indentation.indentFirstLine);
-	} else if (original?.hangingIndent !== void 0 && typeof attrs.hangingIndent === "boolean") indentation.hangingIndent = attrs.hangingIndent;
+	} else if (original?.hangingIndent !== void 0 && original.indentFirstLine === void 0 && typeof attrs.hangingIndent === "boolean") indentation.hangingIndent = attrs.hangingIndent;
 	return Object.keys(indentation).length > 0 ? indentation : void 0;
 };
 const paragraphIndentationEqual = (left, right) => DIRECT_PARAGRAPH_INDENTATION_KEYS.every((key) => left?.[key] === right?.[key]);

package/dist/prosemirror/paragraphMarkJoin.d.ts

@@ -1,3 +1,4 @@
+import { RunStyleResolver } from "./runStyleFormatting.js";
 import { Node } from "prosemirror-model";
 import { Transaction } from "prosemirror-state";
 //#region src/prosemirror/paragraphMarkJoin.d.ts
@@ -9,11 +10,12 @@ type JoinAtParagraphMarkOptions = {
   /** The paragraph directly after it, which the join runs into. */
   next: Node;
   /**
-   * The first paragraph's content is going too (a deleted paragraph), so
-   * only the join survives of it, as when it is already empty.
+   * Re-reads the moved runs' inherited formatting in the next paragraph's
+   * style. Without one, the editor's join restyler does it when the
+   * transaction is dispatched.
    */
-  firstIsGoing?: boolean;
+  styleResolver: RunStyleResolver | null;
 };
-declare const joinAtParagraphMark: ({ tr, paragraphPos, paragraph, next, firstIsGoing }: JoinAtParagraphMarkOptions) => void;
+declare const joinAtParagraphMark: ({ tr, paragraphPos, paragraph, next, styleResolver }: JoinAtParagraphMarkOptions) => void;
 //#endregion
 export { joinAtParagraphMark };

package/dist/prosemirror/paragraphMarkJoin.js

@@ -1,24 +1,26 @@
 import { joinProseParagraphsWithRightPropertySource } from "../docx/paragraphPropertySource.js";
-import { holdsNoContent } from "./zeroWidthAnchors.js";
+import { JOINED_RUNS_RESTYLED_META } from "./extensions/features/JoinedRunStyleExtension.js";
+import { rebaseParagraphRuns } from "./rebaseParagraphRunFormatting.js";
+import { paragraphRunStyleContext } from "./runStyleFormatting.js";
 //#region src/prosemirror/paragraphMarkJoin.ts
-const joinAtParagraphMark = ({ tr, paragraphPos, paragraph, next, firstIsGoing = false }) => {
-	const joinPos = paragraphPos + paragraph.nodeSize;
-	const emptyFirstParagraph = firstIsGoing || holdsNoContent(paragraph);
-	const joinedAttrs = {
-		...(emptyFirstParagraph ? next : paragraph).attrs,
-		pPrMark: next.attrs["pPrMark"],
-		_sectionProperties: next.attrs["_sectionProperties"]
-	};
-	if (emptyFirstParagraph) {
-		joinProseParagraphsWithRightPropertySource({
-			attrs: joinedAttrs,
-			pos: joinPos,
-			transaction: tr
-		});
-		return;
-	}
-	tr.join(joinPos);
-	tr.setNodeMarkup(paragraphPos, void 0, joinedAttrs);
+const joinAtParagraphMark = ({ tr, paragraphPos, paragraph, next, styleResolver }) => {
+	joinProseParagraphsWithRightPropertySource({
+		attrs: next.attrs,
+		pos: paragraphPos + paragraph.nodeSize,
+		transaction: tr
+	});
+	if (!styleResolver) return;
+	if (paragraph.content.size > 0) rebaseParagraphRuns({
+		previousContext: paragraphRunStyleContext(paragraph, styleResolver),
+		paragraphPosition: paragraphPos,
+		range: {
+			from: 0,
+			to: paragraph.content.size
+		},
+		styleResolver,
+		tr
+	});
+	tr.setMeta(JOINED_RUNS_RESTYLED_META, true);
 };
 //#endregion
 export { joinAtParagraphMark };

package/dist/prosemirror/paragraphPropertyCarry.d.ts

@@ -0,0 +1,64 @@
+import { ParagraphPropertyChangeAttrs } from "./schema/nodes.js";
+import { RunStyleResolver } from "./runStyleFormatting.js";
+import { NumberingMap } from "../docx/numberingParser.js";
+import { Node } from "prosemirror-model";
+import { Transaction } from "prosemirror-state";
+//#region src/prosemirror/paragraphPropertyCarry.d.ts
+type CarryParagraphPropertiesOptions = {
+  tr: Transaction;
+  /** The paragraph that takes the properties. */
+  position: number;
+  /** The paragraph whose properties it takes. */
+  source: Node;
+  styleResolver: RunStyleResolver | null;
+  numbering: NumberingMap | null;
+  /** Records the change as a tracked property change; applied directly when omitted. */
+  revision?: ParagraphPropertyChangeAttrs["info"];
+  /** Properties the paragraph keeps its own values of: ones its own batch set. */
+  keep?: ReadonlySet<string>;
+};
+/**
+ * Give a paragraph another one's properties: the pPr a property change
+ * covers. Its identity, mark, mark run properties and section stay its own,
+ * and its runs are re-read in the new style. `tracked` says whether a property
+ * change now records what it had: a paragraph holds one, and a pending one
+ * already records it.
+ */
+declare const carryParagraphProperties: ({ tr, position, source, styleResolver, numbering, revision, keep }: CarryParagraphPropertiesOptions) => {
+  tr: Transaction;
+  changed: boolean;
+  tracked: boolean;
+};
+type ParagraphLeftAfterOptions = {
+  doc: Node;
+  paragraphPos: number;
+  /** Breaks a batch's deferred final-paragraph deletion will remove. */
+  removedBreakPositions?: ReadonlySet<number>;
+};
+/**
+ * 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.
+ */
+declare const paragraphLeftAfter: ({ doc, paragraphPos, removedBreakPositions }: ParagraphLeftAfterOptions) => number | null;
+/**
+ * A paragraph now holds the break another one had (a split, or a paste into
+ * it, leaves that break on the last part) but reads with other properties:
+ * record the other's as its property change. Rejecting the inserted breaks
+ * leaves this paragraph, which then reads as the one that was there. A
+ * pending property change on the other one travels as it is. Returns whether
+ * a change under `revision` was written.
+ */
+declare const recordReplacedParagraphProperties: ({ tr, position, replaced, revision }: {
+  tr: Transaction;
+  position: number;
+  replaced: Node;
+  revision: ParagraphPropertyChangeAttrs["info"];
+}) => boolean;
+/**
+ * The properties a batch's own property change set on a paragraph: the ones
+ * whose value differs from what that change records as before.
+ */
+declare const propertiesSetInBatch: (node: Node, batchRevisionIds: ReadonlySet<number>) => ReadonlySet<string>;
+//#endregion
+export { carryParagraphProperties, paragraphLeftAfter, propertiesSetInBatch, recordReplacedParagraphProperties };

package/dist/prosemirror/paragraphPropertyCarry.js

@@ -0,0 +1,158 @@
+import { expectParagraphAttrs } from "./attrs/index.js";
+import { hasSerializableParagraphPropertyChange, paragraphPropertiesSnapshot } from "./commands/propertyChangeScope.js";
+import { resolveParagraphChangeAttrs } from "./commands/resolveParagraphProperties.js";
+import { rebaseParagraphRuns } from "./rebaseParagraphRunFormatting.js";
+import { paragraphRunStyleContext } from "./runStyleFormatting.js";
+import { panic } from "better-result";
+//#region src/prosemirror/paragraphPropertyCarry.ts
+/**
+* Handing one paragraph's properties to another, as a removed paragraph mark
+* requires.
+*
+* A paragraph's properties live on its mark, and a removed mark leaves the
+* paragraph after it: that is the paragraph left once the change is accepted.
+* An edit that should read as the FIRST paragraph (a merge, a Backspace at a
+* paragraph's start, a deletion across paragraphs) therefore gives the second
+* the first's properties, recorded as a property change under the same
+* revision, so accepting reads as the direct edit and rejecting restores the
+* second's own.
+*/
+/**
+* Give a paragraph another one's properties: the pPr a property change
+* covers. Its identity, mark, mark run properties and section stay its own,
+* and its runs are re-read in the new style. `tracked` says whether a property
+* 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 target = tr.doc.nodeAt(position);
+	if (!target || target.type !== source.type) return {
+		tr,
+		changed: false,
+		tracked: false
+	};
+	const previousFormatting = paragraphPropertiesSnapshot(target);
+	const own = previousFormatting;
+	const formatting = Object.fromEntries([...Object.entries(paragraphPropertiesSnapshot(source)).filter(([key]) => !keep?.has(key)), ...Object.entries(own).filter(([key]) => keep?.has(key))]);
+	if (JSON.stringify(previousFormatting) === JSON.stringify(formatting)) return {
+		tr,
+		changed: false,
+		tracked: false
+	};
+	const existing = expectParagraphAttrs(target)._propertyChanges;
+	const tracked = revision !== void 0 && !hasSerializableParagraphPropertyChange(existing);
+	const carried = resolveParagraphChangeAttrs({
+		node: target.type.create({
+			...target.attrs,
+			_propertyChanges: [{
+				type: "paragraphPropertyChange",
+				info: {
+					id: -1,
+					author: "",
+					date: "1970-01-01T00:00:00Z"
+				},
+				previousFormatting: formatting
+			}]
+		}, target.content, target.marks),
+		mode: "reject",
+		boundaryCovered: true,
+		revisionSet: null,
+		styleResolver,
+		numbering
+	});
+	if (!carried) return panic("Paragraph properties did not pass to the paragraph", { position });
+	const changes = [...Array.isArray(existing) ? existing : [], ...tracked && revision ? [{
+		type: "paragraphPropertyChange",
+		info: revision,
+		previousFormatting
+	}] : []];
+	tr.setNodeMarkup(position, void 0, {
+		...carried,
+		...carriedNumberingProvenance(source, target, keep),
+		_sectionProperties: target.attrs["_sectionProperties"],
+		_propertyChanges: changes.length > 0 ? changes : null
+	});
+	if (styleResolver) rebaseParagraphRuns({
+		previousContext: paragraphRunStyleContext(target, styleResolver),
+		paragraphPosition: position,
+		styleResolver,
+		tr
+	});
+	return {
+		tr,
+		changed: true,
+		tracked
+	};
+};
+/**
+* Whether the carried numbering is the paragraph's own or its style's: the
+* record holds `numPr` as the paragraph reads it, 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.
+*/
+const paragraphLeftAfter = ({ doc, paragraphPos, removedBreakPositions }) => {
+	let position = paragraphPos;
+	const start = doc.nodeAt(position);
+	if (!start) return null;
+	let node = start;
+	for (;;) {
+		const nextPos = position + node.nodeSize;
+		const next = doc.resolve(nextPos).nodeAfter;
+		if (!next || next.type !== node.type) return null;
+		const mark = expectParagraphAttrs(next).pPrMark;
+		const nextGoes = removedBreakPositions?.has(nextPos) || mark != null && (mark.kind === "del" || mark.kind === "moveFrom");
+		const afterNext = doc.resolve(nextPos + next.nodeSize).nodeAfter;
+		if (!nextGoes || afterNext?.type !== node.type) return nextPos;
+		position = nextPos;
+		node = next;
+	}
+};
+const recordedFormatting = (node) => ({
+	...paragraphPropertiesSnapshot(node),
+	numPr: expectParagraphAttrs(node).numPr ?? null
+});
+/**
+* A paragraph now holds the break another one had (a split, or a paste into
+* it, leaves that break on the last part) but reads with other properties:
+* record the other's as its property change. Rejecting the inserted breaks
+* leaves this paragraph, which then reads as the one that was there. A
+* pending property change on the other one travels as it is. Returns whether
+* a change under `revision` was written.
+*/
+const recordReplacedParagraphProperties = ({ tr, position, replaced, revision }) => {
+	const target = tr.doc.nodeAt(position);
+	if (!target || target.type !== replaced.type) return false;
+	if (hasSerializableParagraphPropertyChange(expectParagraphAttrs(target)._propertyChanges)) return false;
+	const pending = expectParagraphAttrs(replaced)._propertyChanges;
+	if (hasSerializableParagraphPropertyChange(pending)) {
+		tr.setNodeAttribute(position, "_propertyChanges", pending);
+		return false;
+	}
+	const previousFormatting = recordedFormatting(replaced);
+	if (JSON.stringify(previousFormatting) === JSON.stringify(recordedFormatting(target))) return false;
+	tr.setNodeAttribute(position, "_propertyChanges", [{
+		type: "paragraphPropertyChange",
+		info: revision,
+		previousFormatting
+	}]);
+	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])));
+};
+//#endregion
+export { carryParagraphProperties, paragraphLeftAfter, propertiesSetInBatch, recordReplacedParagraphProperties };