@stll/folio-core 0.52.0 → 0.53.0

package/dist/prosemirror/markupViewProjection.d.ts

@@ -0,0 +1,95 @@
+import { DisplayMode } from "../managers/EditorModeManager.js";
+import { RemovedSectionReference } from "../internal/sectionEndpointResolution.js";
+import { indexedPositionMap } from "../internal/indexedPositionMap.js";
+import { RevisionResolutionMode } from "../internal/revisionResolutionInline.js";
+import { Node } from "prosemirror-model";
+import { EditorState } from "prosemirror-state";
+import { StepMap } from "prosemirror-transform";
+//#region src/prosemirror/markupViewProjection.d.ts
+/** Resolve every revision in the state's story with the state's own styles and numbering. */
+declare const resolveStateStory: (state: EditorState, mode: RevisionResolutionMode) => {
+  resolved: Node;
+  mapping: import("prosemirror-transform").Mapping;
+  positionMap: StepMap;
+  steps: import("prosemirror-transform").Step[];
+  changedRanges: {
+    from: number;
+    to: number;
+  }[];
+  inlineMap: StepMap;
+  tableRanges: {
+    node: Node;
+    inputNode: Node;
+    sourceNodeSize: number;
+    position: number;
+    inputMap: StepMap;
+    positionMap: StepMap;
+    ranges: readonly {
+      from: number;
+      to: number;
+    }[];
+    paragraphOffsets: readonly {
+      source: number;
+      final: number;
+    }[];
+  }[];
+  transfers: {
+    displacedToken: string | null;
+    selectedToken: string | null;
+  }[];
+  structuralRanges: {
+    from: number;
+    to: number;
+  }[];
+  structuralMap: StepMap;
+  structural: boolean;
+  failed: boolean;
+  removedEndpointCount: number;
+  removedReferences: RemovedSectionReference[];
+};
+type PositionRange = {
+  from: number;
+  to: number;
+};
+type MarkupViewProjection =
+/** The view lays the authored document out as it stands. */
+{
+  type: "authored";
+} | {
+  type: "resolved";
+  /** The document as the view reads it. */
+  doc: Node;
+  /** Authored (editor) positions to `doc` positions. */
+  positionMap: StepMap;
+  /** `positionMap`, indexed for lookups. */
+  toView: ReturnType<typeof indexedPositionMap>;
+  /** `positionMap` inverted and indexed: `doc` positions to editor positions. */
+  toEditor: ReturnType<typeof indexedPositionMap>;
+  /**
+   * Ranges of `doc` whose paragraphs carry a change indicator (Simple
+   * Markup's change bar); empty for a view without indicators.
+   */
+  changeBarRanges: readonly PositionRange[];
+  /**
+   * Whether the resolver left part of the story as authored (a table
+   * revision it cannot resolve). The projection still shows every revision
+   * it could resolve; the caller reports the rest.
+   */
+  completeness: "complete" | "partial";
+};
+/**
+ * The document a markup view lays out, for the state's current document.
+ * Cached per editor state: the resolver also reads its styles and numbering
+ * plugins, which may change while the document node stays the same.
+ */
+declare const projectMarkupView: (state: EditorState, view: DisplayMode) => MarkupViewProjection;
+/**
+ * Where a caret at editor `position` is painted in a view. A position the view
+ * shows is its own; one inside text the view does not show (a deletion in No
+ * Markup, an insertion in Original, typed there with tracking on) moves to the
+ * nearest place the view shows before it, the way the caret sits at the edge
+ * of text it cannot enter.
+ */
+declare const visibleCaretPosition: (projection: MarkupViewProjection, position: number) => number;
+//#endregion
+export { MarkupViewProjection, projectMarkupView, resolveStateStory, visibleCaretPosition };

package/dist/prosemirror/markupViewProjection.js

