@stll/folio-core 0.61.0 → 0.63.0

package/dist/prosemirror/plugins/contentControlWidgets.js

@@ -1,6 +1,7 @@
 import { ContentControlBoundError, ContentControlLockedError, ContentControlTypeError } from "../../content-controls/errors.js";
 import { findBlockSdtMatch, setContentControlValueTr } from "../commands/contentControls.js";
 import { createPluginKeyOwner } from "../pluginKeyOwner.js";
+import { selectLockedInlineControl } from "./lockedControlKeyHandling.js";
 import { Plugin } from "prosemirror-state";
 //#region src/prosemirror/plugins/contentControlWidgets.ts
 /**
@@ -153,13 +154,18 @@ function createContentControlWidgetsPlugin(onEvent = () => void 0) {
 	};
 	return new Plugin({
 		key: contentControlWidgetsPluginKey.createKey(),
-		props: { handleDOMEvents: { click(view, event) {
-			return handleContentControlWidgetClick({
-				view,
-				event,
-				onEvent: (payload) => emit(view, payload)
-			});
-		} } },
+		props: {
+			handleKeyDown(view, event) {
+				return selectLockedInlineControl(view, event);
+			},
+			handleDOMEvents: { click(view, event) {
+				return handleContentControlWidgetClick({
+					view,
+					event,
+					onEvent: (payload) => emit(view, payload)
+				});
+			} }
+		},
 		view() {
 			return {};
 		}

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

@@ -3,11 +3,11 @@ import { Node } from "prosemirror-model";
 import { EditorState, Plugin } from "prosemirror-state";
 //#region src/prosemirror/plugins/createDocScanPlugin.d.ts
 declare const SET_META = "set";
-type DocScanState<TConfig, TRange> = {
+export type DocScanState<TConfig, TRange> = {
   config: TConfig;
   ranges: readonly TRange[];
 };
-type DocScanPluginOptions<TConfig, TRange> = {
+export type DocScanPluginOptions<TConfig, TRange> = {
   key: PluginKeyOwner<DocScanState<TConfig, TRange>>;
   initialConfig: TConfig;
   /** Recompute the ranges from the current doc + config. */
@@ -20,14 +20,14 @@ type DocScanPluginOptions<TConfig, TRange> = {
    */
   onRangesChange?: (ranges: readonly TRange[]) => void;
 };
