@stll/folio-core 0.52.0 → 0.53.0

package/dist/prosemirror/plugins/suggestionMode.js

@@ -1,11 +1,14 @@
+import { expectParagraphAttrs } from "../attrs/index.js";
 import { encloseWholeControls } from "../contentControlRevisions.js";
 import { splitBlockClearBorders } from "../extensions/features/BaseKeymapExtension.js";
+import { expandNoteReferenceDeletionRange } from "../extensions/marks/noteReferenceDeletion.js";
 import { handleEditorBeforeInput } from "../textInput.js";
 import { canCarryTrackedRunMark } from "../trackedRunInlineAtoms.js";
 import { mintRevisionId, seedRevisionIdsFromDoc } from "./revisionIds.js";
 import { Mapping } from "prosemirror-transform";
 import { Plugin, PluginKey, TextSelection } from "prosemirror-state";
 import { isHistoryTransaction } from "prosemirror-history";
+import { undoInputRule } from "prosemirror-inputrules";
 //#region src/prosemirror/plugins/suggestionMode.ts
 /**
 * Suggestion Mode Plugin
@@ -22,6 +25,12 @@ import { isHistoryTransaction } from "prosemirror-history";
 const suggestionModeKey = new PluginKey("suggestionMode");
 const SUGGESTION_META = "suggestionModeApplied";
 const SUGGESTION_BYPASS_META = "suggestionModeBypass";
+/**
+* The text a tracked text-input transaction typed. Rules that react to typing
+* (list autoformat) read it, because this plugin claims text input before any
+* input rule sees it.
+*/
+const SUGGESTED_TEXT_INPUT_META = "suggestionModeTextInput";
 function makeMarkAttrs(pluginState) {
 	return {
 		revisionId: mintRevisionId(),
@@ -69,7 +78,8 @@ function findAdjacentRevisionForRange(doc, from, to, markTypeName, author) {
 	return findAdjacentRevision(doc, from, markTypeName, author) ?? findAdjacentRevision(doc, to, markTypeName, author);
 }
 /**
-* Walk a text range and either mark as deletion or retract own insertions.
+* Walk a selected range and track its text, paragraph breaks, and table rows.
+* Retract the current author's own inserted text.
 * Processes in reverse order to maintain position validity.
 */
 function markRangeAsDeleted(tr, doc, from, to, insertionType, deletionType, pluginState) {
@@ -87,12 +97,25 @@ function markRangeAsDeleted(tr, doc, from, to, insertionType, deletionType, plug
 			isOwnInsert
 		});
 	});
-	if (ranges.length === 0) return;
 	const delAttrs = findAdjacentRevisionForRange(doc, from, to, "deletion", pluginState.author) || makeMarkAttrs(pluginState);
