@stll/folio-core 0.62.0 → 0.63.0

package/dist/prosemirror/imageCommit.d.ts

@@ -1,41 +1,23 @@
 import { Node } from "prosemirror-model";
 import { EditorView } from "prosemirror-view";
 //#region src/prosemirror/imageCommit.d.ts
-/**
- * An image resize handle: the 4 corners ('nw'/'ne'/'se'/'sw') resize both axes
- * and keep the aspect ratio; the 4 edge midpoints ('n'/'s'/'e'/'w') resize a
- * single axis so the user can deliberately stretch the image (break aspect).
- */
-type ImageResizeHandle = "nw" | "ne" | "se" | "sw" | "n" | "s" | "e" | "w";
-/**
- * New image dimensions for a resize drag, shared by the React and Vue overlays
- * (issue #266). Corner handles drive both axes (aspect-locked unless
- * `lockAspect` is false, e.g. Shift held); edge handles drive one axis and
- * never lock. The non-driven axis is returned unchanged. Driven axes are
- * clamped to a sane pixel range.
- */
-declare function calculateResizedImageDimensions(handle: ImageResizeHandle, deltaX: number, deltaY: number, startWidth: number, startHeight: number, lockAspect: boolean): {
-  width: number;
-  height: number;
-};
 /** True when the image is floating (anchored) rather than inline. */
-declare function isFloatingImage(node: Node): boolean;
+export declare function isFloatingImage(node: Node): boolean;
 /**
  * Resize commit: set the image node's `width`/`height`. Returns `pmPos` to
  * re-select, or null if the position no longer holds an image.
  */
-declare function commitImageResize(view: EditorView, pmPos: number, newWidth: number, newHeight: number): number | null;
+export declare function commitImageResize(view: EditorView, pmPos: number, newWidth: number, newHeight: number): number | null;
 /**
  * Floating drag commit: rewrite the anchor's margin-relative `position`
  * offsets (in EMU) so the image lands at the drop point while staying
  * floating. Returns `pmPos` to re-select, or null on no-op / failure.
  */
-declare function commitImageFloatMove(view: EditorView, pmPos: number, hOffsetEmu: number, vOffsetEmu: number): number | null;
+export declare function commitImageFloatMove(view: EditorView, pmPos: number, hOffsetEmu: number, vOffsetEmu: number): number | null;
 /**
  * Inline drag commit: move the image node to `dropPos` via a delete + insert
  * pair. Returns the PM position to re-select, or null when the drop is a
  * no-op (same slot) or fails.
  */
-declare function commitImageInlineMove(view: EditorView, pmPos: number, dropPos: number): number | null;
-//#endregion
-export { ImageResizeHandle, calculateResizedImageDimensions, commitImageFloatMove, commitImageInlineMove, commitImageResize, isFloatingImage };
+export declare function commitImageInlineMove(view: EditorView, pmPos: number, dropPos: number): number | null;
+//#endregion

package/dist/prosemirror/imageCommit.js

@@ -1,34 +1,6 @@
 import { allowsDirectDrawingEdit } from "../docx/imageRawXml.js";
 import { expectImageAttrs, mergeImageAttrs } from "./attrs/index.js";
 //#region src/prosemirror/imageCommit.ts
-const MIN_IMAGE_PX = 20;
-const MAX_IMAGE_PX = 2e3;
-/**
-* New image dimensions for a resize drag, shared by the React and Vue overlays
-* (issue #266). Corner handles drive both axes (aspect-locked unless
-* `lockAspect` is false, e.g. Shift held); edge handles drive one axis and
-* never lock. The non-driven axis is returned unchanged. Driven axes are
-* clamped to a sane pixel range.
-*/
-function calculateResizedImageDimensions(handle, deltaX, deltaY, startWidth, startHeight, lockAspect) {
-	const drivesWidth = handle.includes("w") || handle.includes("e");
-	const drivesHeight = handle.includes("n") || handle.includes("s");
-	const isCorner = drivesWidth && drivesHeight;
-	const signX = handle.includes("w") ? -1 : 1;
-	const signY = handle.includes("n") ? -1 : 1;
-	let newWidth = drivesWidth ? startWidth + deltaX * signX : startWidth;
-	let newHeight = drivesHeight ? startHeight + deltaY * signY : startHeight;
-	if (isCorner && lockAspect) {
-		const scale = Math.max(newWidth / startWidth, newHeight / startHeight);
-		newWidth = startWidth * scale;
-		newHeight = startHeight * scale;
-	}
-	const clamp = (n) => Math.max(MIN_IMAGE_PX, Math.min(MAX_IMAGE_PX, n));
-	return {
-		width: drivesWidth ? clamp(newWidth) : startWidth,
-		height: drivesHeight ? clamp(newHeight) : startHeight
-	};
-}
 /** True when the image is floating (anchored) rather than inline. */
 function isFloatingImage(node) {
 	const wrapType = node.attrs["wrapType"];
@@ -117,4 +89,4 @@ function commitImageInlineMove(view, pmPos, dropPos) {
 	}
 }
 //#endregion
-export { calculateResizedImageDimensions, commitImageFloatMove, commitImageInlineMove, commitImageResize, isFloatingImage };
+export { commitImageFloatMove, commitImageInlineMove, commitImageResize, isFloatingImage };

package/dist/prosemirror/imagePictureNames.d.ts

@@ -1,12 +1,11 @@
 import { document_d_exports } from "../types/document.js";
 //#region src/prosemirror/imagePictureNames.d.ts
-declare const PICTURE_NAME_DOM_ATTRIBUTES: {
+export declare const PICTURE_NAME_DOM_ATTRIBUTES: {
   readonly name: "data-picture-name";
   readonly alt: "data-picture-alt";
   readonly title: "data-picture-title";
 };
 /** Keep picture metadata separate from the containing drawing's accessibility strings. */
-declare const pictureNamesFromDom: (element: HTMLElement) => document_d_exports.NonVisualDrawingNames;
-declare const pictureNamesDomAttrs: (names: document_d_exports.NonVisualDrawingNames | undefined) => Record<string, string>;
-//#endregion
-export { PICTURE_NAME_DOM_ATTRIBUTES, pictureNamesDomAttrs, pictureNamesFromDom };
+export declare const pictureNamesFromDom: (element: HTMLElement) => document_d_exports.NonVisualDrawingNames;
+export declare const pictureNamesDomAttrs: (names: document_d_exports.NonVisualDrawingNames | undefined) => Record<string, string>;
+//#endregion

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 };