@stll/folio-core 0.61.0 → 0.63.0

package/dist/prosemirror/findReplaceSelection.js

@@ -1,6 +1,6 @@
-import { findAllMatches } from "../utils/findReplace.js";
-import { decodeOoxmlSymbolCharacter } from "../utils/ooxmlSymbol.js";
-import { expectSymbolAttrs } from "./attrs/index.js";
+import { findAllMatches, findInDocument, isPageDependentSearchField } from "../utils/findReplace.js";
+import { expectFieldAttrs } from "./attrs/index.js";
+import { getInlineDisplayText, getInlineDisplayToken, isNoteReferenceText } from "./inlineDisplayText.js";
 import { projectMarkupView } from "./markupViewProjection.js";
 //#region src/prosemirror/findReplaceSelection.ts
 function resolveFindMatchRange(doc, match) {
@@ -17,11 +17,29 @@ function resolveFindMatchRange(doc, match) {
 	});
 	return resolved;
 }
+/** Resolve a result set in one paragraph traversal, preserving result order. */
+const resolveFindMatchRanges = (doc, matches) => {
+	const paragraphs = /* @__PURE__ */ new Map();
+	forEachSearchParagraph(doc, (paragraph, paragraphPos, paragraphIndex) => {
+		paragraphs.set(paragraphIndex, {
+			paragraph,
+			paragraphPos
+		});
+		return true;
+	});
+	return matches.map((match) => {
+		const paragraph = paragraphs.get(match.paragraphIndex);
+		return paragraph ? resolveTextRangeInParagraph({
+			...paragraph,
+			...match
+		}) : null;
+	});
+};
 function findInProseMirrorDocument(doc, searchText, options) {
 	if (!searchText) return [];
 	const matches = [];
 	forEachSearchParagraph(doc, (paragraph, paragraphPos, paragraphIndex) => {
-		const text = getSearchableParagraphText(paragraph);
+		const text = getInlineDisplayText(paragraph);
 		for (const { start, end } of findAllMatches(text, searchText, options)) {
 			const range = resolveTextRangeInParagraph({
 				paragraph,
@@ -45,14 +63,95 @@ function findInProseMirrorDocument(doc, searchText, options) {
 const findInMarkupView = ({ state, markupView, searchText, options }) => {
 	const projection = projectMarkupView(state, markupView);
 	if (projection.type === "authored") return findInProseMirrorDocument(state.doc, searchText, options);
-	return findInProseMirrorDocument(projection.doc, searchText, options).map((match) => ({
+	return findInProseMirrorDocument(projection.doc, searchText, options).map((match) => toAuthoredFindMatch(projection, match));
+};
+/** Every view-document position a match carries, mapped to the authored editor document. */
+const toAuthoredFindMatch = (projection, match) => {
+	const toEditorRange = ({ from, to }) => ({
+		from: projection.toEditor(from, 1),
+		to: projection.toEditor(to, -1)
+	});
+	return {
 		paragraphIndex: match.paragraphIndex,
 		startOffset: match.startOffset,
 		endOffset: match.endOffset,
 		text: match.text,
-		from: projection.toEditor(match.from, 1),
-		to: projection.toEditor(match.to, -1)
-	}));
+		...toEditorRange(match),
+		...match.excludedRanges && { excludedRanges: match.excludedRanges.map(toEditorRange) },
+		...match.atomicTextRanges && { atomicTextRanges: match.atomicTextRanges.map((atom) => ({
+			...toEditorRange(atom),
+			startOffset: atom.startOffset,
+			endOffset: atom.endOffset
+		})) }
+	};
+};
+/** Replacement policy for a projected body match, in the shared eligibility vocabulary. */
+const projectedReplacement = (state, viewMatch, authored) => {
+	const atom = authored.atomicTextRanges?.at(0);
+	if (atom) return {
+		status: "blocked",
+		reason: state.doc.nodeAt(atom.from)?.type.name === "field" ? "field-result" : "atomic-content"
+	};
+	return authored.to - authored.from === viewMatch.to - viewMatch.from ? { status: "allowed" } : {
+		status: "blocked",
+		reason: "hidden-content"
+	};
+};
+/**
+* Search every story a display mode shows. All Markup searches the package
+* stories. A resolved review view searches its body through the projection the
+* layout paints, so body ranges address the authored editor document; anchored
+* shapes, headers, footers, notes and comments keep the package search owner
+* with the same display mode. Returns null while a review view has no body
+* editor state to project.
+*/
+const findInDisplayedDocument = ({ document, state, searchText, options, context }) => {
+	const displayMode = options.displayMode ?? "all-markup";
+	if (displayMode === "all-markup" || state === void 0) return findInDocument(document, searchText, options, context);
+	if (state === null) return null;
+	const packageMatches = findInDocument(document, searchText, options, context);
+	const projection = projectMarkupView(state, displayMode);
+	if (projection.type === "authored" || !searchText) return packageMatches;
+	const bodyMatches = findInProseMirrorDocument(projection.doc, searchText, options).map((viewMatch) => {
+		const authored = toAuthoredFindMatch(projection, viewMatch);
+		const { from, to, excludedRanges, atomicTextRanges } = authored;
+		return {
+			paragraphIndex: authored.paragraphIndex,
+			contentIndex: 0,
+			startOffset: authored.startOffset,
+			endOffset: authored.endOffset,
+			text: authored.text,
+			story: "main",
+			replacement: projectedReplacement(state, viewMatch, authored),
+			authoredRange: {
+				from,
+				to,
+				...excludedRanges && { excludedRanges },
+				...atomicTextRanges && { atomicTextRanges }
+			}
+		};
+	});
+	const anchorEnds = [];
+	forEachSearchParagraph(state.doc, (paragraph, paragraphPos, paragraphIndex) => {
+		anchorEnds[paragraphIndex] = paragraphPos + paragraph.nodeSize;
+		return true;
+	});
+	const bodyShapeMatches = packageMatches.filter((match) => match.story === "main" && match.textBoxIndex !== void 0);
+	const orderedBody = [];
+	let shapeIndex = 0;
+	const shapeAnchorEnd = (match) => match.anchorParagraphIndex !== void 0 && anchorEnds[match.anchorParagraphIndex] || Number.POSITIVE_INFINITY;
+	for (const bodyMatch of bodyMatches) {
+		const from = bodyMatch.authoredRange?.from ?? 0;
+		while (shapeIndex < bodyShapeMatches.length) {
+			const shapeMatch = bodyShapeMatches[shapeIndex];
+			if (!shapeMatch || shapeAnchorEnd(shapeMatch) > from) break;
+			orderedBody.push(shapeMatch);
+			shapeIndex++;
+		}
+		orderedBody.push(bodyMatch);
+	}
+	orderedBody.push(...bodyShapeMatches.slice(shapeIndex));
+	return [...orderedBody, ...packageMatches.filter((match) => match.story !== "main" || match.textBoxIndex === void 0 && match.commentId !== void 0)];
 };
 function forEachSearchParagraph(doc, visit) {
 	let paragraphIndex = 0;
@@ -103,54 +202,56 @@ function resolveTextRangeInParagraph({ paragraph, paragraphPos, startOffset, end
 		to: null
 	};
 	const pageBreakOffsets = [];
+	const excludedTextRanges = [];
+	const excludedRanges = [];
+	const atomicTextRanges = [];
 	paragraph.descendants((node, pos) => {
+		if ((node.type.name === "field" || node.type.name === "structuredField") && isPageDependentSearchField(expectFieldAttrs(node).instruction)) {
+			const length = node.type.name === "field" ? expectFieldAttrs(node).displayText.length : getInlineDisplayText(node).length;
+			excludedTextRanges.push({
+				start: textOffset,
+				end: textOffset + length
+			});
+		}
 		if (node.type.name === "pageBreakRun") {
 			pageBreakOffsets.push(textOffset);
 			return false;
 		}
+		if (isNoteReferenceText(node)) {
+			const from = paragraphPos + 1 + pos;
+			excludedRanges.push({
+				from,
+				to: from + node.nodeSize
+			});
+		}
 		const tokenLength = getSearchTextTokenLength(node);
 		if (tokenLength === 0) return true;
 		const textStart = textOffset;
 		const textEnd = textStart + tokenLength;
 		const nodeStart = paragraphPos + 1 + pos;
-		if (range.from === null && startOffset >= textStart && startOffset < textEnd) range.from = nodeStart + Math.min(startOffset - textStart, node.nodeSize);
-		if (range.to === null && endOffset > textStart && endOffset <= textEnd) range.to = nodeStart + Math.min(endOffset - textStart, node.nodeSize);
+		const atomic = node.type.name === "field" || node.type.name === "preservedXml";
+		if (atomic && textStart < endOffset && textEnd > startOffset) atomicTextRanges.push({
+			from: nodeStart,
+			to: nodeStart + node.nodeSize,
+			startOffset: Math.max(0, startOffset - textStart),
+			endOffset: Math.min(tokenLength, endOffset - textStart)
+		});
+		if (range.from === null && startOffset >= textStart && startOffset < textEnd) range.from = atomic ? nodeStart : nodeStart + Math.min(startOffset - textStart, node.nodeSize);
+		if (range.to === null && endOffset > textStart && endOffset <= textEnd) range.to = atomic ? nodeStart + node.nodeSize : nodeStart + Math.min(endOffset - textStart, node.nodeSize);
 		textOffset = textEnd;
 		return range.to === null;
 	});
-	if (range.from === null || range.to === null || range.from >= range.to || pageBreakOffsets.some((offset) => offset > startOffset && offset < endOffset)) return null;
+	if (range.from === null || range.to === null || range.from >= range.to || pageBreakOffsets.some((offset) => offset > startOffset && offset < endOffset) || excludedTextRanges.some(({ start, end }) => start < endOffset && end > startOffset)) return null;
+	const from = range.from;
+	const to = range.to;
+	const visibleExcludedRanges = excludedRanges.filter((anchor) => anchor.from < to && anchor.to > from);
 	return {
-		from: range.from,
-		to: range.to
+		from,
+		to,
+		...atomicTextRanges.length > 0 && { atomicTextRanges },
+		...visibleExcludedRanges.length > 0 && { excludedRanges: visibleExcludedRanges }
 	};
 }
-function getSearchTextTokenLength(node) {
-	if (node.isText) return node.text?.length ?? 0;
-	if (node.type.name === "tab" || node.type.name === "hardBreak" || node.type.name === "symbol") return 1;
-	return 0;
-}
-function getSearchableParagraphText(paragraph) {
-	let text = "";
-	paragraph.descendants((node) => {
-		if (node.isText) {
-			text += node.text ?? "";
-			return false;
-		}
-		if (node.type.name === "tab") {
-			text += "	";
-			return false;
-		}
-		if (node.type.name === "hardBreak") {
-			text += "\n";
-			return false;
-		}
-		if (node.type.name === "symbol") {
-			text += decodeOoxmlSymbolCharacter(expectSymbolAttrs(node).char) ?? "";
-			return false;
-		}
-		return true;
-	});
-	return text;
-}
+const getSearchTextTokenLength = (node) => getInlineDisplayToken(node)?.length ?? 0;
 //#endregion
-export { findInMarkupView, findInProseMirrorDocument, resolveFindMatchRange };
+export { findInDisplayedDocument, findInMarkupView, findInProseMirrorDocument, resolveFindMatchRange, resolveFindMatchRanges };

package/dist/prosemirror/hyperlinkRemoval.d.ts

@@ -2,7 +2,7 @@ import { Node } from "prosemirror-model";
 import { EditorState, Transaction } from "prosemirror-state";
 //#region src/prosemirror/hyperlinkRemoval.d.ts
 declare const HyperlinkRemovalRefusal_base: import("better-result").TaggedErrorClass<"HyperlinkRemovalRefusal">;
-declare class HyperlinkRemovalRefusal extends HyperlinkRemovalRefusal_base<{
+export declare class HyperlinkRemovalRefusal extends HyperlinkRemovalRefusal_base<{
   message: string;
 }> {}
 type HyperlinkRemovalRangeOptions = {
@@ -11,11 +11,11 @@ type HyperlinkRemovalRangeOptions = {
   to: number;
 };
 /** Canonical inline elements have no addressable interior gaps. */
-declare const assertHyperlinkRemovalRange: ({ doc, from, to }: HyperlinkRemovalRangeOptions) => void;
+export declare const assertHyperlinkRemovalRange: ({ doc, from, to }: HyperlinkRemovalRangeOptions) => void;
 /**
  * Remove the hyperlinks from [`from`, `to`) of `tr.doc`: directly, or, with
  * suggestions on, as a tracked replacement of the linked text by plain text.
  */
-declare const removeHyperlinkInRange: (state: EditorState, tr: Transaction, from: number, to: number) => Transaction;
+export declare const removeHyperlinkInRange: (state: EditorState, tr: Transaction, from: number, to: number) => Transaction;
 //#endregion
-export { HyperlinkRemovalRefusal, assertHyperlinkRemovalRange, removeHyperlinkInRange };
+export {};

package/dist/prosemirror/hyperlinkRemoval.js

@@ -5,6 +5,18 @@ import { readAuthoredRunFormatting, reconcileRunFormattingMarks } from "./runFor
 import { paragraphRunStyleContextAt } from "./runStyleFormatting.js";
 import { TaggedError } from "better-result";
 //#region src/prosemirror/hyperlinkRemoval.ts
+/**
+* Removing a hyperlink takes the link and its Hyperlink character style off
+* the text, as the Remove Hyperlink command does; other run formatting stays.
+*
+* A link is a wrapper around its runs, not a run property, so no property
+* revision can record its removal. With suggestions on, the linked text is
+* struck through and the same text follows it as an insertion, without the
+* link. Both carry a run-property change whose previous formatting is the
+* Hyperlink style: the struck text no longer states the style, the inserted
+* text never did. Rejecting brings the link back as it was; accepting leaves
+* the plain text an untracked removal leaves.
+*/
 var HyperlinkRemovalRefusal = class extends TaggedError("HyperlinkRemovalRefusal") {};
 const partialInlineRefusal = () => new HyperlinkRemovalRefusal({ message: "Hyperlink removal cannot split an indivisible inline element." });
 /** Canonical inline elements have no addressable interior gaps. */

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

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

package/dist/prosemirror/inlineDisplayText.js

@@ -0,0 +1,29 @@
+import { decodeOoxmlSymbolCharacter } from "../utils/ooxmlSymbol.js";
+import { expectFieldAttrs, expectPreservedXmlAttrs, expectSymbolAttrs } from "./attrs/index.js";
+//#region src/prosemirror/inlineDisplayText.ts
+/** Native note-reference labels are navigation anchors, outside searchable text. */
+const isNoteReferenceText = (node) => node.isText && node.marks.some((mark) => mark.type.name === "footnoteRef");
+/** A leaf's logical text; null means a transparent container to descend into. */
+const getInlineDisplayToken = (node) => {
+	if (isNoteReferenceText(node)) return "";
+	if (node.type.name === "field") return expectFieldAttrs(node).displayText;
+	if (node.type.name === "preservedXml") return expectPreservedXmlAttrs(node).text;
+	if (node.isText) return node.text ?? "";
+	if (node.type.name === "tab") return "	";
+	if (node.type.name === "hardBreak") return "\n";
+	if (node.type.name === "symbol") return decodeOoxmlSymbolCharacter(expectSymbolAttrs(node).char) ?? "";
+	return null;
+};
+/** Visible inline text, including cached source atoms and native run tokens. */
+const getInlineDisplayText = (paragraph) => {
+	let text = "";
+	paragraph.descendants((node) => {
+		const token = getInlineDisplayToken(node);
+		if (token === null) return true;
+		text += token;
+		return false;
+	});
+	return text;
+};
+//#endregion
+export { getInlineDisplayText, getInlineDisplayToken, isNoteReferenceText };

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