@@ -0,0 +1,83 @@
+import { indexedPositionMap } from "../internal/indexedPositionMap.js";
+import { finalRevisionParagraphRanges } from "../internal/revisionResolutionTracking.js";
+import { resolveWholeStory } from "../internal/wholeStoryRevisionResolution.js";
+import { getDocumentNumbering } from "./plugins/documentNumbering.js";
+import { getDocumentStyleResolver } from "./plugins/documentStyles.js";
+import { Selection } from "prosemirror-state";
+//#region src/prosemirror/markupViewProjection.ts
+/** Resolve every revision in the state's story with the state's own styles and numbering. */
+const resolveStateStory = (state, mode) => resolveWholeStory({
+	doc: state.doc,
+	mode,
+	styleResolver: getDocumentStyleResolver(state),
+	numbering: getDocumentNumbering(state)
+});
+/**
+* Every view's reading of the document. Total over `DisplayMode`, so a new view
+* cannot ship without a decision about what it lays out.
+*/
+const MARKUP_VIEW_RESOLUTIONS = {
+	"all-markup": { type: "authored" },
+	"simple-markup": {
+		type: "resolved",
+		mode: "accept",
+		indicators: "change-bars"
+	},
+	"no-markup": {
+		type: "resolved",
+		mode: "accept",
+		indicators: "none"
+	},
+	original: {
+		type: "resolved",
+		mode: "reject",
+		indicators: "none"
+	}
+};
+const AUTHORED = { type: "authored" };
+const projectionCache = /* @__PURE__ */ new WeakMap();
+/**
+* The document a markup view lays out, for the state's current document.
+* Cached per editor state: the resolver also reads its styles and numbering
+* plugins, which may change while the document node stays the same.
+*/
+const projectMarkupView = (state, view) => {
+	const resolution = MARKUP_VIEW_RESOLUTIONS[view];
+	if (resolution.type === "authored") return AUTHORED;
+	let byView = projectionCache.get(state);
+	const cached = byView?.get(view);
+	if (cached) return cached;
+	const result = resolveStateStory(state, resolution.mode);
+	const projection = result.resolved.eq(state.doc) ? AUTHORED : {
+		type: "resolved",
+		doc: result.resolved,
+		positionMap: result.positionMap,
+		toView: indexedPositionMap(result.positionMap),
+		toEditor: indexedPositionMap(result.positionMap.invert()),
+		changeBarRanges: resolution.indicators === "change-bars" ? finalRevisionParagraphRanges(result) : [],
+		completeness: result.failed ? "partial" : "complete"
+	};
+	if (!byView) {
+		byView = /* @__PURE__ */ new Map();
+		projectionCache.set(state, byView);
+	}
+	byView.set(view, projection);
+	return projection;
+};
+/**
+* Where a caret at editor `position` is painted in a view. A position the view
+* shows is its own; one inside text the view does not show (a deletion in No
+* Markup, an insertion in Original, typed there with tracking on) moves to the
+* nearest place the view shows before it, the way the caret sits at the edge
+* of text it cannot enter.
+*/
+const visibleCaretPosition = (projection, position) => {
+	if (projection.type === "authored") return position;
+	const { pos: viewPosition, deletedAcross } = projection.toView.mapResult(position, -1);
+	if (!deletedAcross) return position;
+	const bounded = Math.max(0, Math.min(viewPosition, projection.doc.content.size));
+	const near = Selection.near(projection.doc.resolve(bounded), -1);
+	return projection.toEditor(near.head, -1);
+};
+//#endregion
+export { projectMarkupView, resolveStateStory, visibleCaretPosition };

package/dist/prosemirror/numberingAttr.d.ts

@@ -22,6 +22,14 @@ type ParagraphNumberingAttr = ParagraphNumberingOverride & {
 };
 /** Mint the attr value for a stated override: the one model-to-attr crossing. */
 declare const paragraphNumberingAttr: (numbering: ParagraphNumberingOverride) => ParagraphNumberingAttr;
+/**
+ * The `numPr` that takes a paragraph out of its list. When its style supplies
+ * the numbering, the paragraph has to state the cancellation (`w:numId="0"`):
+ * clearing the attr would uncover the style tier, and the next save hands the
+ * numbering straight back. A cancellation states no level (17.9.18: there is
+ * no id left for a level to belong to).
+ */
+declare const removedNumberingAttr: (numPrFromStyle: ParagraphNumberingOverride | null | undefined) => ParagraphNumberingAttr | null;
 /**
  * The one shape check over a persisted `numPr` attr.
  *
@@ -52,4 +60,4 @@ declare const paragraphNumberingFromAttrValue: (value: unknown) => ParagraphNumb
  */
 declare const readParagraphNumberingAttr: (value: unknown) => ParagraphNumberingAttr | null;
 //#endregion