+	doc.nodesBetween(from, to, (node, pos) => {
+		if (node.type.name === "tableRow" && pos >= from && pos + node.nodeSize <= to && node.attrs["trIns"] == null && node.attrs["trDel"] == null) tr.setNodeAttribute(pos, "trDel", delAttrs);
+		if (node.type.name !== "paragraph") return;
+		const boundary = pos + node.nodeSize;
+		if (boundary > from && boundary <= to && node.attrs["pPrMark"] == null) tr.setNodeAttribute(pos, "pPrMark", {
+			kind: "del",
+			info: {
+				id: delAttrs.revisionId,
+				author: delAttrs.author,
+				date: delAttrs.date
+			}
+		});
+	});
+	if (ranges.length === 0) return;
 	encloseWholeControls({
 		tr,
-		from: tr.mapping.map(from),
-		to: tr.mapping.map(to, -1),
+		from,
+		to,
 		revisionId: delAttrs.revisionId
 	});
 	for (let i = ranges.length - 1; i >= 0; i--) {
@@ -102,9 +125,8 @@ function markRangeAsDeleted(tr, doc, from, to, insertionType, deletionType, plug
 	}
 }
 /**
-* Add the insertion mark to every run carrier in `[from, to)` that does not
-* already carry a tracked-change mark. Content already carrying a revision is
-* left untouched so another author's attribution is not overwritten.
+* Track every inserted run, paragraph break, and table row in `[from, to)`.
+* Content already carrying a revision keeps its attribution.
 */
 function markRangeAsInserted(tr, doc, from, to, insertionType, deletionType, attrs) {
 	doc.nodesBetween(from, to, (node, pos) => {
@@ -115,6 +137,20 @@ function markRangeAsInserted(tr, doc, from, to, insertionType, deletionType, att
 		if (start >= end) return;
 		tr.addMark(start, end, insertionType.create(attrs));
 	});
+	doc.nodesBetween(from, to, (node, pos) => {
+		if (node.type.name === "paragraph") {
+			const boundary = pos + node.nodeSize;
+			if (boundary > from && boundary < to && node.attrs["pPrMark"] == null) tr.setNodeAttribute(pos, "pPrMark", {
+				kind: "ins",
+				info: {
+					id: attrs.revisionId,
+					author: attrs.author,
+					date: attrs.date
+				}
+			});
+		}
+		if (node.type.name === "tableRow" && pos >= from && pos + node.nodeSize <= to && node.attrs["trIns"] == null && node.attrs["trDel"] == null) tr.setNodeAttribute(pos, "trIns", attrs);
+	});
 	encloseWholeControls({
 		tr,
 		from,
@@ -159,6 +195,7 @@ function applySuggestionInsert(view, from, to, text, pluginState) {
 	if (!insertionType) return false;
 	const tr = view.state.tr;
 	tr.setMeta(SUGGESTION_META, true);
+	tr.setMeta(SUGGESTED_TEXT_INPUT_META, text);
 	const insertAttrs = findAdjacentRevision(view.state.doc, from, "insertion", pluginState.author) || makeMarkAttrs(pluginState);
 	if (from !== to) {
 		const deletionType = view.state.schema.marks["deletion"];
@@ -173,6 +210,19 @@ function applySuggestionInsert(view, from, to, text, pluginState) {
 	return true;
 }
 /**
+* Remove `from`..`to` of `tr.doc` as a suggestion: text the current author
+* inserted is retracted, anything else is marked deleted. `false` when the
+* editor is not suggesting.
+*/
+function suggestRangeDeletion(state, tr, from, to) {
+	const pluginState = suggestionModeKey.getState(state);
+	const insertionType = state.schema.marks["insertion"];
+	const deletionType = state.schema.marks["deletion"];
+	if (!pluginState?.active || !insertionType || !deletionType) return false;
+	markRangeAsDeleted(tr, tr.doc, from, to, insertionType, deletionType, pluginState);
+	return true;
+}
+/**
 * Track-changes Enter: split the paragraph and stamp `pPrMark = 'ins'` on the
 * FIRST half of the split (the upper paragraph), per ECMA-376 §17.13.5. The
 * actual splitting reuses `splitBlockClearBorders` so border/style/stored-mark
@@ -291,7 +341,11 @@ function handleSuggestionDelete(state, dispatch, direction) {
 	const tr = state.tr;
 	tr.setMeta(SUGGESTION_META, true);
 	if (!empty) {
-		markRangeAsDeleted(tr, state.doc, $from.pos, $to.pos, insertionType, deletionType, pluginState);
+		const ranges = state.selection.ranges.map(({ $from: rangeFrom, $to: rangeTo }) => expandNoteReferenceDeletionRange(state.doc, rangeFrom.pos, rangeTo.pos) ?? {
+			from: rangeFrom.pos,
+			to: rangeTo.pos
+		}).sort((a, b) => b.from - a.from);
+		for (const { from, to } of ranges) markRangeAsDeleted(tr, state.doc, from, to, insertionType, deletionType, pluginState);
 		const cursorPos = tr.mapping.map($to.pos);
 		tr.setSelection(TextSelection.near(tr.doc.resolve(cursorPos)));
 		dispatch(tr.scrollIntoView());
@@ -301,22 +355,27 @@ function handleSuggestionDelete(state, dispatch, direction) {
 	const deletePos = isBackward ? $from.pos - 1 : $from.pos;
 	const deleteEnd = isBackward ? $from.pos : $from.pos + 1;
 	if (deletePos < 0 || deleteEnd > state.doc.content.size) return true;
-	const nodeAfter = state.doc.resolve(deletePos).nodeAfter;
+	const noteRange = expandNoteReferenceDeletionRange(state.doc, deletePos, deleteEnd);
+	const rangeFrom = noteRange?.from ?? deletePos;
+	const rangeTo = noteRange?.to ?? deleteEnd;
+	const nodeAfter = state.doc.resolve(rangeFrom).nodeAfter;
 	if (!nodeAfter || !canCarryTrackedRunMark(nodeAfter)) return false;
 	const hasOwnInsertion = nodeAfter.marks.some((m) => m.type === insertionType && m.attrs["author"] === pluginState.author);
 	if (nodeAfter.marks.some((m) => m.type === deletionType)) {
-		const newPos = isBackward ? deletePos : deleteEnd;
+		const newPos = isBackward ? rangeFrom : rangeTo;
 		tr.setSelection(TextSelection.near(tr.doc.resolve(newPos)));
-	} else if (hasOwnInsertion) tr.delete(deletePos, deleteEnd);
+	} else if (hasOwnInsertion) tr.delete(rangeFrom, rangeTo);
 	else {
-		const delAttrs = findAdjacentRevisionForRange(state.doc, deletePos, deleteEnd, "deletion", pluginState.author) || makeMarkAttrs(pluginState);
-		tr.addMark(deletePos, deleteEnd, deletionType.create(delAttrs));
-		const newPos = isBackward ? deletePos : deleteEnd;
+		const delAttrs = findAdjacentRevisionForRange(state.doc, rangeFrom, rangeTo, "deletion", pluginState.author) || makeMarkAttrs(pluginState);
+		tr.addMark(rangeFrom, rangeTo, deletionType.create(delAttrs));
+		const newPos = isBackward ? rangeFrom : rangeTo;
 		tr.setSelection(TextSelection.near(tr.doc.resolve(newPos)));
 	}
 	dispatch(tr.scrollIntoView());
 	return true;
 }
+/** Apply the editor's selected-content deletion path for a host cut action. */
+const deleteSelectionAsSuggestion = (state, dispatch) => state.selection.empty ? false : handleSuggestionDelete(state, dispatch, "forward");
 /**
 * Mark the text committed by an IME composition as a tracked insertion.
 *
@@ -329,18 +388,28 @@ function handleSuggestionDelete(state, dispatch, direction) {
 * committed range safely. `markRangeAsInserted` skips nodes that already carry a
 * tracked-change mark, so this is idempotent. eigenpal/docx-editor#938.
 */
-function markComposedAsInsertion(view, from, pluginState) {
+function markComposedAsInsertion(view, from, pluginState, replaced) {
 	const insertionType = view.state.schema.marks["insertion"];
 	const deletionType = view.state.schema.marks["deletion"];
 	if (!insertionType || !deletionType) return;
 	const to = view.state.selection.to;
-	if (to <= from) return;
+	if (to <= from && !replaced) return;
 	const tr = view.state.tr;
 	tr.setMeta(SUGGESTION_META, true);
-	const markAttrs = findAdjacentRevisionForRange(view.state.doc, from, to, "insertion", pluginState.author) || makeMarkAttrs(pluginState);
-	markRangeAsInserted(tr, view.state.doc, from, to, insertionType, deletionType, markAttrs);
+	if (replaced) {
+		tr.insert(from, replaced.content);
+		markRangeAsDeleted(tr, tr.doc, from, from + replaced.content.size, insertionType, deletionType, pluginState);
+	}
+	const insertionFrom = tr.mapping.map(from, 1);
+	const insertionTo = tr.mapping.map(to, 1);
+	if (insertionTo <= insertionFrom) {
+		if (tr.steps.length > 0) view.dispatch(tr);
+		return;
+	}
+	const markAttrs = findAdjacentRevisionForRange(tr.doc, insertionFrom, insertionTo, "insertion", pluginState.author) || makeMarkAttrs(pluginState);
+	markRangeAsInserted(tr, tr.doc, insertionFrom, insertionTo, insertionType, deletionType, markAttrs);
 	if (tr.steps.length === 0) return;
-	const caret = tr.mapping.map(to);
+	const caret = tr.mapping.map(to, 1);
 	tr.setSelection(TextSelection.create(tr.doc, caret));
 	view.dispatch(tr);
 }
@@ -351,6 +420,7 @@ function markComposedAsInsertion(view, from, pluginState) {
 function createSuggestionModePlugin(initialActive = false, author = "User") {
 	let composing = false;
 	let compositionFrom = null;
+	let compositionReplaced = null;
 	return new Plugin({
 		key: suggestionModeKey,
 		state: {
@@ -372,32 +442,32 @@ function createSuggestionModePlugin(initialActive = false, author = "User") {
 		},
 		props: {
 			handleDOMEvents: {
+				cut(view, event) {
+					if (!suggestionModeKey.getState(view.state)?.active || view.state.selection.empty) return false;
+					const data = event.clipboardData;
+					if (!data) return false;
+					const { dom, text } = view.serializeForClipboard(view.state.selection.content());
+					data.clearData();
+					data.setData("text/html", dom.innerHTML);
+					data.setData("text/plain", text);
+					event.preventDefault();
+					return handleSuggestionDelete(view.state, view.dispatch, "forward");
+				},
 				compositionstart(view) {
-					const pluginState = suggestionModeKey.getState(view.state);
-					if (!pluginState?.active) return false;
+					if (!suggestionModeKey.getState(view.state)?.active) return false;
+					if (composing) return false;
 					composing = true;
 					const { from, to } = view.state.selection;
-					if (from !== to) {
-						const insertionType = view.state.schema.marks["insertion"];
-						const deletionType = view.state.schema.marks["deletion"];
-						if (insertionType && deletionType) {
-							const tr = view.state.tr;
-							tr.setMeta(SUGGESTION_META, true);
-							markRangeAsDeleted(tr, view.state.doc, from, to, insertionType, deletionType, pluginState);
-							const caret = tr.mapping.map(to);
-							tr.setSelection(TextSelection.create(tr.doc, caret));
-							view.dispatch(tr);
-							compositionFrom = caret;
-							return false;
-						}
-					}
 					compositionFrom = from;
+					compositionReplaced = from === to ? null : view.state.doc.slice(from, to);
 					return false;
 				},
 				compositionend(view) {
 					const pluginState = suggestionModeKey.getState(view.state);
 					const from = compositionFrom;
+					const replaced = compositionReplaced;
 					compositionFrom = null;
+					compositionReplaced = null;
 					if (!pluginState?.active || from == null) {
 						composing = false;
 						return false;
@@ -405,7 +475,7 @@ function createSuggestionModePlugin(initialActive = false, author = "User") {
 					queueMicrotask(() => {
 						try {
 							const current = suggestionModeKey.getState(view.state);
-							if (current?.active) markComposedAsInsertion(view, from, current);
+							if (current?.active) markComposedAsInsertion(view, from, current, replaced);
 						} finally {
 							composing = false;
 						}
@@ -420,8 +490,15 @@ function createSuggestionModePlugin(initialActive = false, author = "User") {
 			handleKeyDown(view, event) {
 				const pluginState = suggestionModeKey.getState(view.state);
 				if (!pluginState?.active) return false;
-				if (event.key === "Enter") return handleSuggestionEnter(view, pluginState);
+				if (event.key === "Enter") {
+					const { $from, empty } = view.state.selection;
+					if (empty && $from.parent.type.name === "paragraph" && expectParagraphAttrs($from.parent).numPr?.kind === "reference") return false;
+					return handleSuggestionEnter(view, pluginState);
+				}
+				if (event.key === "Backspace" && undoInputRule(view.state, view.dispatch)) return true;
 				if (event.key === "Backspace" || event.key === "Delete") {
+					const { $from, empty } = view.state.selection;
+					if (event.key === "Backspace" && empty && $from.parentOffset === 0 && $from.parent.type.name === "paragraph" && expectParagraphAttrs($from.parent).numPr?.kind === "reference") return false;
 					const boundaryTarget = paragraphBoundaryTarget(view.state, event.key === "Backspace" ? "backward" : "forward");
 					if (boundaryTarget !== null) return applyPPrDel(view, boundaryTarget, pluginState);
 					const direction = event.key === "Backspace" ? "backward" : "forward";
@@ -461,20 +538,7 @@ function createSuggestionModePlugin(initialActive = false, author = "User") {
 					const newFrom = following.map(stepFrom, -1);
 					const newTo = following.map(stepTo, 1);
 					if (newTo > newFrom) {
-						newState.doc.nodesBetween(newFrom, newTo, (node, pos) => {
-							if (!canCarryTrackedRunMark(node)) return;
-							if (!node.marks.some((m) => m.type === insertionType || deletionType && m.type === deletionType)) {
-								const nodeStart = Math.max(pos, newFrom);
-								const nodeEnd = Math.min(pos + node.nodeSize, newTo);
-								tr.addMark(nodeStart, nodeEnd, insertionType.create(markAttrs));
-							}
-						});
-						encloseWholeControls({
-							tr,
-							from: newFrom,
-							to: newTo,
-							revisionId: markAttrs.revisionId
-						});
+						if (deletionType) markRangeAsInserted(tr, newState.doc, newFrom, newTo, insertionType, deletionType, markAttrs);
 					}
 				});
 			}
@@ -509,4 +573,4 @@ function isSuggestionModeActive(state) {
 	return suggestionModeKey.getState(state)?.active ?? false;
 }
 //#endregion
-export { SUGGESTION_BYPASS_META, SUGGESTION_META, createSuggestionModePlugin, handleSuggestionEnter, handleSuggestionPaste, isSuggestionModeActive, makeRevisionInfo, paragraphBoundaryTarget, setSuggestionMode, suggestionModeKey, toggleSuggestionMode };
+export { SUGGESTED_TEXT_INPUT_META, SUGGESTION_BYPASS_META, SUGGESTION_META, createSuggestionModePlugin, deleteSelectionAsSuggestion, handleSuggestionEnter, handleSuggestionPaste, isSuggestionModeActive, makeRevisionInfo, paragraphBoundaryTarget, setSuggestionMode, suggestRangeDeletion, suggestionModeKey, toggleSuggestionMode };

package/dist/prosemirror/plugins/templateDirectives.d.ts

@@ -1,6 +1,6 @@
 import { DocScanState } from "./createDocScanPlugin.js";
-import { EditorState, PluginKey } from "prosemirror-state";
 import { Node } from "prosemirror-model";
+import { EditorState, PluginKey } from "prosemirror-state";
 import { DirectiveKind } from "@stll/template-conditions";
 //#region src/prosemirror/plugins/templateDirectives.d.ts
 type DirectiveRange = {

package/dist/prosemirror/plugins/transactionInvariants.d.ts

@@ -0,0 +1,32 @@
+import { EditorState, Plugin, Transaction } from "prosemirror-state";
+//#region src/prosemirror/plugins/transactionInvariants.d.ts
+type TransactionInvariantFlags = {
+  /** Install the invariant plugin in every extension-manager runtime. */
+  enabled?: boolean;
+};
+declare global {
+  var __folioTransactionInvariants: TransactionInvariantFlags | undefined;
+}
+/** Whether new extension-manager runtimes install the invariant plugin. */
+declare const areTransactionInvariantsEnabled: () => boolean;
+type TransactionInvariantIssue = {
+  path: string;
+  message: string;
+  /** Position of the node the issue sits on, when the check knows it. */
+  pos?: number;
+};
+declare class TransactionInvariantError extends Error {
+  readonly issues: readonly TransactionInvariantIssue[];
+  readonly steps: readonly unknown[];
+  constructor(issues: readonly TransactionInvariantIssue[], transactions: readonly Transaction[]);
+}
+/** Every invariant the state breaks; empty when it is sound. */
+declare const checkEditorStateInvariants: (state: EditorState) => TransactionInvariantIssue[];
+/**
+ * Throw a {@link TransactionInvariantError} naming the offending steps when a
+ * document-changing transaction leaves the state with an issue it did not
+ * have before.
+ */
+declare const createTransactionInvariantPlugin: () => Plugin;
+//#endregion
+export { TransactionInvariantError, TransactionInvariantFlags, TransactionInvariantIssue, areTransactionInvariantsEnabled, checkEditorStateInvariants, createTransactionInvariantPlugin };

package/dist/prosemirror/plugins/transactionInvariants.js

@@ -0,0 +1,86 @@
+import { paragraphNumberingReferenceId } from "../../docx/numberingReference.js";
+import { validateProseMirrorDocument } from "../validation.js";
+import { getDocumentNumbering, hasDocumentNumbering } from "./documentNumbering.js";
+import { Plugin, PluginKey } from "prosemirror-state";
+//#region src/prosemirror/plugins/transactionInvariants.ts
+/** Whether new extension-manager runtimes install the invariant plugin. */
+const areTransactionInvariantsEnabled = () => globalThis.__folioTransactionInvariants?.enabled === true;
+const MAX_REPORTED_STEPS_LENGTH = 4e3;
+const describeSteps = (transactions) => {
+	const steps = transactions.flatMap((transaction) => transaction.steps.map((step) => step.toJSON()));
+	const json = JSON.stringify(steps);
+	return json.length > MAX_REPORTED_STEPS_LENGTH ? `${json.slice(0, MAX_REPORTED_STEPS_LENGTH)}… (${json.length} characters)` : json;
+};
+var TransactionInvariantError = class extends Error {
+	issues;
+	steps;
+	constructor(issues, transactions) {
+		super(`A transaction left the editor document invalid:\n${issues.map((issue) => `- ${issue.path}: ${issue.message}`).join("\n")}\nSteps: ${describeSteps(transactions)}`);
+		this.name = "TransactionInvariantError";
+		this.issues = issues;
+		this.steps = transactions.flatMap((transaction) => transaction.steps.map((step) => step.toJSON()));
+	}
+};
+const numberingReferenceIssues = (state) => {
+	if (!hasDocumentNumbering(state)) return [];
+	const numbering = getDocumentNumbering(state);
+	const issues = [];
+	state.doc.descendants((node, pos) => {
+		if (node.type.name !== "paragraph") return true;
+		const numId = paragraphNumberingReferenceId(node.attrs["numPr"]);
+		if (numId !== void 0 && !numbering?.hasNumbering(numId)) issues.push({
+			path: `paragraph at ${pos}.numPr.numId`,
+			message: `Numbering definition ${numId} is missing.`,
+			pos
+		});
+		return false;
+	});
+	return issues;
+};
+/** Every invariant the state breaks; empty when it is sound. */
+const checkEditorStateInvariants = (state) => [...validateProseMirrorDocument(state.doc).issues, ...numberingReferenceIssues(state)];
+/**
+* The issues `after` has that `before` did not. A document can arrive broken
+* (a malformed attribute the editor tolerates); only what a transaction adds
+* is the transaction's fault. An issue that names its node persists only on
+* that node, followed through the transactions' mappings, so moving a broken
+* reference from one paragraph to another still counts as new. Issues without
+* a position are matched by message, since their paths move with the edit.
+*/
+const introducedIssues = (before, after, transactions) => {
+	const mapPosition = (pos) => {
+		let mapped = pos;
+		for (const transaction of transactions) mapped = transaction.mapping.map(mapped, 1);
+		return mapped;
+	};
+	const persisting = /* @__PURE__ */ new Set();
+	const remaining = /* @__PURE__ */ new Map();
+	for (const issue of before) if (issue.pos === void 0) remaining.set(issue.message, (remaining.get(issue.message) ?? 0) + 1);
+	else persisting.add(`${mapPosition(issue.pos)}:${issue.message}`);
+	return after.filter((issue) => {
+		if (issue.pos !== void 0) return !persisting.has(`${issue.pos}:${issue.message}`);
+		const count = remaining.get(issue.message) ?? 0;
+		if (count === 0) return true;
+		remaining.set(issue.message, count - 1);
+		return false;
+	});
+};
+const transactionInvariantsKey = new PluginKey("transactionInvariants");
+/**
+* Throw a {@link TransactionInvariantError} naming the offending steps when a
+* document-changing transaction leaves the state with an issue it did not
+* have before.
+*/
+const createTransactionInvariantPlugin = () => new Plugin({
+	key: transactionInvariantsKey,
+	appendTransaction(transactions, oldState, newState) {
+		if (!transactions.some((transaction) => transaction.docChanged)) return null;
+		const issues = checkEditorStateInvariants(newState);
+		if (issues.length === 0) return null;
+		const introduced = introducedIssues(checkEditorStateInvariants(oldState), issues, transactions);
+		if (introduced.length > 0) throw new TransactionInvariantError(introduced, transactions);
+		return null;
+	}
+});
+//#endregion
+export { TransactionInvariantError, areTransactionInvariantsEnabled, checkEditorStateInvariants, createTransactionInvariantPlugin };

package/dist/prosemirror/positionSweep.d.ts

@@ -0,0 +1,24 @@
+import { Mapping } from "prosemirror-transform";
+//#region src/prosemirror/positionSweep.d.ts
+type PositionQuery = {
+  pos: number;
+  assoc: -1 | 1;
+  /**
+   * Index of the first step map to apply, counting across every mapping
+   * passed in order: the position is in the document that step read.
+   */
+  from: number;
+};
+type SweptPosition = {
+  pos: number;
+  deletedAcross: boolean;
+};
+/**
+ * Map every query through `mappings` (one per transaction, in order), each
+ * entering at its own step. O((positions + steps) x log positions) plus the
+ * positions a step's changed ranges actually cover, rather than
+ * O(positions x steps).
+ */
+declare const sweepPositions: (mappings: readonly Mapping[], queries: readonly PositionQuery[]) => SweptPosition[];
+//#endregion
+export { PositionQuery, SweptPosition, sweepPositions };