@stll/folio-core 0.62.0 → 0.63.1

package/dist/prosemirror/indexedNodeLookup.d.ts

@@ -2,16 +2,16 @@ import { Node } from "prosemirror-model";
 //#region src/prosemirror/indexedNodeLookup.d.ts
 type NodesBetweenCallback = (node: Node, pos: number, parent: Node | null, index: number) => boolean | void;
 /** `doc.nodesBetween(from, to, visit)`, locating `from` by binary search. */
-declare const nodesBetweenIndexed: (doc: Node, from: number, to: number, visit: NodesBetweenCallback) => void;
+export declare const nodesBetweenIndexed: (doc: Node, from: number, to: number, visit: NodesBetweenCallback) => void;
 /** `doc.nodeAt(pos)`. */
-declare const nodeAtIndexed: (doc: Node, pos: number) => Node | null;
+export declare const nodeAtIndexed: (doc: Node, pos: number) => Node | null;
 /**
  * The innermost paragraph `doc.resolve(pos)` passes through, and the position
  * before it (`$pos.before(depth)`), or null outside every paragraph.
  */
-declare const enclosingParagraphIndexed: (doc: Node, pos: number) => {
+export declare const enclosingParagraphIndexed: (doc: Node, pos: number) => {
   node: Node;
   pos: number;
 } | null;
 //#endregion
-export { enclosingParagraphIndexed, nodeAtIndexed, nodesBetweenIndexed };
+export {};

package/dist/prosemirror/inlineDisplayText.d.ts

@@ -1,10 +1,9 @@
 import { Node } from "prosemirror-model";
 //#region src/prosemirror/inlineDisplayText.d.ts
 /** Native note-reference labels are navigation anchors, outside searchable text. */
-declare const isNoteReferenceText: (node: Node) => boolean;
+export declare const isNoteReferenceText: (node: Node) => boolean;
 /** A leaf's logical text; null means a transparent container to descend into. */
-declare const getInlineDisplayToken: (node: Node) => string | null;
+export declare const getInlineDisplayToken: (node: Node) => string | null;
 /** Visible inline text, including cached source atoms and native run tokens. */
-declare const getInlineDisplayText: (paragraph: Node) => string;
-//#endregion
-export { getInlineDisplayText, getInlineDisplayToken, isNoteReferenceText };
+export declare const getInlineDisplayText: (paragraph: Node) => string;
+//#endregion

package/dist/prosemirror/inlineWrapperStack.d.ts

@@ -2,9 +2,9 @@ import { document_d_exports } from "../types/document.js";
 import { InlineWrapperLayer } from "./schema/marks.js";
 //#region src/prosemirror/inlineWrapperStack.d.ts
 /** The DOM attribute that carries a serialised stack through copy and paste. */
-declare const INLINE_WRAPPER_STACK_ATTRIBUTE = "data-inline-wrapper";
+export declare const INLINE_WRAPPER_STACK_ATTRIBUTE = "data-inline-wrapper";
 /** A layer with its keys in canonical order, absent fields left absent. */
-declare const inlineWrapperLayer: (layer: InlineWrapperLayer) => InlineWrapperLayer;
+export declare const inlineWrapperLayer: (layer: InlineWrapperLayer) => InlineWrapperLayer;
 /**
  * The model member a layer describes, holding `content`.
  *
@@ -12,10 +12,10 @@ declare const inlineWrapperLayer: (layer: InlineWrapperLayer) => InlineWrapperLa
  * member apart into a layer and its content, and the save leg puts one back
  * together. Both directions live here so a wrapper kind is spelled once.
  */
-declare const inlineWrapperMember: (layer: InlineWrapperLayer, content: document_d_exports.InlineWrapper["content"]) => document_d_exports.InlineWrapper;
+export declare const inlineWrapperMember: (layer: InlineWrapperLayer, content: document_d_exports.InlineWrapper["content"]) => document_d_exports.InlineWrapper;
 /** `layers` in canonical form, or `null` when there is no wrapper to record. */
-declare const inlineWrapperStack: (layers: readonly InlineWrapperLayer[]) => readonly InlineWrapperLayer[] | null;
-declare const serializeInlineWrapperStack: (stack: readonly InlineWrapperLayer[]) => string;
+export declare const inlineWrapperStack: (layers: readonly InlineWrapperLayer[]) => readonly InlineWrapperLayer[] | null;
+export declare const serializeInlineWrapperStack: (stack: readonly InlineWrapperLayer[]) => string;
 /**
  * The key two stacks share exactly when they are the same nest of wrappers.
  *
@@ -25,7 +25,7 @@ declare const serializeInlineWrapperStack: (stack: readonly InlineWrapperLayer[]
  * be written as two `w:bdo` elements. The empty stack keys as the empty string,
  * which is what "inside no wrapper" compares as.
  */
-declare const inlineWrapperStackKey: (stack: readonly InlineWrapperLayer[]) => string;
+export declare const inlineWrapperStackKey: (stack: readonly InlineWrapperLayer[]) => string;
 /**
  * A stack read back from the DOM, or `null` when the markup carries none.
  *
@@ -34,6 +34,5 @@ declare const inlineWrapperStackKey: (stack: readonly InlineWrapperLayer[]) => s
  * not a stack this build validates is read the same way — the text is what
  * matters, and inventing a wrapper around it would change the document.
  */
-declare const parseInlineWrapperStack: (serialized: string | null | undefined) => readonly InlineWrapperLayer[] | null;
-//#endregion
-export { INLINE_WRAPPER_STACK_ATTRIBUTE, inlineWrapperLayer, inlineWrapperMember, inlineWrapperStack, inlineWrapperStackKey, parseInlineWrapperStack, serializeInlineWrapperStack };
+export declare const parseInlineWrapperStack: (serialized: string | null | undefined) => readonly InlineWrapperLayer[] | null;
+//#endregion

package/dist/prosemirror/insertOperations.d.ts

@@ -4,15 +4,15 @@ import "./commands/index.js";
 import { EditorView } from "prosemirror-view";
 //#region src/prosemirror/insertOperations.d.ts
 /** Insert a `rows × columns` table at the current selection. */
-declare function insertTableInView(view: EditorView, rows: number, columns: number): boolean;
+export declare function insertTableInView(view: EditorView, rows: number, columns: number): boolean;
 /** Insert a page break at the current selection. */
-declare function insertPageBreakInView(view: EditorView): boolean;
+export declare function insertPageBreakInView(view: EditorView): boolean;
 /**
  * Generate (or refresh) a table of contents from the document's headings.
  *
  * `title` is the caller's because this layer has no locale — see
  * {@link GenerateTableOfContentsOptions}.
  */
-declare function insertTableOfContentsInView(view: EditorView, options: GenerateTableOfContentsOptions): boolean;
+export declare function insertTableOfContentsInView(view: EditorView, options: GenerateTableOfContentsOptions): boolean;
 //#endregion
-export { insertImageFromFile, insertPageBreakInView, insertTableInView, insertTableOfContentsInView };
+export { insertImageFromFile };

package/dist/prosemirror/keptRangeBoundaries.d.ts

@@ -0,0 +1,76 @@
+import { document_d_exports } from "../types/document.js";
+import { TrackedRevisionAncestor } from "./schema/marks.js";
+import { Node } from "prosemirror-model";
+import { Transaction } from "prosemirror-state";
+//#region src/prosemirror/keptRangeBoundaries.d.ts
+/** A range boundary, as the engine's model writes it. */
+type BoundaryItem = Extract<document_d_exports.ParagraphContent, {
+  type: "bookmarkStart" | "bookmarkEnd" | "commentRangeStart" | "commentRangeEnd" | "moveFromRangeStart" | "moveFromRangeEnd" | "moveToRangeStart" | "moveToRangeEnd";
+}>;
+/** The range boundaries `node` carries; none for any other node. */
+export declare const rangeBoundaryItemsOf: (node: Node) => readonly BoundaryItem[];
+/** Range boundary nodes, as the nodes that stand for them between blocks. */
+export declare const blockBoundariesOf: (nodes: readonly Node[]) => Node[];
+/** Whether `node` holds a comment's anchor, which only a paragraph holds. */
+export declare const carriesCommentAnchor: (node: Node) => boolean;
+/** Whether `node` is a range boundary standing between blocks. */
+export declare const isBlockBoundaryNode: (node: Node | null | undefined) => boolean;
+/**
+ * The inline form of range boundaries between blocks whose paragraph break
+ * goes, so they stand between the joined paragraphs' content; `null` when
+ * one of `blocks` is not such a boundary.
+ */
+export declare const inlineBoundariesOf: (blocks: readonly Node[]) => Node[] | null;
+/**
+ * What `paragraph` leaves where it was when it goes whole, by the engine's
+ * own rule (`paragraphRemains`): before a table, its bookmark and move range
+ * boundaries as block nodes in its place (`blocks`), unless a comment needs
+ * the paragraph before it, which takes every carrier in source order
+ * (`comments`); ending its
+ * container, every node carrying a boundary (`inline`), for the paragraph
+ * before it.
+ */
+export declare const paragraphRemainsOf: (paragraph: Node) => {
+  blocks: Node[];
+  comments: Node[];
+  inline: Node[];
+};
+/**
+ * Make every range a rejection kept boundaries of well-formed, by the
+ * engine's own plan (`planWellFormedRanges`): `kept` holds the nodes
+ * {@link removeResolvedSubtree} kept, found in `tr.doc` as themselves. The plan
+ * runs once over every boundary in document order and names each by its
+ * place in that list, as the engine names its own, so applying it never
+ * reads a position the repair itself moved.
+ */
+export declare const normalizeKeptRangeBoundaries: (tr: Transaction, kept: ReadonlySet<Node>) => void;
+declare const removedSubtreeBrand: unique symbol;
+/**
+ * What stays of a subtree a resolution removes. Only
+ * {@link removeResolvedSubtree} makes one, so no resolution can drop content
+ * without being handed the boundaries it holds.
+ */
+export type RemovedSubtree = {
+  /** Fresh nodes, in document order, to stand where the subtree was. */
+  readonly kept: readonly Node[];
+  readonly [removedSubtreeBrand]: true;
+};
+/** What a resolution resolves: the mode, and which revisions it selects. */
+export type RevisionSelection = {
+  mode: "accept" | "reject";
+  resolves: (revisionId: number) => boolean;
+};
+/** Whether resolving `layer` by `mode` takes its content out. */
+export declare const revisionLayerRemovesContent: (layer: TrackedRevisionAncestor, mode: "accept" | "reject") => boolean;
+/**
+ * Remove `node` and everything in it. Rejecting keeps every range boundary
+ * within it, at any depth, as the engine's `removedContentBoundaries` does;
+ * accepting keeps none, as a direct deletion does. A kept boundary keeps its
+ * own other marks and carries the revisions of where `node` stood
+ * ({@link landingMarks}), never one from inside the removed content. Each
+ * kept node is a new node, so the range repair can tell it from a boundary
+ * that was already standing.
+ */
+export declare const removeResolvedSubtree: (node: Node, selection: RevisionSelection) => RemovedSubtree;
+//#endregion
+export {};

package/dist/prosemirror/keptRangeBoundaries.js

@@ -0,0 +1,381 @@
+import { expectBookmarkBoundaryAttrs } from "./bookmarkBoundaryAttrs.js";
+import { expectCommentRangeBoundaryAttrs } from "./commentRangeBoundaryAttrs.js";
+import { expectCommentReferenceAttrs } from "./commentReferenceAttrs.js";
+import "./commentReferenceIntegrity.js";
+import { copyOriginBoundaryAfterRemovingAddedAncestors, copyOriginBoundaryAfterResolution } from "./copyOriginResolution.js";
+import { planEmptyRanges } from "./emptyRangeAnchor.js";
+import { BLOCK_BOOKMARK_BOUNDARY_NODE_NAME } from "./extensions/nodes/BlockBookmarkBoundaryExtension.js";
+import { BLOCK_MOVE_RANGE_BOUNDARY_NODE_NAME } from "./extensions/nodes/BlockMoveRangeBoundaryExtension.js";
+import { BOOKMARK_BOUNDARY_NODE_NAME } from "./extensions/nodes/BookmarkBoundaryExtension.js";
+import { COMMENT_RANGE_BOUNDARY_NODE_NAME } from "./extensions/nodes/CommentRangeBoundaryExtension.js";
+import { MOVE_RANGE_BOUNDARY_NODE_NAME } from "./extensions/nodes/MoveRangeBoundaryExtension.js";
+import { RANGE_ANCHOR_NODE_NAME } from "./extensions/nodes/RangeAnchorExtension.js";
+import { expectMoveRangeBoundaryAttrs } from "./moveRangeBoundaryAttrs.js";
+import { expectRangeAnchorAttrs } from "./rangeAnchorAttrs.js";
+import { retainedTrackedRevisionMark, trackedRevisionPathOf } from "./trackedRevisionPath.js";
+import { paragraphRemains, planWellFormedRanges } from "@stll/docx-core/ops";
+//#region src/prosemirror/keptRangeBoundaries.ts
+/** The marks that say a node is in a revision: its wrappers, in the engine. */
+const REVISION_MARK_NAMES = /* @__PURE__ */ new Set(["insertion", "deletion"]);
+const bookmarkItems = (node) => {
+	const attrs = expectBookmarkBoundaryAttrs(node);
+	return attrs.type === "start" ? [{
+		type: "bookmarkStart",
+		id: attrs.id,
+		name: attrs.name,
+		...attrs.copyOriginAncestors === void 0 ? {} : { copyOriginAncestors: attrs.copyOriginAncestors }
+	}] : [{
+		type: "bookmarkEnd",
+		id: attrs.id,
+		...attrs.copyOriginAncestors === void 0 ? {} : { copyOriginAncestors: attrs.copyOriginAncestors }
+	}];
+};
+/** The boundaries each node carries, in document order. A missing kind fails to type-check. */
+const BOUNDARY_ITEMS = {
+	[BOOKMARK_BOUNDARY_NODE_NAME]: bookmarkItems,
+	[BLOCK_BOOKMARK_BOUNDARY_NODE_NAME]: bookmarkItems,
+	[MOVE_RANGE_BOUNDARY_NODE_NAME]: (node) => [expectMoveRangeBoundaryAttrs(node)],
+	[BLOCK_MOVE_RANGE_BOUNDARY_NODE_NAME]: (node) => [expectMoveRangeBoundaryAttrs(node)],
+	[RANGE_ANCHOR_NODE_NAME]: (node) => {
+		const { start, end } = expectRangeAnchorAttrs(node);
+		return [start, end];
+	},
+	[COMMENT_RANGE_BOUNDARY_NODE_NAME]: (node) => [expectCommentRangeBoundaryAttrs(node).marker]
+};
+const isBoundaryNodeName = (name) => Object.hasOwn(BOUNDARY_ITEMS, name);
+/** The range boundaries `node` carries; none for any other node. */
+const rangeBoundaryItemsOf = (node) => isBoundaryNodeName(node.type.name) ? BOUNDARY_ITEMS[node.type.name](node) : [];
+const isComment = (item) => item.type === "commentRangeStart" || item.type === "commentRangeEnd";
+/**
+* Whether resolving away the content around `node` keeps it in place: it
+* carries range boundaries and none is a comment's, which goes with the
+* comment.
+*/
+const keepsRangeBoundary = (node) => {
+	const items = rangeBoundaryItemsOf(node);
+	return items.length > 0 && !items.some(isComment);
+};
+/** Each boundary's range family and side, as the engine pairs them. */
+const BOUNDARY_SIDES = {
+	bookmarkStart: {
+		family: "bookmark",
+		side: "start"
+	},
+	bookmarkEnd: {
+		family: "bookmark",
+		side: "end"
+	},
+	commentRangeStart: {
+		family: "comment",
+		side: "start"
+	},
+	commentRangeEnd: {
+		family: "comment",
+		side: "end"
+	},
+	moveFromRangeStart: {
+		family: "moveFrom",
+		side: "start"
+	},
+	moveFromRangeEnd: {
+		family: "moveFrom",
+		side: "end"
+	},
+	moveToRangeStart: {
+		family: "moveTo",
+		side: "start"
+	},
+	moveToRangeEnd: {
+		family: "moveTo",
+		side: "end"
+	}
+};
+const occurrenceOf = (item, kept, keptFrom) => {
+	const { family, side } = BOUNDARY_SIDES[item.type];
+	return {
+		boundary: `${item.type}:${item.id}`,
+		range: `${family}:${item.id}`,
+		side,
+		kept,
+		...kept && keptFrom !== void 0 ? { keptFrom } : {}
+	};
+};
+/**
+* The date of the revision each kept boundary was kept from, the empty string
+* when it has none: the engine's tie-break between a kept start and end out
+* of order, so the editor moves the same one.
+*/
+const keptRevisionDates = /* @__PURE__ */ new WeakMap();
+/** The date of the outermost revision `selection` removes `node` with. */
+const removingRevisionDate = (node, selection) => {
+	for (const mark of node.marks) {
+		if (!REVISION_MARK_NAMES.has(mark.type.name)) continue;
+		const layer = trackedRevisionPathOf(mark).find((candidate) => selection.resolves(candidate.revisionId) && revisionLayerRemovesContent(candidate, selection.mode));
+		if (layer !== void 0) return layer.date ?? "";
+	}
+	return "";
+};
+const boundariesIn = (doc, kept) => {
+	const found = [];
+	doc.descendants((node, position) => {
+		for (const item of rangeBoundaryItemsOf(node)) found.push({
+			position,
+			node,
+			item,
+			occurrence: occurrenceOf(item, kept.has(node), keptRevisionDates.get(node))
+		});
+		return true;
+	});
+	return found;
+};
+const isBookmark = (item) => item.type === "bookmarkStart" || item.type === "bookmarkEnd";
+/**
+* The one half a move's point range keeps, as a node of its own on `marks`:
+* the only boundary the repair makes, since one node holds both halves of a
+* point range. A comment's point range goes with its comment, and a bookmark
+* is never one.
+*/
+const pointRangeHalf = (node, half, marks) => {
+	if (isComment(half) || isBookmark(half)) return void 0;
+	return node.type.schema.nodes[MOVE_RANGE_BOUNDARY_NODE_NAME]?.create({ marker: half }, null, marks);
+};
+/** One boundary as a node of its own, inline or between blocks. */
+const boundaryNode = (item, schema, inline) => {
+	if (item.type === "bookmarkStart" || item.type === "bookmarkEnd") {
+		const attrs = item.type === "bookmarkStart" ? {
+			type: "start",
+			id: item.id,
+			name: item.name,
+			...item.copyOriginAncestors === void 0 ? {} : { copyOriginAncestors: item.copyOriginAncestors }
+		} : {
+			type: "end",
+			id: item.id,
+			...item.copyOriginAncestors === void 0 ? {} : { copyOriginAncestors: item.copyOriginAncestors }
+		};
+		return schema.nodes[inline ? BOOKMARK_BOUNDARY_NODE_NAME : BLOCK_BOOKMARK_BOUNDARY_NODE_NAME]?.create(attrs);
+	}
+	if (isComment(item)) return void 0;
+	return schema.nodes[inline ? MOVE_RANGE_BOUNDARY_NODE_NAME : BLOCK_MOVE_RANGE_BOUNDARY_NODE_NAME]?.create({ marker: item });
+};
+/** Range boundary nodes, as the nodes that stand for them between blocks. */
+const blockBoundariesOf = (nodes) => nodes.flatMap((node) => rangeBoundaryItemsOf(node).flatMap((item) => {
+	const block = boundaryNode(item, node.type.schema, false);
+	return block === void 0 ? [] : [block];
+}));
+/** Whether `node` holds a comment's anchor, which only a paragraph holds. */
+const carriesCommentAnchor = (node) => node.type.name === "commentReference" || rangeBoundaryItemsOf(node).some(isComment);
+/** Whether `node` is a range boundary standing between blocks. */
+const isBlockBoundaryNode = (node) => node != null && !node.isInline && rangeBoundaryItemsOf(node).length > 0;
+/**
+* The inline form of range boundaries between blocks whose paragraph break
+* goes, so they stand between the joined paragraphs' content; `null` when
+* one of `blocks` is not such a boundary.
+*/
+const inlineBoundariesOf = (blocks) => {
+	const inline = [];
+	for (const block of blocks) {
+		if (!isBlockBoundaryNode(block)) return null;
+		for (const item of rangeBoundaryItemsOf(block)) {
+			const node = boundaryNode(item, block.type.schema, true);
+			if (node === void 0) return null;
+			inline.push(node);
+		}
+	}
+	return inline;
+};
+/**
+* What `paragraph` leaves where it was when it goes whole, by the engine's
+* own rule (`paragraphRemains`): before a table, its bookmark and move range
+* boundaries as block nodes in its place (`blocks`), unless a comment needs
+* the paragraph before it, which takes every carrier in source order
+* (`comments`); ending its
+* container, every node carrying a boundary (`inline`), for the paragraph
+* before it.
+*/
+const paragraphRemainsOf = (paragraph) => {
+	const items = [];
+	const inline = [];
+	paragraph.descendants((node) => {
+		const carried = rangeBoundaryItemsOf(node);
+		const remains = carried.length > 0 ? copyOriginBoundaryAfterRemovingAddedAncestors(node) : node;
+		if ((carried.length > 0 || node.type.name === "commentReference") && remains !== null) inline.push(remains);
+		if (remains !== null) items.push(...rangeBoundaryItemsOf(remains));
+		if (node.type.name === "commentReference") items.push({
+			type: "commentReference",
+			id: expectCommentReferenceAttrs(node).commentId
+		});
+		return true;
+	});
+	const remains = paragraphRemains(items);
+	if (remains.placement === "previous") return {
+		blocks: [],
+		comments: inline,
+		inline
+	};
+	return {
+		blocks: remains.blocks.flatMap((item) => {
+			const block = boundaryNode(item, paragraph.type.schema, false);
+			return block === void 0 ? [] : [block];
+		}),
+		comments: [],
+		inline
+	};
+};
+/** The revision marks of `anchor`, with the other marks of `node`. */
+const marksBeside = (node, anchor) => [...node.marks.filter((mark) => !REVISION_MARK_NAMES.has(mark.type.name)), ...anchor.marks.filter((mark) => REVISION_MARK_NAMES.has(mark.type.name))];
+/**
+* The kept boundary `moving` names, moved beside the other end of its range,
+* `anchor`: the same node, its attributes and its own marks, inside the
+* revisions `anchor` stands in, as the engine moves a boundary in among its
+* anchor's wrappers.
+*/
+const movedBeside = (moving, anchor) => rangeBoundaryItemsOf(moving.node).length === 1 ? moving.node.mark(marksBeside(moving.node, anchor)) : pointRangeHalf(moving.node, moving.item, marksBeside(moving.node, anchor));
+/**
+* Make every range a rejection kept boundaries of well-formed, by the
+* engine's own plan (`planWellFormedRanges`): `kept` holds the nodes
+* {@link removeResolvedSubtree} kept, found in `tr.doc` as themselves. The plan
+* runs once over every boundary in document order and names each by its
+* place in that list, as the engine names its own, so applying it never
+* reads a position the repair itself moved.
+*/
+const normalizeKeptRangeBoundaries = (tr, kept) => {
+	if (kept.size > 0) wellFormKeptRangeBoundaries(tr, kept);
+	collapseEmptyMoveRanges(tr);
+};
+/**
+* A move range whose start and end a resolution left side by side, with
+* nothing between, as one point anchor: the node a reopened package reads
+* that empty range as, so the resolved document has the same shape live and
+* after a save. Only a start directly followed by its own end collapses; the
+* order of any other markers stays as the engine leaves it.
+*/
+const collapseEmptyMoveRanges = (tr) => {
+	const anchorType = tr.doc.type.schema.nodes[RANGE_ANCHOR_NODE_NAME];
+	if (anchorType === void 0) return;
+	const pairs = [];
+	tr.doc.descendants((node, position) => {
+		if (!node.isTextblock) return true;
+		let previous;
+		node.forEach((child, offset) => {
+			const childPosition = position + 1 + offset;
+			if (previous !== void 0 && child.type.name === "moveRangeBoundary" && previous.node.type.name === "moveRangeBoundary") {
+				const start = expectMoveRangeBoundaryAttrs(previous.node);
+				const end = expectMoveRangeBoundaryAttrs(child);
+				if (start.id === end.id && (start.type === "moveFromRangeStart" && end.type === "moveFromRangeEnd" || start.type === "moveToRangeStart" && end.type === "moveToRangeEnd")) {
+					pairs.push({
+						position: previous.position,
+						start: previous.node,
+						end: child
+					});
+					previous = void 0;
+					return;
+				}
+			}
+			previous = {
+				node: child,
+				position: childPosition
+			};
+		});
+		return false;
+	});
+	for (const { position, start, end } of pairs.toReversed()) {
+		const anchored = planEmptyRanges([expectMoveRangeBoundaryAttrs(start), expectMoveRangeBoundaryAttrs(end)]).anchorAt.get(0);
+		if (anchored === void 0) continue;
+		tr.replaceWith(position, position + start.nodeSize + end.nodeSize, anchorType.create(anchored, null, start.marks));
+	}
+};
+const wellFormKeptRangeBoundaries = (tr, kept) => {
+	const found = boundariesIn(tr.doc, kept);
+	const plan = planWellFormedRanges(found.map(({ occurrence }) => occurrence));
+	const leaving = new Set(plan.dropped);
+	for (const { moving } of plan.moved) leaving.add(moving);
+	const edits = [];
+	const byNode = /* @__PURE__ */ new Map();
+	for (const [index, { position }] of found.entries()) byNode.set(position, [...byNode.get(position) ?? [], index]);
+	for (const [position, indices] of byNode) {
+		const staying = indices.filter((index) => !leaving.has(index));
+		const node = found[indices[0] ?? -1]?.node;
+		if (node === void 0 || staying.length === indices.length) continue;
+		const half = staying.length === 1 ? found[staying[0] ?? -1] : void 0;
+		edits.push(half === void 0 ? {
+			kind: "delete",
+			position,
+			node
+		} : {
+			kind: "narrow",
+			position,
+			node,
+			half: half.item
+		});
+	}
+	for (const { moving: movingIndex, anchor: anchorIndex, side } of plan.moved) {
+		const moving = found[movingIndex];
+		const anchor = found[anchorIndex];
+		const moved = moving === void 0 || anchor === void 0 ? void 0 : movedBeside(moving, anchor.node);
+		if (anchor !== void 0 && moved !== void 0) edits.push({
+			kind: "move",
+			position: side === "after" ? anchor.position + anchor.node.nodeSize : anchor.position,
+			node: moved
+		});
+	}
+	const order = (edit) => edit.kind === "move" ? 1 : 0;
+	for (const edit of edits.toSorted((left, right) => right.position - left.position || order(left) - order(right))) if (edit.kind === "move") tr.insert(edit.position, edit.node);
+	else if (edit.kind === "delete") tr.delete(edit.position, edit.position + edit.node.nodeSize);
+	else {
+		const half = pointRangeHalf(edit.node, edit.half, edit.node.marks);
+		if (half === void 0) tr.delete(edit.position, edit.position + edit.node.nodeSize);
+		else tr.replaceWith(edit.position, edit.position + edit.node.nodeSize, half);
+	}
+};
+/** Whether resolving `layer` by `mode` takes its content out. */
+const revisionLayerRemovesContent = (layer, mode) => mode === "accept" ? layer.type === "deletion" || layer.type === "moveFrom" : layer.type === "insertion" || layer.type === "moveTo";
+const layerKey = (layer) => `${layer.type}:${layer.revisionId}`;
+/**
+* The revision marks a boundary carries where `removed` stood: of each of
+* its revision marks, the layers outside the outermost one this resolution
+* takes content out by, less those it resolves. A revision nested inside
+* removed content goes with that content, as the engine's wrappers do.
+*/
+const landingMarks = (removed, selection) => removed.marks.flatMap((mark) => {
+	if (!REVISION_MARK_NAMES.has(mark.type.name)) return [];
+	const path = trackedRevisionPathOf(mark);
+	const cut = path.findIndex((layer) => selection.resolves(layer.revisionId) && revisionLayerRemovesContent(layer, selection.mode));
+	const standing = new Set((cut === -1 ? path : path.slice(0, cut)).filter((layer) => !selection.resolves(layer.revisionId)).map(layerKey));
+	if (standing.size === path.length) return [mark];
+	const landing = retainedTrackedRevisionMark(mark, (layer) => standing.has(layerKey(layer)));
+	return landing === null ? [] : [landing];
+});
+/**
+* Marks that say which content a range covers. A kept boundary is no content,
+* so it carries none: a comment whose content went goes with it, as in the
+* engine, whose comment anchors are boundaries of their own.
+*/
+const COVERAGE_MARK_NAMES = /* @__PURE__ */ new Set(["comment"]);
+/**
+* Remove `node` and everything in it. Rejecting keeps every range boundary
+* within it, at any depth, as the engine's `removedContentBoundaries` does;
+* accepting keeps none, as a direct deletion does. A kept boundary keeps its
+* own other marks and carries the revisions of where `node` stood
+* ({@link landingMarks}), never one from inside the removed content. Each
+* kept node is a new node, so the range repair can tell it from a boundary
+* that was already standing.
+*/
+const removeResolvedSubtree = (node, selection) => {
+	const kept = [];
+	const landing = landingMarks(node, selection);
+	const visit = (candidate) => {
+		if (keepsRangeBoundary(candidate)) {
+			const withResolvedCopyOrigin = copyOriginBoundaryAfterResolution(candidate, selection);
+			if (withResolvedCopyOrigin === null) return;
+			const keptNode = withResolvedCopyOrigin.type.create(withResolvedCopyOrigin.attrs, null, [...candidate.marks.filter((mark) => !REVISION_MARK_NAMES.has(mark.type.name) && !COVERAGE_MARK_NAMES.has(mark.type.name)), ...landing]);
+			keptRevisionDates.set(keptNode, removingRevisionDate(candidate.marks.some((mark) => REVISION_MARK_NAMES.has(mark.type.name)) ? candidate : node, selection));
+			kept.push(keptNode);
+			return;
+		}
+		candidate.forEach(visit);
+	};
+	if (selection.mode === "reject") visit(node);
+	return { kept };
+};
+//#endregion
+export { blockBoundariesOf, carriesCommentAnchor, inlineBoundariesOf, isBlockBoundaryNode, normalizeKeptRangeBoundaries, paragraphRemainsOf, rangeBoundaryItemsOf, removeResolvedSubtree, revisionLayerRemovesContent };

package/dist/prosemirror/listAutoformatMarkers.d.ts

@@ -4,7 +4,7 @@ import { ListRequest } from "./listNumbering.js";
  * A marker plus the space that triggers the conversion. The text before the
  * caret must be exactly this, so a marker typed mid-paragraph never matches.
  */
-declare const LIST_MARKER_PATTERN: RegExp;
+export declare const LIST_MARKER_PATTERN: RegExp;
 /**
  * The lists `text` (the paragraph's text up to and including the typed space)
  * may ask for, most likely first, or `null` when it is not a marker.
@@ -14,6 +14,5 @@ declare const LIST_MARKER_PATTERN: RegExp;
  * letters. The caller prefers whichever interpretation a neighbouring list
  * already has, and otherwise takes the first.
  */
-declare const listRequestsForMarker: (text: string) => ListRequest[] | null;
-//#endregion
-export { LIST_MARKER_PATTERN, listRequestsForMarker };
+export declare const listRequestsForMarker: (text: string) => ListRequest[] | null;
+//#endregion

package/dist/prosemirror/listInstanceReferences.d.ts

@@ -2,11 +2,10 @@ import { document_d_exports } from "../types/document.js";
 import { Node } from "prosemirror-model";
 //#region src/prosemirror/listInstanceReferences.d.ts
 /** The instances one paragraph names, live or as a tracked change's previous state. */
-declare const paragraphListReferences: (node: Node) => number[];
+export declare const paragraphListReferences: (node: Node) => number[];
 /**
  * `definitions` plus every instance `doc` references and only its paragraphs
  * define: what the package's numbering part has to hold for `doc` to save.
  */
-declare const completeNumberingForDoc: (definitions: document_d_exports.NumberingDefinitions | undefined, doc: Node) => document_d_exports.NumberingDefinitions | undefined;
-//#endregion
-export { completeNumberingForDoc, paragraphListReferences };
+export declare const completeNumberingForDoc: (definitions: document_d_exports.NumberingDefinitions | undefined, doc: Node) => document_d_exports.NumberingDefinitions | undefined;
+//#endregion

package/dist/prosemirror/listInstanceReferences.js

@@ -15,7 +15,7 @@ const collectReference = (attrs, sink) => {
 		numPrFromStyle: attrs.numPrFromStyle
 	}));
 	if (numbering === void 0 || sink.isDefined(numbering.numId)) return;