-export { ParagraphNumberingAttr, paragraphNumberingAttr, paragraphNumberingFromAttrValue, readParagraphNumberingAttr };
+export { ParagraphNumberingAttr, paragraphNumberingAttr, paragraphNumberingFromAttrValue, readParagraphNumberingAttr, removedNumberingAttr };

package/dist/prosemirror/numberingAttr.js

@@ -17,6 +17,14 @@ const paragraphNumberingAttr = (numbering) => {
 		default: return panic(`Unhandled paragraph numbering ${JSON.stringify(numbering)}`);
 	}
 };
+/**
+* The `numPr` that takes a paragraph out of its list. When its style supplies
+* the numbering, the paragraph has to state the cancellation (`w:numId="0"`):
+* clearing the attr would uncover the style tier, and the next save hands the
+* numbering straight back. A cancellation states no level (17.9.18: there is
+* no id left for a level to belong to).
+*/
+const removedNumberingAttr = (numPrFromStyle) => numPrFromStyle?.kind === "reference" ? paragraphNumberingAttr(NO_PARAGRAPH_NUMBERING) : null;
 /** A `<w:numPr>` slot value: an ordinal, so a non-integer or a negative is not one. */
 const isNumberingSlot = (value) => typeof value === "number" && Number.isInteger(value) && value >= 0;
 /**
@@ -71,4 +79,4 @@ const readParagraphNumberingAttr = (value) => {
 	return numbering;
 };
 //#endregion
-export { paragraphNumberingAttr, paragraphNumberingFromAttrValue, readParagraphNumberingAttr };
+export { paragraphNumberingAttr, paragraphNumberingFromAttrValue, readParagraphNumberingAttr, removedNumberingAttr };

package/dist/prosemirror/outlineLevelAttr.js

@@ -17,7 +17,7 @@ import { headingOutlineLevel } from "@stll/docx-core/model";
 const outlineLevelFromAttrValue = (value) => {
 	if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
 	const kind = Reflect.get(value, "kind");
-	if (kind === "bodyText") return { kind: "bodyText" };
+	if (kind === "bodyText") return Reflect.has(value, "level") ? null : { kind: "bodyText" };
 	if (kind !== "heading") return null;
 	const level = Reflect.get(value, "level");
 	return typeof level === "number" ? headingOutlineLevel(level) ?? null : null;

package/dist/prosemirror/paragraphIndentation.d.ts

@@ -6,7 +6,16 @@ import { ParagraphAttrs } from "./schema/nodes.js";
 type DirectParagraphIndentation = FolioContentParagraphIndentation;
 /** Project only authored `w:ind` attributes, preserving zero and false. */
 declare const paragraphIndentationFromFormatting: (formatting: document_d_exports.ParagraphFormatting | null | undefined) => DirectParagraphIndentation | undefined;
-/** Read direct indentation without materializing values inherited from a style. */
+/**
+ * Read direct indentation without materializing values inherited from a style:
+ * the `w:ind` a save writes for the paragraph.
+ *
+ * A field the source stated reads at its current value. A field it did not
+ * reads only when an edit set it to something the style cascade does not
+ * supply — reading `_originalFormatting` alone missed every indentation a
+ * command set on a paragraph whose source stated none. A hanging indent reads
+ * with a negative `indentFirstLine`, as the model states it.
+ */
 declare const directParagraphIndentation: (attrs: ParagraphAttrs) => DirectParagraphIndentation | undefined;
 declare const paragraphIndentationEqual: (left: DirectParagraphIndentation | null | undefined, right: DirectParagraphIndentation | null | undefined) => boolean;
 /** Replace the complete direct `w:ind` cluster in canonical formatting. */

package/dist/prosemirror/paragraphIndentation.js

@@ -31,19 +31,41 @@ const paragraphIndentationFromFormatting = (formatting) => {
 	if (indentation.indentFirstLine !== void 0 && indentation.hangingIndent === void 0) indentation.hangingIndent = false;
 	return Object.keys(indentation).length > 0 ? indentation : void 0;
 };
