@stll/folio-core 0.52.0 → 0.54.0

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

@@ -1,3 +1,4 @@
+import { paragraphNumberingReferenceId } from "../docx/numberingReference.js";
 import { panic } from "better-result";
 //#region src/prosemirror/paragraphIndentation.ts
 const DIRECT_PARAGRAPH_INDENTATION_KEYS = [
@@ -31,19 +32,43 @@ 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 numbered = paragraphNumberingReferenceId(attrs.numPr ?? void 0) !== void 0;
 	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 zeroIsDefault = key === "indentRight" || !numbered;
+		const inherited = resolved?.[key] === value || original === void 0 && value === 0 && zeroIsDefault;
+		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 && original.indentFirstLine === 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,21 @@
+import { RunStyleResolver } from "./runStyleFormatting.js";
+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;
+  /**
+   * Re-reads the moved runs' inherited formatting in the next paragraph's
+   * style. Without one, the editor's join restyler does it when the
+   * transaction is dispatched.
+   */
+  styleResolver: RunStyleResolver | null;
+};
+declare const joinAtParagraphMark: ({ tr, paragraphPos, paragraph, next, styleResolver }: JoinAtParagraphMarkOptions) => void;
+//#endregion
+export { joinAtParagraphMark };

package/dist/prosemirror/paragraphMarkJoin.js

@@ -0,0 +1,26 @@
+import { joinProseParagraphsWithRightPropertySource } from "../docx/paragraphPropertySource.js";
+import { JOINED_RUNS_RESTYLED_META } from "./extensions/features/JoinedRunStyleExtension.js";
+import { rebaseParagraphRuns } from "./rebaseParagraphRunFormatting.js";
+import { paragraphRunStyleContext } from "./runStyleFormatting.js";
+//#region src/prosemirror/paragraphMarkJoin.ts
+const joinAtParagraphMark = ({ tr, paragraphPos, paragraph, next, styleResolver }) => {
+	joinProseParagraphsWithRightPropertySource({
+		attrs: next.attrs,
+		pos: paragraphPos + paragraph.nodeSize,
+		transaction: tr
+	});
+	if (!styleResolver) return;
+	if (paragraph.content.size > 0) rebaseParagraphRuns({
+		previousContext: paragraphRunStyleContext(paragraph, styleResolver),
+		paragraphPosition: paragraphPos,
+		range: {
+			from: 0,
+			to: paragraph.content.size
+		},
+		styleResolver,
+		tr
+	});
+	tr.setMeta(JOINED_RUNS_RESTYLED_META, true);
+};
+//#endregion
+export { joinAtParagraphMark };

package/dist/prosemirror/paragraphPropertyCarry.d.ts