-declare const createDocScanPlugin: <TConfig, TRange>({ key, initialConfig, scan, onRangesChange }: DocScanPluginOptions<TConfig, TRange>) => Plugin<DocScanState<TConfig, TRange>>;
-declare const setDocScanConfigMeta: <TConfig, TRange>(key: PluginKeyOwner<DocScanState<TConfig, TRange>>, config: TConfig) => {
+export declare const createDocScanPlugin: <TConfig, TRange>({ key, initialConfig, scan, onRangesChange }: DocScanPluginOptions<TConfig, TRange>) => Plugin<DocScanState<TConfig, TRange>>;
+export declare const setDocScanConfigMeta: <TConfig, TRange>(key: PluginKeyOwner<DocScanState<TConfig, TRange>>, config: TConfig) => {
   key: PluginKeyOwner<DocScanState<TConfig, TRange>>;
   payload: {
     type: typeof SET_META;
     config: TConfig;
   };
 };
-declare const getDocScanRanges: <TConfig, TRange>(key: PluginKeyOwner<DocScanState<TConfig, TRange>>, state: EditorState) => readonly TRange[];
+export declare const getDocScanRanges: <TConfig, TRange>(key: PluginKeyOwner<DocScanState<TConfig, TRange>>, state: EditorState) => readonly TRange[];
 //#endregion
-export { DocScanPluginOptions, DocScanState, createDocScanPlugin, getDocScanRanges, setDocScanConfigMeta };
+export {};

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

@@ -1,36 +1,38 @@
 import { document_d_exports } from "../../types/document.js";
 import { NumberingMap } from "../../docx/numberingParser.js";
+import { Node } from "prosemirror-model";
 import { EditorState, Plugin } from "prosemirror-state";
 //#region src/prosemirror/plugins/documentNumbering.d.ts
-declare const createDocumentNumberingPlugin: (definitions: document_d_exports.NumberingDefinitions | null | undefined) => Plugin;
+export declare const createDocumentNumberingPlugin: (definitions: document_d_exports.NumberingDefinitions | null | undefined) => Plugin;
+/** Numbering derived from a document when no editor plugin owns package definitions. */
+export declare const getDocumentNumberingForDoc: (doc: Node) => NumberingMap | null;
 /**
  * The numbering the document's paragraphs resolve against: the package's
  * definitions plus every instance a list command defined in this document.
  * An instance whose paragraphs were all deleted may linger until the next
  * completion; the save completes from the document itself.
  */
-declare const getDocumentNumbering: (state: EditorState) => NumberingMap | null;
+export declare const getDocumentNumbering: (state: EditorState) => NumberingMap | null;
 /** The package's own definitions, without the instances the document defines. */
-declare const getPackageNumberingDefinitions: (state: EditorState) => document_d_exports.NumberingDefinitions | null;
+export declare const getPackageNumberingDefinitions: (state: EditorState) => document_d_exports.NumberingDefinitions | null;
 /**
  * Whether the state knows its document's numbering at all. A state without
  * the plugin cannot tell a package with no numbering part from one it was
  * never told about.
  */
-declare const hasDocumentNumbering: (state: EditorState) => boolean;
+export declare const hasDocumentNumbering: (state: EditorState) => boolean;
 /**
  * The document's numbering definitions: `null` for a document without a
  * numbering part, `undefined` when the state carries no numbering plugin and
  * so cannot say what the document defines.
  */
-declare const getStatedDocumentNumbering: (state: EditorState) => document_d_exports.NumberingDefinitions | null | undefined;
+export declare const getStatedDocumentNumbering: (state: EditorState) => document_d_exports.NumberingDefinitions | null | undefined;
 /**
  * The numbering instances (`w:num` ids) the document defines, or `null` when
  * the state carries no numbering plugin and so cannot say. A document without
  * a numbering part defines none.
  */
-declare const getDocumentNumberingInstanceIds: (state: EditorState) => ReadonlySet<number> | null;
+export declare const getDocumentNumberingInstanceIds: (state: EditorState) => ReadonlySet<number> | null;
 /** Replace numbering state while retaining every unrelated plugin state. */
-declare const withDocumentNumbering: (state: EditorState, definitions: document_d_exports.NumberingDefinitions) => EditorState;
-//#endregion
-export { createDocumentNumberingPlugin, getDocumentNumbering, getDocumentNumberingInstanceIds, getPackageNumberingDefinitions, getStatedDocumentNumbering, hasDocumentNumbering, withDocumentNumbering };
+export declare const withDocumentNumbering: (state: EditorState, definitions: document_d_exports.NumberingDefinitions) => EditorState;
+//#endregion

package/dist/prosemirror/plugins/documentNumbering.js

@@ -4,7 +4,6 @@ import { createPluginKeyOwner } from "../pluginKeyOwner.js";
 import { AddMarkStep, DocAttrStep, RemoveMarkStep, ReplaceAroundStep, ReplaceStep } from "prosemirror-transform";
 import { Plugin } from "prosemirror-state";
 //#region src/prosemirror/plugins/documentNumbering.ts
-/** Document-scoped numbering definitions for list-editing commands. */
 const documentNumberingKey = createPluginKeyOwner("documentNumbering");
 const completedState = (definitions, doc) => {
 	const completed = completeNumberingForDoc(definitions ?? void 0, doc);
@@ -13,52 +12,58 @@ const completedState = (definitions, doc) => {
 		map: completed ? getCachedNumberingMap(completed) : null
 	};
 };
-/** Steps that can change a paragraph's attrs or bring paragraphs in, by what they replace. */
 const isReplace = (step) => step instanceof ReplaceStep || step instanceof ReplaceAroundStep;
-/** Steps that change nothing a numbering reference lives in. */
-const leavesParagraphAttrs = (step) => step instanceof AddMarkStep || step instanceof RemoveMarkStep || step instanceof DocAttrStep;
+const leavesNumberingUnchanged = (step) => step instanceof AddMarkStep || step instanceof RemoveMarkStep || step instanceof DocAttrStep;
+const containsNumberedParagraph = (node, from, to) => {
+	let found = false;
+	node.nodesBetween(from, to, (child, pos) => {
+		if (child.type.name !== "paragraph" || pos < from || pos + child.nodeSize > to || paragraphListReferences(child).length === 0) return !found;
+		found = true;
+		return false;
+	});
+	return found;
+};
 /**
-* Whether `tr` may have introduced a reference `map` does not define. Only the
-* ranges its steps replaced are read, so typing costs one paragraph, not the
-* document. A step that changes attrs in place (not by replacement) is not
-* localised and answers yes.
+* Whether a transaction can change a paragraph-level numbering source. Text
+* and mark edits do not; paragraph attrs and structural replacements do. The
+* latter are inspected in the step-local document rather than by walking the
+* completed document.
 */
-const mayReferenceUnknownInstance = (tr, map) => {
-	const ranges = [];
-	for (const [index, step] of tr.steps.entries()) {
-		if (leavesParagraphAttrs(step)) continue;
-		if (!isReplace(step)) return true;
-		const later = tr.mapping.slice(index + 1);
-		step.getMap().forEach((_oldStart, _oldEnd, newStart, newEnd) => {
-			ranges.push({
-				from: later.map(newStart, -1),
-				to: later.map(newEnd, 1)
-			});
-		});
-	}
-	const size = tr.doc.content.size;
-	const isUnknown = (numId) => !(map?.hasNumbering(numId) ?? false);
-	return ranges.some(({ from, to }) => {
-		let unknown = false;
-		const start = Math.min(Math.max(0, from), size);
-		tr.doc.nodesBetween(start, Math.min(Math.max(start, to), size), (node) => {
-			if (unknown) return false;
-			if (node.type.name !== "paragraph") return true;
-			unknown = paragraphListReferences(node).some(isUnknown);
-			return false;
-		});
-		return unknown;
+const changesNumberingInputs = (tr) => tr.steps.some((step, index) => {
+	if (leavesNumberingUnchanged(step)) return false;
+	if (!isReplace(step)) return true;
+	let insertsNumberedParagraph = false;
+	step.slice.content.descendants((node) => {
+		if (paragraphListReferences(node).length === 0) return !insertsNumberedParagraph;
+		insertsNumberedParagraph = true;
+		return false;
 	});
-};
+	if (insertsNumberedParagraph) return true;
+	const before = tr.docs[index];
+	if (before === void 0) return true;
+	const fromParent = before.resolve(step.from).parent;
+	const toParent = before.resolve(step.to).parent;
+	if (fromParent !== toParent && (paragraphListReferences(fromParent).length > 0 || paragraphListReferences(toParent).length > 0)) return true;
+	return containsNumberedParagraph(before, step.from, step.to);
+});
 const createDocumentNumberingPlugin = (definitions) => new Plugin({
 	key: documentNumberingKey.createKey(),
 	state: {
 		init: (_config, state) => completedState(definitions ?? null, state.doc),
-		apply: (tr, current, _oldState, state) => tr.docChanged && mayReferenceUnknownInstance(tr, current.map) ? completedState(current.definitions, state.doc) : current
+		apply: (tr, current, _oldState, state) => tr.docChanged && changesNumberingInputs(tr) ? completedState(current.definitions, state.doc) : current
 	}
 });
 /** Numbering for states without the plugin, one per document node. */
 const untrackedNumbering = /* @__PURE__ */ new WeakMap();
+/** Numbering derived from a document when no editor plugin owns package definitions. */
+const getDocumentNumberingForDoc = (doc) => {
+	let untracked = untrackedNumbering.get(doc);
+	if (!untracked) {
+		untracked = completedState(null, doc);
+		untrackedNumbering.set(doc, untracked);
+	}
+	return untracked.map;
+};
 /**
 * The numbering the document's paragraphs resolve against: the package's
 * definitions plus every instance a list command defined in this document.
@@ -68,12 +73,7 @@ const untrackedNumbering = /* @__PURE__ */ new WeakMap();
 const getDocumentNumbering = (state) => {
 	const tracked = documentNumberingKey.getState(state);
 	if (tracked) return tracked.map;
-	let untracked = untrackedNumbering.get(state.doc);
-	if (!untracked) {
-		untracked = completedState(null, state.doc);
-		untrackedNumbering.set(state.doc, untracked);
-	}
-	return untracked.map;
+	return getDocumentNumberingForDoc(state.doc);
 };
 /** The package's own definitions, without the instances the document defines. */
 const getPackageNumberingDefinitions = (state) => documentNumberingKey.getState(state)?.definitions ?? null;
@@ -109,4 +109,4 @@ const withDocumentNumbering = (state, definitions) => {
 	return state.reconfigure({ plugins: retained }).reconfigure({ plugins: [...retained, createDocumentNumberingPlugin(definitions)] });
 };
 //#endregion
-export { createDocumentNumberingPlugin, getDocumentNumbering, getDocumentNumberingInstanceIds, getPackageNumberingDefinitions, getStatedDocumentNumbering, hasDocumentNumbering, withDocumentNumbering };
+export { createDocumentNumberingPlugin, getDocumentNumbering, getDocumentNumberingForDoc, getDocumentNumberingInstanceIds, getPackageNumberingDefinitions, getStatedDocumentNumbering, hasDocumentNumbering, withDocumentNumbering };

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

@@ -3,7 +3,7 @@ import { BuiltInStyleIndex } from "../../docx/builtInStyles.js";
 import { StyleResolver } from "../styles/styleResolver.js";
 import { EditorState } from "prosemirror-state";
 //#region src/prosemirror/plugins/documentStyleState.d.ts
-declare const documentStylesKey: Readonly<{
+export declare const documentStylesKey: Readonly<{
   key: string;
   createKey: () => import("prosemirror-state").PluginKey<StyleResolver | null>;
   owns: (plugin: import("prosemirror-state").Plugin<StyleResolver | null>) => boolean;
@@ -11,13 +11,13 @@ declare const documentStylesKey: Readonly<{
   getState: (state: EditorState) => StyleResolver | null | undefined;
 }>;
 /** Read the document's StyleResolver, or null when the plugin isn't installed. */
-declare function getDocumentStyleResolver(state: EditorState): StyleResolver | null;
+export declare function getDocumentStyleResolver(state: EditorState): StyleResolver | null;
 /**
  * The document's style definitions by id, or `null` when the state carries no
  * styles plugin and so cannot say what the document defines. A document
  * without a styles part defines none.
  */
-declare function getDocumentStyleDefinitions(state: EditorState): {
+export declare function getDocumentStyleDefinitions(state: EditorState): {
   get: (styleId: string) => document_d_exports.Style | undefined;
   paragraphStyles: () => document_d_exports.Style[];
 } | null;
@@ -27,6 +27,5 @@ declare function getDocumentStyleDefinitions(state: EditorState): {
  * the plugin every lookup misses, which degrades classification to the
  * paragraph's own outline level rather than to English style ids.
  */
-declare function getDocumentBuiltInStyles(state: EditorState): BuiltInStyleIndex;
-//#endregion
-export { documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleDefinitions, getDocumentStyleResolver };
+export declare function getDocumentBuiltInStyles(state: EditorState): BuiltInStyleIndex;
+//#endregion

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

@@ -5,7 +5,7 @@ import { EditorState, Plugin } from "prosemirror-state";
 //#region src/prosemirror/plugins/documentStyles.d.ts
 type DocumentStylesInput = document_d_exports.StyleDefinitions | StyleResolver | null | undefined;
 /** Canonical projections own formatting; expose the resolver without PM repair transactions. */
-declare const createDocumentStyleContextPlugin: (styles: DocumentStylesInput) => Plugin;
+export declare const createDocumentStyleContextPlugin: (styles: DocumentStylesInput) => Plugin;
 /**
  * Create the plugin holding a StyleResolver for the document's `styles` for
  * the lifetime of the EditorState. The resolver is fixed per document load;
@@ -13,8 +13,8 @@ declare const createDocumentStyleContextPlugin: (styles: DocumentStylesInput) =>
  * fresh resolver. Accepts a pre-built resolver too, for callers that already
  * have one.
  */
-declare function createDocumentStylesPlugin(styles: document_d_exports.StyleDefinitions | StyleResolver | null | undefined): Plugin;
+export declare function createDocumentStylesPlugin(styles: document_d_exports.StyleDefinitions | StyleResolver | null | undefined): Plugin;
 /** Reconfigure so ProseMirror replaces the keyed plugin's resolver state. */
-declare const withDocumentStyles: (state: EditorState, styles: document_d_exports.StyleDefinitions | StyleResolver | null | undefined) => EditorState;
+export declare const withDocumentStyles: (state: EditorState, styles: document_d_exports.StyleDefinitions | StyleResolver | null | undefined) => EditorState;
 //#endregion
-export { createDocumentStyleContextPlugin, createDocumentStylesPlugin, documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleDefinitions, getDocumentStyleResolver, withDocumentStyles };
+export { documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleDefinitions, getDocumentStyleResolver };

package/dist/prosemirror/plugins/documentStyles.js

@@ -38,7 +38,8 @@ const rebaseEditedParagraphJoins = (transactions, tr, resolver) => {
 			const before = transaction.docs[index];
 			if (!before) continue;
 			const map = step.getMap();
-			const mapping = new Mapping([map, ...new Mapping(maps.slice(offset + index + 1)).maps]);
+			const following = new Mapping(maps.slice(offset + index + 1));
+			const mapping = new Mapping([map, ...following.maps]);
 			map.forEach((oldFrom, oldTo) => {
 				before.nodesBetween(oldFrom, oldTo, (paragraph, position) => {
 					if (paragraph.type.name !== "paragraph") return true;

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

@@ -0,0 +1,4 @@
+import { EditorView } from "prosemirror-view";
+//#region src/prosemirror/plugins/lockedControlKeyHandling.d.ts
+export declare const selectLockedInlineControl: (view: Pick<EditorView, "dispatch" | "state">, event: KeyboardEvent) => boolean;
+//#endregion

package/dist/prosemirror/plugins/lockedControlKeyHandling.js

@@ -0,0 +1,16 @@
+import { NodeSelection, TextSelection } from "prosemirror-state";
+//#region src/prosemirror/plugins/lockedControlKeyHandling.ts
+const selectLockedInlineControl = (view, event) => {
+	if (event.key !== "Backspace" && event.key !== "Delete") return false;
+	const { state } = view;
+	if (!(state.selection instanceof TextSelection) || !state.selection.empty) return false;
+	const backward = event.key === "Backspace";
+	const { $from } = state.selection;
+	const node = backward ? $from.nodeBefore : $from.nodeAfter;
+	if (!node || node.type.name !== "sdt" || node.attrs["lock"] !== "contentLocked") return false;
+	const pos = backward ? $from.pos - node.nodeSize : $from.pos;
+	view.dispatch(state.tr.setSelection(NodeSelection.create(state.doc, pos)).scrollIntoView());
+	return true;
+};
+//#endregion
+export { selectLockedInlineControl };

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

@@ -1,6 +1,6 @@
+import { NumberingMap } from "../../docx/numberingParser.js";
 import { StyleEngine } from "../../style-engine/styleEngine.js";
 import "../../style-engine/index.js";
-import { NumberingMap } from "../../docx/numberingParser.js";
 import { ParagraphCascadeResolver } from "../styles/paragraphStyleCascade.js";
 import { EditorState, Transaction } from "prosemirror-state";
 //#region src/prosemirror/plugins/paragraphStyleResolution.d.ts
@@ -10,6 +10,6 @@ type ParagraphStyleResolver = ParagraphCascadeResolver & Pick<StyleEngine, "getD
  * that has not been projected yet. Returns the transaction to append, or null
  * when every touched paragraph already reads as a reopened document would.
  */
-declare const resolveEditedParagraphStyles: (transactions: readonly Transaction[], state: EditorState, resolver: ParagraphStyleResolver, numbering: () => NumberingMap | null) => Transaction | null;
+export declare const resolveEditedParagraphStyles: (transactions: readonly Transaction[], state: EditorState, resolver: ParagraphStyleResolver, numbering: () => NumberingMap | null) => Transaction | null;
 //#endregion
-export { resolveEditedParagraphStyles };
+export {};

package/dist/prosemirror/plugins/paragraphStyleResolution.js

@@ -10,6 +10,23 @@ import { TableMap } from "prosemirror-tables";
 import { Mapping } from "prosemirror-transform";
 import { isHistoryTransaction } from "prosemirror-history";
 //#region src/prosemirror/plugins/paragraphStyleResolution.ts
+/**
+* Resolve the style cascade onto paragraphs an edit creates.
+*
+* A loaded paragraph carries its effective formatting as attrs: `toProseDoc`
+* projects the style cascade (docDefaults, the paragraph style chain) onto
+* every paragraph, and the painter reads those attrs. A paragraph an edit
+* creates — a paste, a structural table command, a replacement that joins
+* paragraphs, a cut that empties the document — starts from the node spec's
+* defaults instead, so it paints without its inherited spacing and run
+* defaults until the document is saved and reopened.
+*
+* {@link resolveEditedParagraphStyles} closes that gap in one place: after
+* every edit it projects the same cascade onto each paragraph the edit touched
+* and that the load path never saw, filling only what the paragraph leaves
+* unstated, with the provenance a save needs to keep those inherited values
+* out of the paragraph's own `w:pPr`.
+*/
 /** The ranges of `doc` the given transactions changed, in its own positions. */
 const changedRanges = (transactions) => {
 	const ranges = [];
@@ -52,6 +69,8 @@ const statedFormatting = (attrs) => {
 	copy("shading");
 	copy("tabs");
 	copy("kinsoku");
+	copy("autoSpaceDE");
+	copy("autoSpaceDN");
 	copy("overflowPunctuation");
 	copy("suppressAutoHyphens");
 	copy("pageBreakBefore");
@@ -74,9 +93,10 @@ const isUnset = (value) => value === null || value === void 0;
 const cascadePatch = (node, resolver, tableParagraphOverlay, numbering) => {
 	const attrs = expectParagraphAttrs(node);
 	const styleId = attrs.styleId ?? void 0;
+	const formatting = statedFormatting(attrs);
 	const { attrs: cascade, stylePpr } = paragraphStyleCascadeAttrs({
 		styleId,
-		formatting: statedFormatting(attrs),
+		formatting,
 		styleResolver: resolver,
 		tableParagraphOverlay,
 		includeParagraphMarkRunProperties: false
@@ -121,6 +141,8 @@ const cascadePatch = (node, resolver, tableParagraphOverlay, numbering) => {
 		"shading",
 		"tabs",
 		"kinsoku",
+		"autoSpaceDE",
+		"autoSpaceDN",
 		"overflowPunctuation",
 		"suppressAutoHyphens",
 		"pageBreakBefore",

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

@@ -1,6 +1,6 @@
 import { Node } from "prosemirror-model";
 //#region src/prosemirror/plugins/pmTextScan.d.ts
-type TextChunk = {
+export type TextChunk = {
   text: string;
   /** PM doc position where this chunk's first char lives. */
   start: number;
@@ -13,10 +13,9 @@ type TextChunk = {
  * An explicit page-break run ends a segment: it is zero-width in the joined
  * text, but a text-shaped overlay must not select across that structural atom.
  */
-declare const collectBlockChunks: (doc: Node) => TextChunk[][];
+export declare const collectBlockChunks: (doc: Node) => TextChunk[][];
 /** Map a joined-string offset back to its PM doc position. */
-declare const offsetToDocPos: (chunks: TextChunk[], offset: number, bias?: "start" | "end") => number;
+export declare const offsetToDocPos: (chunks: TextChunk[], offset: number, bias?: "start" | "end") => number;
 /** Join a block's chunks into the single string callers scan. */
-declare const joinChunks: (chunks: TextChunk[]) => string;
-//#endregion
-export { TextChunk, collectBlockChunks, joinChunks, offsetToDocPos };
+export declare const joinChunks: (chunks: TextChunk[]) => string;
+//#endregion

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

@@ -1,35 +1,35 @@
 import { Node } from "prosemirror-model";
 //#region src/prosemirror/plugins/revisionIds.d.ts
 declare const RevisionIdAllocationError_base: import("better-result").TaggedErrorClass<"RevisionIdAllocationError">;
-declare class RevisionIdAllocationError extends RevisionIdAllocationError_base<{
+export declare class RevisionIdAllocationError extends RevisionIdAllocationError_base<{
   message: string;
   first: number;
   next: number;
 }> {}
 /** Deterministic package-local batches prefer ids above loaded revisions, then a free interval. */
-declare const revisionIdSeedAbove: (existingIds: Iterable<number>) => number;
+export declare const revisionIdSeedAbove: (existingIds: Iterable<number>) => number;
 /** The next free id, including after the signed 32-bit boundary wraps. */
-declare const nextRevisionId: () => number;
+export declare const nextRevisionId: () => number;
 /**
  * A shared batch increments its seed locally, so a single free id is not
  * enough: start in the largest free interval. Every contiguous batch that
  * can fit anywhere fits here, including after loaded ids shorten the tail.
  * Continue within this interval until another producer changes the cursor.
  */
-declare const nextRevisionIdRange: () => number;
+export declare const nextRevisionIdRange: () => number;
 /** Reserve a deterministic batch without changing its caller-supplied ids. */
-declare const reserveRevisionIds: (first: number, next: number) => void;
+export declare const reserveRevisionIds: (first: number, next: number) => void;
 /** Shared producers must never cross a loaded or already issued id on wrap. */
-declare const claimRevisionIds: (first: number, next: number) => void;
+export declare const claimRevisionIds: (first: number, next: number) => void;
 /** Mint a bounded id without reusing loaded or previously issued ids. */
-declare function mintRevisionId(): number;
+export declare function mintRevisionId(): number;
 /** Reserve a valid loaded id and prefer the range above it. */
-declare function seedRevisionIdsAbove(maxId: number): void;
-declare const maxAnnotationIdInDoc: (doc: Node) => number;
+export declare function seedRevisionIdsAbove(maxId: number): void;
+export declare const maxAnnotationIdInDoc: (doc: Node) => number;
 /**
  * Raise the counter above every annotation id already present in `doc`.
  * Called from the suggestion-mode plugin's `state.init`.
  */
-declare function seedRevisionIdsFromDoc(doc: Node): void;
+export declare function seedRevisionIdsFromDoc(doc: Node): void;
 //#endregion
-export { RevisionIdAllocationError, claimRevisionIds, maxAnnotationIdInDoc, mintRevisionId, nextRevisionId, nextRevisionIdRange, reserveRevisionIds, revisionIdSeedAbove, seedRevisionIdsAbove, seedRevisionIdsFromDoc };
+export {};

package/dist/prosemirror/plugins/revisionIds.js

@@ -2,6 +2,17 @@ import { TaggedError } from "better-result";
 import { MAX_REVISION_ID } from "@stll/docx-core/model";
 //#region src/prosemirror/plugins/revisionIds.ts
 /**
+* Tracked-revision id minting (`w:id` on `<w:ins>` / `<w:del>`).
+*
+* Uniqueness comes from `seedRevisionIdsAbove` (called on load with the
+* document's own max id), NOT from the counter's starting value. A clock seed
+* bought uniqueness at the cost of ids no consumer could read — see
+* `MAX_REVISION_ID`. Port of eigenpal/docx-editor#1093.
+*
+* Kept free of `suggestionMode` imports so the suggestion plugin can mint
+* without a load-order cycle.
+*/
+/**
 * Next id to hand out. Starts at 1 (0 is the serializer's "unusable metadata"
 * fallback) and is raised past a loaded document's existing ids by
 * `seedRevisionIdsAbove`.

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

@@ -5,7 +5,7 @@ import { EditorState, Plugin } from "prosemirror-state";
 /**
  * Selection context for toolbar state
  */
-type SelectionContext = {
+export type SelectionContext = {
   /** Whether there's a non-collapsed selection */
   hasSelection: boolean;
   /** Whether selection spans multiple paragraphs */
@@ -30,7 +30,7 @@ type SelectionContext = {
 /**
  * Plugin key for accessing selection tracker state
  */
-declare const selectionTrackerKey: Readonly<{
+export declare const selectionTrackerKey: Readonly<{
   key: string;
   createKey: () => import("prosemirror-state").PluginKey<SelectionContext>;
   owns: (plugin: Plugin<SelectionContext>) => boolean;
@@ -40,18 +40,17 @@ declare const selectionTrackerKey: Readonly<{
 /**
  * Callback type for selection changes
  */
-type SelectionChangeCallback = (context: SelectionContext) => void;
+export type SelectionChangeCallback = (context: SelectionContext) => void;
 /**
  * Extract selection context from editor state
  */
-declare function extractSelectionContext(state: EditorState): SelectionContext;
+export declare function extractSelectionContext(state: EditorState): SelectionContext;
 /**
  * Create selection tracker plugin
  */
-declare function createSelectionTrackerPlugin(onSelectionChange?: SelectionChangeCallback): Plugin;
+export declare function createSelectionTrackerPlugin(onSelectionChange?: SelectionChangeCallback): Plugin;
 /**
  * Get current selection context from editor state
  */
-declare function getSelectionContext(state: EditorState): SelectionContext | null;
-//#endregion
-export { SelectionChangeCallback, SelectionContext, createSelectionTrackerPlugin, extractSelectionContext, getSelectionContext, selectionTrackerKey };
+export declare function getSelectionContext(state: EditorState): SelectionContext | null;
+//#endregion

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

@@ -2,26 +2,26 @@ import { Slice } from "prosemirror-model";
 import { EditorState, Plugin, Transaction } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
 //#region src/prosemirror/plugins/suggestionMode.d.ts
-declare const suggestionModeKey: Readonly<{
+export declare const suggestionModeKey: Readonly<{
   key: string;
   createKey: () => import("prosemirror-state").PluginKey<SuggestionModeState>;
   owns: (plugin: Plugin<SuggestionModeState>) => boolean;
   get: (state: EditorState) => Plugin<SuggestionModeState> | undefined;
   getState: (state: EditorState) => SuggestionModeState | undefined;
 }>;
-declare const SUGGESTION_META = "suggestionModeApplied";
-declare const SUGGESTION_BYPASS_META = "suggestionModeBypass";
+export declare const SUGGESTION_META = "suggestionModeApplied";
+export declare 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.
  */
-declare const SUGGESTED_TEXT_INPUT_META = "suggestionModeTextInput";
+export declare const SUGGESTED_TEXT_INPUT_META = "suggestionModeTextInput";
 type SuggestionModeState = {
   active: boolean;
   author: string;
 };
-declare function makeRevisionInfo(state: EditorState): {
+export declare function makeRevisionInfo(state: EditorState): {
   id: number;
   author: string;
   date: string;
@@ -35,7 +35,7 @@ declare function makeRevisionInfo(state: EditorState): {
  * default paste + the `appendTransaction` catch-all marks a plain insertion
  * (eigenpal/docx-editor#784).
  */
-declare function handleSuggestionPaste(view: EditorView, slice: Slice, pluginState: SuggestionModeState): boolean;
+export declare function handleSuggestionPaste(view: Pick<EditorView, "dispatch" | "state">, slice: Slice, pluginState: SuggestionModeState): boolean;
 /**
  * With track changes on, a paste into a table's cells (a cell selection, or a
  * block of copied cells) replaces each cell's content the way a paste over a
@@ -44,13 +44,13 @@ declare function handleSuggestionPaste(view: EditorView, slice: Slice, pluginSta
  * last one ends the cell, so its paragraph mark is tracked as added too:
  * rejecting then drops it and accepting joins the struck paragraphs into it.
  */
-declare function handleSuggestionTableCellPaste(view: EditorView, slice: Slice, pluginState: SuggestionModeState): boolean;
+export declare function handleSuggestionTableCellPaste(view: EditorView, slice: Slice, pluginState: SuggestionModeState): boolean;
 /**
  * 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.
  */
-declare function suggestRangeDeletion(state: EditorState, tr: Transaction, from: number, to: number): boolean;
+export declare function suggestRangeDeletion(state: EditorState, tr: Transaction, from: number, to: number): boolean;
 /**
  * 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
@@ -60,7 +60,7 @@ declare function suggestRangeDeletion(state: EditorState, tr: Transaction, from:
  * If the source paragraph already carries a `pPrMark`, leave it alone — a
  * prior author's revision must not be silently overwritten.
  */
-declare function handleSuggestionEnter(view: EditorView, pluginState: SuggestionModeState): boolean;
+export declare function handleSuggestionEnter(view: EditorView, pluginState: SuggestionModeState): boolean;
 /**
  * Detect a caret-at-paragraph-boundary scenario where Backspace/Delete should
  * record a tracked paragraph-mark deletion instead of joining paragraphs.
@@ -75,25 +75,25 @@ declare function handleSuggestionEnter(view: EditorView, pluginState: Suggestion
  * not produce paragraph-mark merging, e.g. doc start, doc end, or a table).
  * Bookmark markers at an edge do not hide the adjacent paragraph break.
  */
-declare function paragraphBoundaryTarget(state: EditorState, direction: "backward" | "forward"): number | null;
+export declare function paragraphBoundaryTarget(state: EditorState, direction: "backward" | "forward"): number | null;
 /** Apply the editor's selected-content deletion path for a host cut action. */
-declare const deleteSelectionAsSuggestion: (state: EditorState, dispatch: (tr: Transaction) => void) => boolean;
+export declare const deleteSelectionAsSuggestion: (state: EditorState, dispatch: (tr: Transaction) => void) => boolean;
 /**
  * Create the suggestion mode plugin.
  * When active, text edits become tracked changes.
  */
-declare function createSuggestionModePlugin(initialActive?: boolean, author?: string): Plugin;
+export declare function createSuggestionModePlugin(initialActive?: boolean, author?: string): Plugin;
 /**
  * Toggle suggestion mode on/off.
  */
-declare function toggleSuggestionMode(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;
+export declare function toggleSuggestionMode(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;
 /**
  * Set suggestion mode active state and author.
  */
-declare function setSuggestionMode(active: boolean, state: EditorState, dispatch?: (tr: Transaction) => void, author?: string): boolean;
+export declare function setSuggestionMode(active: boolean, state: EditorState, dispatch?: (tr: Transaction) => void, author?: string): boolean;
 /**
  * Check if suggestion mode is currently active.
  */
-declare function isSuggestionModeActive(state: EditorState): boolean;
+export declare function isSuggestionModeActive(state: EditorState): boolean;
 //#endregion
-export { SUGGESTED_TEXT_INPUT_META, SUGGESTION_BYPASS_META, SUGGESTION_META, createSuggestionModePlugin, deleteSelectionAsSuggestion, handleSuggestionEnter, handleSuggestionPaste, handleSuggestionTableCellPaste, isSuggestionModeActive, makeRevisionInfo, paragraphBoundaryTarget, setSuggestionMode, suggestRangeDeletion, suggestionModeKey, toggleSuggestionMode };
+export {};