-/** Read direct indentation without materializing values inherited from a style. */
+const PARAGRAPH_INDENTATION_VALUE_KEYS = [
+	"indentLeft",
+	"indentRight",
+	"indentFirstLine"
+];
+/**
+* Read direct indentation without materializing values inherited from a style:
+* the `w:ind` a save writes for the paragraph.
+*
+* A field the source stated reads at its current value. A field it did not
+* reads only when an edit set it to something the style cascade does not
+* supply — reading `_originalFormatting` alone missed every indentation a
+* command set on a paragraph whose source stated none. A hanging indent reads
+* with a negative `indentFirstLine`, as the model states it.
+*/
 const directParagraphIndentation = (attrs) => {
-	const original = paragraphIndentationFromFormatting(attrs._originalFormatting);
-	if (!original) return;
+	const original = attrs._originalFormatting ?? void 0;
+	const resolved = attrs._resolvedFormatting;
 	const indentation = {};
-	for (const key of DIRECT_PARAGRAPH_INDENTATION_KEYS) {
-		if (original[key] === void 0) continue;
-		copyIndentationValue({
+	for (const key of PARAGRAPH_INDENTATION_VALUE_KEYS) {
+		const value = attrs[key];
+		if (typeof value !== "number") continue;
+		const stated = original?.[key] !== void 0;
+		const inherited = resolved?.[key] === value || original === void 0 && value === 0;
+		if (stated || !inherited) copyIndentationValue({
 			target: indentation,
 			key,
-			value: attrs[key]
+			value
 		});
 	}
+	if (indentation.indentFirstLine !== void 0) {
+		const hanging = attrs.hangingIndent === true;
+		indentation.hangingIndent = hanging;
+		if (hanging) indentation.indentFirstLine = -Math.abs(indentation.indentFirstLine);
+	} else if (original?.hangingIndent !== void 0 && typeof attrs.hangingIndent === "boolean") indentation.hangingIndent = attrs.hangingIndent;
 	return Object.keys(indentation).length > 0 ? indentation : void 0;
 };
 const paragraphIndentationEqual = (left, right) => DIRECT_PARAGRAPH_INDENTATION_KEYS.every((key) => left?.[key] === right?.[key]);

package/dist/prosemirror/paragraphMarkJoin.d.ts

@@ -0,0 +1,19 @@
+import { Node } from "prosemirror-model";
+import { Transaction } from "prosemirror-state";
+//#region src/prosemirror/paragraphMarkJoin.d.ts
+type JoinAtParagraphMarkOptions = {
+  tr: Transaction;
+  /** Position of the paragraph whose mark goes. */
+  paragraphPos: number;
+  paragraph: Node;
+  /** The paragraph directly after it, which the join runs into. */
+  next: Node;
+  /**
+   * The first paragraph's content is going too (a deleted paragraph), so
+   * only the join survives of it, as when it is already empty.
+   */
+  firstIsGoing?: boolean;
+};
+declare const joinAtParagraphMark: ({ tr, paragraphPos, paragraph, next, firstIsGoing }: JoinAtParagraphMarkOptions) => void;
+//#endregion
+export { joinAtParagraphMark };

package/dist/prosemirror/paragraphMarkJoin.js

@@ -0,0 +1,24 @@
+import { joinProseParagraphsWithRightPropertySource } from "../docx/paragraphPropertySource.js";
+import { holdsNoContent } from "./zeroWidthAnchors.js";
+//#region src/prosemirror/paragraphMarkJoin.ts
+const joinAtParagraphMark = ({ tr, paragraphPos, paragraph, next, firstIsGoing = false }) => {
+	const joinPos = paragraphPos + paragraph.nodeSize;
+	const emptyFirstParagraph = firstIsGoing || holdsNoContent(paragraph);
+	const joinedAttrs = {
+		...(emptyFirstParagraph ? next : paragraph).attrs,
+		pPrMark: next.attrs["pPrMark"],
+		_sectionProperties: next.attrs["_sectionProperties"]
+	};
+	if (emptyFirstParagraph) {
+		joinProseParagraphsWithRightPropertySource({
+			attrs: joinedAttrs,
+			pos: joinPos,
+			transaction: tr
+		});
+		return;
+	}
+	tr.join(joinPos);
+	tr.setNodeMarkup(paragraphPos, void 0, joinedAttrs);
+};
+//#endregion
+export { joinAtParagraphMark };

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

@@ -1,5 +1,5 @@
-import { EditorState, Plugin, PluginKey } from "prosemirror-state";
 import { Node } from "prosemirror-model";
+import { EditorState, Plugin, PluginKey } from "prosemirror-state";
 //#region src/prosemirror/plugins/createDocScanPlugin.d.ts
 declare const SET_META = "set";
 type DocScanState<TConfig, TRange> = {

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

@@ -3,8 +3,34 @@ import { NumberingMap } from "../../docx/numberingParser.js";
 import { EditorState, Plugin } from "prosemirror-state";
 //#region src/prosemirror/plugins/documentNumbering.d.ts
 declare const createDocumentNumberingPlugin: (definitions: document_d_exports.NumberingDefinitions | null | undefined) => Plugin;
+/**
+ * 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;
+/** The package's own definitions, without the instances the document defines. */
+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;
+/**
+ * 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;
+/**
+ * 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;
 /** Replace numbering state while retaining every unrelated plugin state. */
 declare const withDocumentNumbering: (state: EditorState, definitions: document_d_exports.NumberingDefinitions) => EditorState;
 //#endregion
-export { createDocumentNumberingPlugin, getDocumentNumbering, withDocumentNumbering };
+export { createDocumentNumberingPlugin, getDocumentNumbering, getDocumentNumberingInstanceIds, getPackageNumberingDefinitions, getStatedDocumentNumbering, hasDocumentNumbering, withDocumentNumbering };

package/dist/prosemirror/plugins/documentNumbering.js

@@ -1,19 +1,105 @@
 import { getCachedNumberingMap } from "../../docx/numberingParser.js";
+import { completeNumberingForDoc, paragraphListReferences } from "../listInstanceReferences.js";
+import { AddMarkStep, DocAttrStep, RemoveMarkStep, ReplaceAroundStep, ReplaceStep } from "prosemirror-transform";
 import { Plugin, PluginKey } from "prosemirror-state";
 //#region src/prosemirror/plugins/documentNumbering.ts
-/** Document-scoped numbering definitions for list-editing commands. */
 const documentNumberingKey = new PluginKey("documentNumbering");
-const createDocumentNumberingPlugin = (definitions) => {
-	const numbering = definitions ? getCachedNumberingMap(definitions) : null;
-	return new Plugin({
-		key: documentNumberingKey,
-		state: {
-			init: () => numbering,
-			apply: (_transaction, value) => value
-		}
+const completedState = (definitions, doc) => {
+	const completed = completeNumberingForDoc(definitions ?? void 0, doc);
+	return {
+		definitions,
+		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;
+/**
+* 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.
+*/
+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 getDocumentNumbering = (state) => documentNumberingKey.getState(state) ?? null;
+const createDocumentNumberingPlugin = (definitions) => new Plugin({
+	key: documentNumberingKey,
+	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
+	}
+});
+/** Numbering for states without the plugin, one per document node. */
+const untrackedNumbering = /* @__PURE__ */ new WeakMap();
+/**
+* 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.
+*/
+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;
+};
+/** The package's own definitions, without the instances the document defines. */
+const getPackageNumberingDefinitions = (state) => documentNumberingKey.getState(state)?.definitions ?? 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.
+*/
+const hasDocumentNumbering = (state) => documentNumberingKey.get(state) !== void 0;
+/**
+* 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.
+*/
+const getStatedDocumentNumbering = (state) => {
+	if (documentNumberingKey.get(state) === void 0) return;
+	return getDocumentNumbering(state)?.definitions ?? null;
+};
+/**
+* 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.
+*/
+const getDocumentNumberingInstanceIds = (state) => {
+	const numbering = getStatedDocumentNumbering(state);
+	if (numbering === void 0) return null;
+	return new Set(numbering?.nums.map(({ numId }) => numId) ?? []);
+};
 /** Replace numbering state while retaining every unrelated plugin state. */
 const withDocumentNumbering = (state, definitions) => {
 	const previous = documentNumberingKey.get(state);
@@ -21,4 +107,4 @@ const withDocumentNumbering = (state, definitions) => {
 	return state.reconfigure({ plugins: retained }).reconfigure({ plugins: [...retained, createDocumentNumberingPlugin(definitions)] });
 };
 //#endregion
-export { createDocumentNumberingPlugin, getDocumentNumbering, withDocumentNumbering };
+export { createDocumentNumberingPlugin, getDocumentNumbering, getDocumentNumberingInstanceIds, getPackageNumberingDefinitions, getStatedDocumentNumbering, hasDocumentNumbering, withDocumentNumbering };

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

@@ -14,6 +14,15 @@ declare const documentStylesKey: PluginKey<StyleResolver | null>;
 declare function createDocumentStylesPlugin(styles: document_d_exports.StyleDefinitions | StyleResolver | null | undefined): Plugin;
 /** Read the document's StyleResolver, or null when the plugin isn't installed. */
 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): {
+  get: (styleId: string) => document_d_exports.Style | undefined;
+  paragraphStyles: () => document_d_exports.Style[];
+} | null;
 /**
  * Read the document's built-in style index, for the callers that classify
  * paragraphs (heading collection, markdown export, the AI snapshot). Without
@@ -24,4 +33,4 @@ declare function getDocumentBuiltInStyles(state: EditorState): BuiltInStyleIndex
 /** Reconfigure so ProseMirror replaces the keyed plugin's resolver state. */
 declare const withDocumentStyles: (state: EditorState, styles: document_d_exports.StyleDefinitions | StyleResolver | null | undefined) => EditorState;
 //#endregion
-export { createDocumentStylesPlugin, documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleResolver, withDocumentStyles };
+export { createDocumentStylesPlugin, documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleDefinitions, getDocumentStyleResolver, withDocumentStyles };

package/dist/prosemirror/plugins/documentStyles.js

@@ -44,6 +44,19 @@ function getDocumentStyleResolver(state) {
 	return documentStylesKey.getState(state) ?? 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.
+*/
+function getDocumentStyleDefinitions(state) {
+	if (documentStylesKey.get(state) === void 0) return null;
+	const resolver = getDocumentStyleResolver(state);
+	return {
+		get: (styleId) => resolver?.getStyle(styleId),
+		paragraphStyles: () => resolver?.getParagraphStyles() ?? []
+	};
+}
+/**
 * Read the document's built-in style index, for the callers that classify
 * paragraphs (heading collection, markdown export, the AI snapshot). Without
 * the plugin every lookup misses, which degrades classification to the
@@ -59,4 +72,4 @@ const withDocumentStyles = (state, styles) => {
 	return state.reconfigure({ plugins: retained }).reconfigure({ plugins: [...retained, createDocumentStylesPlugin(styles)] });
 };
 //#endregion
-export { createDocumentStylesPlugin, documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleResolver, withDocumentStyles };
+export { createDocumentStylesPlugin, documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleDefinitions, getDocumentStyleResolver, withDocumentStyles };

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

@@ -1,10 +1,16 @@
-import { EditorState, Plugin, PluginKey, Transaction } from "prosemirror-state";
 import { Slice } from "prosemirror-model";
+import { EditorState, Plugin, PluginKey, Transaction } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
 //#region src/prosemirror/plugins/suggestionMode.d.ts
 declare const suggestionModeKey: PluginKey<SuggestionModeState>;
 declare const SUGGESTION_META = "suggestionModeApplied";
 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";
 type SuggestionModeState = {
   active: boolean;
   author: string;
@@ -23,6 +29,12 @@ declare function makeRevisionInfo(state: EditorState): {
  * (eigenpal/docx-editor#784).
  */
 declare function handleSuggestionPaste(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;
 /**
  * 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
@@ -48,6 +60,8 @@ declare function handleSuggestionEnter(view: EditorView, pluginState: Suggestion
  * is a table). The default merge path then runs unchanged.
  */
 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;
 /**
  * Create the suggestion mode plugin.
  * When active, text edits become tracked changes.
@@ -66,4 +80,4 @@ declare function setSuggestionMode(active: boolean, state: EditorState, dispatch
  */
 declare function isSuggestionModeActive(state: EditorState): boolean;
 //#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 };