-	if (!hasListRendering(attrs)) return;
+	if (attrs.listMarkerHidden === true || !hasListRendering(attrs)) return;
 	sink.references.push({
 		numId: numbering.numId,
 		ilvl: numbering.ilvl,

package/dist/prosemirror/listLabels.d.ts

@@ -1,7 +1,9 @@
 import { document_d_exports } from "../types/document.js";
 import { ParagraphNumberingSources } from "./numberingAttr.js";
 import { ParagraphAttrs } from "./schema/nodes.js";
+import { NumberingMap } from "../docx/numberingParser.js";
 import { ListCounterStreams } from "./listMarker.js";
+import { ResolvedParagraphNumbering } from "@stll/docx-core/model";
 //#region src/prosemirror/listLabels.d.ts
 /**
  * The attrs the counter reads for a paragraph of the document model, as
@@ -9,17 +11,25 @@ import { ListCounterStreams } from "./listMarker.js";
  * attrs no label depends on: a reader that walks the model (Markdown) counts
  * every list paragraph through here.
  */
-declare const listLabelAttrsFromRendering: (rendering: document_d_exports.ListRendering | undefined, { numPr, numPrFromStyle }: ParagraphNumberingSources) => ParagraphAttrs;
+export declare const listLabelAttrsFromRendering: (rendering: document_d_exports.ListRendering | undefined, { numPr, numPrFromStyle }: ParagraphNumberingSources) => ParagraphAttrs;
+type VisibleListLabel = {
+  kind: "none" | "markerless" | "marker";
+  label: string | undefined;
+  /** The revision-selected reference whose marker was counted for display. */
+  numbering: Extract<ResolvedParagraphNumbering, {
+    kind: "reference";
+  }> | undefined;
+};
 /**
  * Advances past one paragraph and answers the label it shows, or `undefined`
- * when it shows none.
+ * when it shows none, with the numbering that label is counted in.
  */
-type ListLabelCounter = (attrs: Readonly<ParagraphAttrs>) => string | undefined;
+export type ListLabelCounter = (attrs: Readonly<ParagraphAttrs>, standaloneRendering?: document_d_exports.ListRendering) => VisibleListLabel;
 /**
  * A counter over paragraph attrs in document order. Call it for every
  * paragraph, numbered or not: whether a list continues depends on what stands
  * between its items.
  */
-declare const createListLabelCounter: (streams?: ListCounterStreams) => ListLabelCounter;
+export declare const createListLabelCounter: (numberingOrStreams?: NumberingMap | ListCounterStreams | null, suppliedStreams?: ListCounterStreams) => ListLabelCounter;
 //#endregion
-export { ListLabelCounter, createListLabelCounter, listLabelAttrsFromRendering };
+export {};