@@ -0,0 +1,64 @@
+import { ParagraphPropertyChangeAttrs } from "./schema/nodes.js";
+import { RunStyleResolver } from "./runStyleFormatting.js";
+import { NumberingMap } from "../docx/numberingParser.js";
+import { Node } from "prosemirror-model";
+import { Transaction } from "prosemirror-state";
+//#region src/prosemirror/paragraphPropertyCarry.d.ts
+type CarryParagraphPropertiesOptions = {
+  tr: Transaction;
+  /** The paragraph that takes the properties. */
+  position: number;
+  /** The paragraph whose properties it takes. */
+  source: Node;
+  styleResolver: RunStyleResolver | null;
+  numbering: NumberingMap | null;
+  /** Records the change as a tracked property change; applied directly when omitted. */
+  revision?: ParagraphPropertyChangeAttrs["info"];
+  /** Properties the paragraph keeps its own values of: ones its own batch set. */
+  keep?: ReadonlySet<string>;
+};
+/**
+ * Give a paragraph another one's properties: the pPr a property change
+ * covers. Its identity, mark, mark run properties and section stay its own,
+ * and its runs are re-read in the new style. `tracked` says whether a property
+ * change now records what it had: a paragraph holds one, and a pending one
+ * already records it.
+ */
+declare const carryParagraphProperties: ({ tr, position, source, styleResolver, numbering, revision, keep }: CarryParagraphPropertiesOptions) => {
+  tr: Transaction;
+  changed: boolean;
+  tracked: boolean;
+};
+type ParagraphLeftAfterOptions = {
+  doc: Node;
+  paragraphPos: number;
+  /** Breaks a batch's deferred final-paragraph deletion will remove. */
+  removedBreakPositions?: ReadonlySet<number>;
+};
+/**
+ * The paragraph left once the break of the paragraph at `paragraphPos` goes:
+ * the next one, or, when its own break is pending deletion too, the first
+ * paragraph after it whose break stays. Null when no paragraph follows.
+ */
+declare const paragraphLeftAfter: ({ doc, paragraphPos, removedBreakPositions }: ParagraphLeftAfterOptions) => number | null;
+/**
+ * A paragraph now holds the break another one had (a split, or a paste into
+ * it, leaves that break on the last part) but reads with other properties:
+ * record the other's as its property change. Rejecting the inserted breaks
+ * leaves this paragraph, which then reads as the one that was there. A
+ * pending property change on the other one travels as it is. Returns whether
+ * a change under `revision` was written.
+ */
+declare const recordReplacedParagraphProperties: ({ tr, position, replaced, revision }: {
+  tr: Transaction;
+  position: number;
+  replaced: Node;
+  revision: ParagraphPropertyChangeAttrs["info"];
+}) => boolean;
+/**
+ * The properties a batch's own property change set on a paragraph: the ones
+ * whose value differs from what that change records as before.
+ */
+declare const propertiesSetInBatch: (node: Node, batchRevisionIds: ReadonlySet<number>) => ReadonlySet<string>;
+//#endregion
+export { carryParagraphProperties, paragraphLeftAfter, propertiesSetInBatch, recordReplacedParagraphProperties };

package/dist/prosemirror/paragraphPropertyCarry.js

@@ -0,0 +1,158 @@
+import { expectParagraphAttrs } from "./attrs/index.js";
+import { hasSerializableParagraphPropertyChange, paragraphPropertiesSnapshot } from "./commands/propertyChangeScope.js";
+import { resolveParagraphChangeAttrs } from "./commands/resolveParagraphProperties.js";
+import { rebaseParagraphRuns } from "./rebaseParagraphRunFormatting.js";
+import { paragraphRunStyleContext } from "./runStyleFormatting.js";
+import { panic } from "better-result";
+//#region src/prosemirror/paragraphPropertyCarry.ts
+/**
+* Handing one paragraph's properties to another, as a removed paragraph mark
+* requires.
+*
+* A paragraph's properties live on its mark, and a removed mark leaves the
+* paragraph after it: that is the paragraph left once the change is accepted.
+* An edit that should read as the FIRST paragraph (a merge, a Backspace at a
+* paragraph's start, a deletion across paragraphs) therefore gives the second
+* the first's properties, recorded as a property change under the same
+* revision, so accepting reads as the direct edit and rejecting restores the
+* second's own.
+*/
+/**
+* Give a paragraph another one's properties: the pPr a property change
+* covers. Its identity, mark, mark run properties and section stay its own,
+* and its runs are re-read in the new style. `tracked` says whether a property
+* change now records what it had: a paragraph holds one, and a pending one
+* already records it.
+*/
+const carryParagraphProperties = ({ tr, position, source, styleResolver, numbering, revision, keep }) => {
+	const target = tr.doc.nodeAt(position);
+	if (!target || target.type !== source.type) return {
+		tr,
+		changed: false,
+		tracked: false
+	};
+	const previousFormatting = paragraphPropertiesSnapshot(target);
+	const own = previousFormatting;
+	const formatting = Object.fromEntries([...Object.entries(paragraphPropertiesSnapshot(source)).filter(([key]) => !keep?.has(key)), ...Object.entries(own).filter(([key]) => keep?.has(key))]);
+	if (JSON.stringify(previousFormatting) === JSON.stringify(formatting)) return {
+		tr,
+		changed: false,
+		tracked: false
+	};
+	const existing = expectParagraphAttrs(target)._propertyChanges;
+	const tracked = revision !== void 0 && !hasSerializableParagraphPropertyChange(existing);
+	const carried = resolveParagraphChangeAttrs({
+		node: target.type.create({
+			...target.attrs,
+			_propertyChanges: [{
+				type: "paragraphPropertyChange",
+				info: {
+					id: -1,
+					author: "",
+					date: "1970-01-01T00:00:00Z"
+				},
+				previousFormatting: formatting
+			}]
+		}, target.content, target.marks),
+		mode: "reject",
+		boundaryCovered: true,
+		revisionSet: null,
+		styleResolver,
+		numbering
+	});
+	if (!carried) return panic("Paragraph properties did not pass to the paragraph", { position });
+	const changes = [...Array.isArray(existing) ? existing : [], ...tracked && revision ? [{
+		type: "paragraphPropertyChange",
+		info: revision,
+		previousFormatting
+	}] : []];
+	tr.setNodeMarkup(position, void 0, {
+		...carried,
+		...carriedNumberingProvenance(source, target, keep),
+		_sectionProperties: target.attrs["_sectionProperties"],
+		_propertyChanges: changes.length > 0 ? changes : null
+	});
+	if (styleResolver) rebaseParagraphRuns({
+		previousContext: paragraphRunStyleContext(target, styleResolver),
+		paragraphPosition: position,
+		styleResolver,
+		tr
+	});
+	return {
+		tr,
+		changed: true,
+		tracked
+	};
+};
+/**
+* Whether the carried numbering is the paragraph's own or its style's: the
+* record holds `numPr` as the paragraph reads it, and a style's numbering
+* stays the style's rather than becoming the paragraph's own `w:numPr`.
+*/
+const carriedNumberingProvenance = (source, target, keep) => ({ numPrFromStyle: expectParagraphAttrs(keep?.has("numPr") ? target : source).numPrFromStyle });
+/**
+* The paragraph left once the break of the paragraph at `paragraphPos` goes:
+* the next one, or, when its own break is pending deletion too, the first
+* paragraph after it whose break stays. Null when no paragraph follows.
+*/
+const paragraphLeftAfter = ({ doc, paragraphPos, removedBreakPositions }) => {
+	let position = paragraphPos;
+	const start = doc.nodeAt(position);
+	if (!start) return null;
+	let node = start;
+	for (;;) {
+		const nextPos = position + node.nodeSize;
+		const next = doc.resolve(nextPos).nodeAfter;
+		if (!next || next.type !== node.type) return null;
+		const mark = expectParagraphAttrs(next).pPrMark;
+		const nextGoes = removedBreakPositions?.has(nextPos) || mark != null && (mark.kind === "del" || mark.kind === "moveFrom");
+		const afterNext = doc.resolve(nextPos + next.nodeSize).nodeAfter;
+		if (!nextGoes || afterNext?.type !== node.type) return nextPos;
+		position = nextPos;
+		node = next;
+	}
+};
+const recordedFormatting = (node) => ({
+	...paragraphPropertiesSnapshot(node),
+	numPr: expectParagraphAttrs(node).numPr ?? null
+});
+/**
+* A paragraph now holds the break another one had (a split, or a paste into
+* it, leaves that break on the last part) but reads with other properties:
+* record the other's as its property change. Rejecting the inserted breaks
+* leaves this paragraph, which then reads as the one that was there. A
+* pending property change on the other one travels as it is. Returns whether
+* a change under `revision` was written.
+*/
+const recordReplacedParagraphProperties = ({ tr, position, replaced, revision }) => {
+	const target = tr.doc.nodeAt(position);
+	if (!target || target.type !== replaced.type) return false;
+	if (hasSerializableParagraphPropertyChange(expectParagraphAttrs(target)._propertyChanges)) return false;
+	const pending = expectParagraphAttrs(replaced)._propertyChanges;
+	if (hasSerializableParagraphPropertyChange(pending)) {
+		tr.setNodeAttribute(position, "_propertyChanges", pending);
+		return false;
+	}
+	const previousFormatting = recordedFormatting(replaced);
+	if (JSON.stringify(previousFormatting) === JSON.stringify(recordedFormatting(target))) return false;
+	tr.setNodeAttribute(position, "_propertyChanges", [{
+		type: "paragraphPropertyChange",
+		info: revision,
+		previousFormatting
+	}]);
+	return true;
+};
+/**
+* The properties a batch's own property change set on a paragraph: the ones
+* whose value differs from what that change records as before.
+*/
+const propertiesSetInBatch = (node, batchRevisionIds) => {
+	const changes = expectParagraphAttrs(node)._propertyChanges;
+	const change = Array.isArray(changes) ? changes.find(({ info }) => batchRevisionIds.has(info.id)) : void 0;
+	if (change === void 0) return /* @__PURE__ */ new Set();
+	const before = change.previousFormatting ?? {};
+	const now = paragraphPropertiesSnapshot(node);
+	return new Set([.../* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(now)])].filter((key) => JSON.stringify(before[key]) !== JSON.stringify(now[key])));
+};
+//#endregion
+export { carryParagraphProperties, paragraphLeftAfter, propertiesSetInBatch, recordReplacedParagraphProperties };

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/documentStyleState.d.ts

@@ -0,0 +1,26 @@
+import { document_d_exports } from "../../types/document.js";
+import { BuiltInStyleIndex } from "../../docx/builtInStyles.js";
+import { StyleResolver } from "../styles/styleResolver.js";
+import { EditorState, PluginKey } from "prosemirror-state";
+//#region src/prosemirror/plugins/documentStyleState.d.ts
+declare const documentStylesKey: PluginKey<StyleResolver | null>;
+/** 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
+ * 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 };

package/dist/prosemirror/plugins/documentStyleState.js

@@ -0,0 +1,32 @@
+import { EMPTY_BUILT_IN_STYLE_INDEX } from "../../docx/builtInStyles.js";
+import { PluginKey } from "prosemirror-state";
+//#region src/prosemirror/plugins/documentStyleState.ts
+const documentStylesKey = new PluginKey("documentStyles");
+/** Read the document's StyleResolver, or null when the plugin isn't installed. */
+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
+* paragraph's own outline level rather than to English style ids.
+*/
+function getDocumentBuiltInStyles(state) {
+	return getDocumentStyleResolver(state)?.builtInStyles ?? EMPTY_BUILT_IN_STYLE_INDEX;
+}
+//#endregion
+export { documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleDefinitions, getDocumentStyleResolver };

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

@@ -1,9 +1,8 @@
 import { document_d_exports } from "../../types/document.js";
-import { BuiltInStyleIndex } from "../../docx/builtInStyles.js";
 import { StyleResolver } from "../styles/styleResolver.js";
-import { EditorState, Plugin, PluginKey } from "prosemirror-state";
+import { documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleDefinitions, getDocumentStyleResolver } from "./documentStyleState.js";
+import { EditorState, Plugin } from "prosemirror-state";
 //#region src/prosemirror/plugins/documentStyles.d.ts
-declare const documentStylesKey: PluginKey<StyleResolver | null>;
 /**
  * Create the plugin holding a StyleResolver for the document's `styles` for
  * the lifetime of the EditorState. The resolver is fixed per document load;
@@ -12,16 +11,7 @@ declare const documentStylesKey: PluginKey<StyleResolver | null>;
  * have one.
  */
 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;
-/**
- * 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
- * paragraph's own outline level rather than to English style ids.
- */
-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 };