@stll/folio-core 0.52.0 → 0.53.0

package/dist/prosemirror/listLabels.js

@@ -0,0 +1,111 @@
+import { bulletMarkerFontName, convertBulletToUnicode } from "../docx/bulletMarkers.js";
+import { paragraphNumberingReference, paragraphNumberingReferenceId } from "../docx/numberingReference.js";
+import { advanceListMarker, advanceVisibleListMarker, cloneListCounterState, createListCounterState } from "./listMarker.js";
+import { hasListRendering } from "./listRenderingAttrs.js";
+import { paragraphNumberingAttr } from "./numberingAttr.js";
+//#region src/prosemirror/listLabels.ts
+/**
+* The number or bullet a paragraph shows beside its text, as a reader reports
+* it: counted in document order by the counter the page paints its markers
+* with (`advanceVisibleListMarker`), so a reader's labels follow every edit.
+* The `listMarker` attr is the marker the parser resolved when the document
+* was opened; an item inserted, deleted, moved or restarted since leaves it
+* stale for that item and every item after it.
+*
+* A reader counts inside the walk it already makes over the document (the AI
+* snapshot's, Markdown's), one step per paragraph, so an edit costs nothing
+* until something reads the document.
+*/
+/**
+* The cached text of a `LISTNUM` field the parser folded into the marker
+* (`7.1\t(a)`). The level's template does not carry it, so it is kept as read.
+*/
+const foldedFieldSuffix = (attrs) => {
+	const marker = attrs.listMarker;
+	const template = attrs.listMarkerTemplate;
+	if (!marker || !template || template.includes("	")) return "";
+	const tab = marker.indexOf("	");
+	return tab === -1 ? "" : marker.slice(tab);
+};
+const withoutNumbering = (attrs) => {
+	const unnumbered = { ...attrs };
+	Reflect.deleteProperty(unnumbered, "numPr");
+	return unnumbered;
+};
+const staticMarker = (attrs) => {
+	const marker = attrs.listMarker;
+	if (!marker) return;
+	return (attrs.listIsBullet ? convertBulletToUnicode(marker, bulletMarkerFontName(attrs.listMarkerFormatting)) : marker).trim() || void 0;
+};
+/** Most paragraphs: nothing to count and no marker to show. */
+const isPlainParagraph = (attrs) => attrs.numPr == null && attrs.listMarker == null && attrs.listMarkerTemplate == null && (attrs._propertyChanges == null || attrs._propertyChanges.length === 0);
+const NO_PREVIOUS_LIST = {
+	abstractNumId: null,
+	fromStyle: false,
+	numId: null
+};
+/**
+* The attrs the counter reads for a paragraph of the document model, as
+* `toProseDoc` projects them (`listRenderingAttrPatch`), without the layout
+* attrs no label depends on: a reader that walks the model (Markdown) counts
+* every list paragraph through here.
+*/
+const listLabelAttrsFromRendering = (rendering, numPrFromStyle) => {
+	const attrs = { numPr: paragraphNumberingAttr(paragraphNumberingReference({
+		numId: rendering.numId,
+		ilvl: rendering.level
+	})) };
+	if (numPrFromStyle) attrs.numPrFromStyle = paragraphNumberingAttr(numPrFromStyle);
+	if (rendering.marker) attrs.listMarker = rendering.marker;
+	if (rendering.markerTemplate) attrs.listMarkerTemplate = rendering.markerTemplate;
+	if (rendering.isBullet) attrs.listIsBullet = true;
+	if (rendering.isLegal) attrs.listIsLegal = true;
+	if (rendering.numFmt) attrs.listNumFmt = rendering.numFmt;
+	if (rendering.markerHidden) attrs.listMarkerHidden = true;
+	if (rendering.markerFormatting) attrs.listMarkerFormatting = rendering.markerFormatting;
+	if (rendering.levelNumFmts) attrs.listLevelNumFmts = rendering.levelNumFmts;
+	if (rendering.levelStarts) attrs.listLevelStarts = rendering.levelStarts;
+	if (rendering.abstractNumId !== void 0) attrs.listAbstractNumId = rendering.abstractNumId;
+	if (rendering.startOverride !== void 0) attrs.listStartOverride = rendering.startOverride;
+	if (rendering.implicitChildLevelAdvances !== void 0) attrs.listImplicitChildLevelAdvances = rendering.implicitChildLevelAdvances;
+	return attrs;
+};
+/**
+* A counter over paragraph attrs in document order. Call it for every
+* paragraph, numbered or not: whether a list continues depends on what stands
+* between its items.
+*/
+const createListLabelCounter = () => {
+	const final = createListCounterState();
+	let streams = null;
+	let originalPreviousList = NO_PREVIOUS_LIST;
+	const advance = (counted) => {
+		const tracked = counted.pPrMark != null || counted._propertyChanges != null && counted._propertyChanges.length > 0;
+		if (streams === null && tracked) {
+			const original = cloneListCounterState(final);
+			original.previousList = { ...originalPreviousList };
+			streams = {
+				final,
+				original
+			};
+		}
+		if (streams !== null) return advanceVisibleListMarker(counted, streams).marker;
+		const marker = advanceListMarker(counted, final);
+		if (counted.numPr) originalPreviousList = final.previousList ?? NO_PREVIOUS_LIST;
+		return marker;
+	};
+	return (attrs) => {
+		if (isPlainParagraph(attrs)) {
+			final.previousList = NO_PREVIOUS_LIST;
+			return;
+		}
+		const rendered = hasListRendering(attrs);
+		const marker = advance(rendered ? attrs : withoutNumbering(attrs));
+		if (attrs.listMarkerHidden === true || !rendered) return;
+		const counted = paragraphNumberingReferenceId(attrs.numPr) === void 0 ? null : marker?.trim();
+		if (counted) return `${counted}${foldedFieldSuffix(attrs)}`;
+		return staticMarker(attrs);
+	};
+};
+//#endregion
+export { createListLabelCounter, listLabelAttrsFromRendering };

package/dist/prosemirror/listNumbering.d.ts

@@ -0,0 +1,110 @@
+import { ListKind, ListLevelFormat } from "../docx/listNumberingInstances.js";
+import { ParagraphAttrs, ParagraphPropertyChangeAttrs } from "./schema/nodes.js";
+import { NumberingMap } from "../docx/numberingParser.js";
+import { Node, ResolvedPos } from "prosemirror-model";
+import { Command, EditorState, Transaction } from "prosemirror-state";
+//#region src/prosemirror/listNumbering.d.ts
+/** What a list command or typed marker asks for. */
+type ListRequest = {
+  kind: ListKind;
+  /**
+   * The first level's format. A neighbouring list is continued only when its
+   * level has this format; a new list is defined with it.
+   */
+  format?: ListLevelFormat | undefined;
+  /** The value a new list's first item shows. */
+  start?: number | undefined;
+};
+type PreviousFormatting = NonNullable<ParagraphPropertyChangeAttrs["previousFormatting"]>;
+/**
+ * The list rendering a paragraph takes when a `w:pPrChange` is rejected. A
+ * reject restores the recorded numbering, but the rendering attrs sit outside
+ * the scope it restores wholesale, so a record that does not state them (one
+ * written by an operation, or read from a file) would leave the rendering of
+ * the numbering it undoes: a paragraph restored to no numbering still showed
+ * the marker it was given. When the reject changes the numbering, the
+ * rendering is recomputed from the restored numbering; otherwise it stays.
+ */
+type RejectedListRenderingOptions = {
+  /** The paragraph's attrs before the reject. */
+  current: Pick<ParagraphAttrs, "numPr">;
+  /** The previous state the rejected record restores. */
+  previousFormatting: PreviousFormatting | null | undefined;
+  numbering: NumberingMap | null;
+};
+declare const rejectedListRenderingPatch: ({ current, previousFormatting, numbering }: RejectedListRenderingOptions) => Record<string, unknown>;
+/** Where the paragraphs a command numbers go. */
+type ListTarget = {
+  numId: number;
+  /** The level a paragraph that is not yet a list item takes. */
+  ilvl: number;
+  /** Definitions the target is resolved in, including one minted for it. */
+  numbering: NumberingMap;
+};
+type ResolveListTargetOptions = {
+  numbering: NumberingMap | null;
+  $from: ResolvedPos;
+  $to: ResolvedPos;
+  /** Candidate requests, most likely first (see `listRequestsForMarker`). */
+  requests: readonly ListRequest[];
+};
+/**
+ * The list a paragraph range joins: the list directly above it, else the one
+ * directly below it, when it matches one of `requests`; otherwise a new list:
+ * an unused instance the package already defines for the first request, or
+ * one defined for it.
+ */
+declare const resolveListTarget: ({ numbering, $from, $to, requests }: ResolveListTargetOptions) => ListTarget | null;
+/** A paragraph's attrs as an item of `numId` at `ilvl`, resolved in `numbering`. */
+declare const listItemAttrs: (attrs: Record<string, unknown>, { numId, ilvl }: {
+  numId: number;
+  ilvl: number;
+}, numbering: NumberingMap) => Record<string, unknown>;
+type ParagraphUpdate = {
+  pos: number;
+  node: Node;
+  next: Record<string, unknown>;
+};
+type ApplyParagraphUpdatesOptions = {
+  tr: Transaction;
+  state: EditorState;
+  updates: readonly ParagraphUpdate[];
+};
+/**
+ * Write `updates` into `tr`, each recorded as a tracked change while the
+ * editor is suggesting. `pos` is a position in `tr.doc`.
+ */
+declare const applyParagraphUpdates: ({ tr, state, updates }: ApplyParagraphUpdatesOptions) => void;
+/**
+ * Start the list over at `value` from the selected item: *Set Numbering
+ * Value* with *Start new list*. The item and every later item of
+ * its list move to a new instance of the same definition, whose
+ * `w:startOverride` at the item's level is `value`.
+ */
+declare const setNumberingValue: (value: number) => Command;
+/** *Restart at 1*: the selected item starts its list over at one. */
+declare const restartNumbering: Command;
+/**
+ * *Continue Numbering*: the selected item and the rest of its list
+ * join the nearest earlier list of the same kind, so their numbers carry on
+ * from it. Not applicable when no such list precedes the item.
+ */
+declare const continueNumbering: Command;
+/** What a context menu offers for the item the selection is in. */
+type ListNumberingMenuState = {
+  readonly type: "none";
+} | {
+  readonly type: "listItem";
+  readonly canContinue: boolean;
+};
+declare const NO_LIST_NUMBERING_MENU: {
+  readonly type: "none";
+};
+/**
+ * Whether the selection is in a list item whose numbering can be restarted
+ * or set, and whether an earlier list lets it continue: the enabled state of
+ * those menu entries.
+ */
+declare const listNumberingMenuState: (state: EditorState) => ListNumberingMenuState;
+//#endregion
+export { ListNumberingMenuState, ListRequest, NO_LIST_NUMBERING_MENU, RejectedListRenderingOptions, applyParagraphUpdates, continueNumbering, listItemAttrs, listNumberingMenuState, rejectedListRenderingPatch, resolveListTarget, restartNumbering, setNumberingValue };

package/dist/prosemirror/listNumbering.js

@@ -0,0 +1,345 @@
+import { mintListInstance, restartListInstance } from "../docx/listNumberingInstances.js";
+import { createNumberingMap, isBulletLevel } from "../docx/numberingParser.js";
+import { paragraphNumberingLevel, paragraphNumberingReferenceId, sameStatedParagraphNumbering } from "../docx/numberingReference.js";
+import { expectParagraphAttrs } from "./attrs/index.js";
+import { paragraphPropertiesSnapshot } from "./commands/propertyChangeScope.js";
+import { CLEARED_LIST_RENDERING_ATTRS } from "./listMarker.js";
+import { LIST_RENDERING_ATTR_KEYS } from "./listRenderingAttrs.js";
+import { getDocumentNumbering } from "./plugins/documentNumbering.js";
+import { SUGGESTION_META, makeRevisionInfo } from "./plugins/suggestionMode.js";
+import { listAttrsFromNumbering } from "./styles/resolvedStyleAttrs.js";
+//#region src/prosemirror/listNumbering.ts
+const PARAGRAPH_NODE = "paragraph";
+/**
+* The paragraph's properties as a `w:pPrChange` records them before a list
+* change: every non-null in-scope attr (a reject restores the scope
+* wholesale, so an unrecorded one would be wiped), plus the numbering and the
+* list-rendering bookkeeping with explicit nulls (those sit outside the
+* wholesale scope, so only recorded keys restore).
+*/
+const listChangeSnapshot = (node, attrs) => {
+	const previousFormatting = paragraphPropertiesSnapshot(node.type.create(attrs, node.content, node.marks));
+	previousFormatting["numPr"] = attrs["numPr"] ?? null;
+	for (const key of LIST_RENDERING_ATTR_KEYS) previousFormatting[key] = attrs[key] ?? null;
+	return previousFormatting;
+};
+/**
+* The original state a pending record describes, completed with the list
+* attrs it may not state. A record written by a list command states them all.
+* One written for another property (or read from a file) states the scope
+* only: its numbering is the original's, and an absent one means the original
+* had none, so the rendering is recomputed from it rather than copied from
+* the live paragraph, whose list may since have changed.
+*/
+const originalListFormatting = (record, numbering) => {
+	const original = { ...record };
+	if (recordsListRendering(record)) return original;
+	Object.assign(original, listRenderingFor(record.numPr, numbering));
+	original["numPr"] = record.numPr ?? null;
+	return original;
+};
+/** Whether a `w:pPrChange` record states the list rendering it had (a list command's does). */
+const recordsListRendering = (record) => LIST_RENDERING_ATTR_KEYS.some((key) => Object.hasOwn(record, key));
+/** Every list-rendering attr for `numPr`: its level's, or all cleared when it numbers nothing. */
+const listRenderingFor = (numPr, numbering) => {
+	const numId = paragraphNumberingReferenceId(numPr ?? void 0);
+	const rendering = numId === void 0 ? CLEARED_LIST_RENDERING_ATTRS : listAttrsFromNumbering({
+		numId,
+		ilvl: paragraphNumberingLevel(numPr ?? void 0) ?? 0
+	}, numbering);
+	const attrs = {};
+	for (const key of LIST_RENDERING_ATTR_KEYS) attrs[key] = rendering[key] ?? null;
+	return attrs;
+};
+const rejectedListRenderingPatch = ({ current, previousFormatting, numbering }) => {
+	const record = previousFormatting ?? {};
+	if (recordsListRendering(record)) return {};
+	const restored = record.numPr ?? void 0;
+	if (sameStatedParagraphNumbering(restored, current.numPr ?? void 0)) return {};
+	return listRenderingFor(restored, numbering);
+};
+const canonicalJson = (value) => JSON.stringify(value, (_key, nested) => nested !== null && typeof nested === "object" && !Array.isArray(nested) ? Object.fromEntries(Object.entries(nested).filter(([, entry]) => entry !== null && entry !== void 0).toSorted(([left], [right]) => left.localeCompare(right))) : nested);
+/**
+* `next` with the list change recorded as a tracked paragraph-property change.
+*
+* A paragraph holds at most one serializable `w:pPrChange`. When it already
+* has one, the record is replaced by one that keeps the original previous
+* state: a second change under tracking is a further change to the same
+* paragraph, and rejecting it must restore the paragraph as it was before
+* either. When the change brings the paragraph back to that original, there
+* is nothing left to track and the author's own record is dropped.
+*
+* A pending record by another author (another reviewer's, or one read from
+* the file) keeps its author, id and date: the change joins that revision
+* rather than re-attributing it, and it is never dropped.
+*/
+const trackListChange = ({ current, next, rev, numbering }) => {
+	const currentAttrs = expectParagraphAttrs(current);
+	const existing = currentAttrs._propertyChanges ?? [];
+	const pending = existing.find(({ info }) => info.provenance !== "suggested");
+	const retained = existing.filter((change) => change !== pending);
+	const previousFormatting = pending?.previousFormatting ? originalListFormatting(pending.previousFormatting, numbering) : listChangeSnapshot(current, currentAttrs);
+	const ownPending = pending !== void 0 && pending.info.author === rev.author;
+	if (ownPending && canonicalJson(previousFormatting) === canonicalJson(listChangeSnapshot(current, next))) return {
+		...next,
+		_propertyChanges: retained.length > 0 ? retained : null
+	};
+	const record = pending && !ownPending ? {
+		...pending,
+		previousFormatting
+	} : {
+		type: "paragraphPropertyChange",
+		info: {
+			id: rev.id,
+			author: rev.author,
+			date: rev.date
+		},
+		previousFormatting
+	};
+	return {
+		...next,
+		_propertyChanges: [...retained, record]
+	};
+};
+const levelKind = (level) => isBulletLevel(level) ? "bullet" : "numbered";
+/** A level's text with its placeholders blanked: `%1.` and `%3.` read alike. */
+const levelTextShape = (lvlText) => lvlText.replaceAll(/%\d/gu, "%");
+const levelMatches = (level, request) => {
+	if (levelKind(level) !== request.kind) return false;
+	const { format } = request;
+	return format === void 0 || level.numFmt === format.numFmt && levelTextShape(level.lvlText) === levelTextShape(format.lvlText);
+};
+/**
+* The list `node` is an item of, when the paragraph states it directly. A
+* numbering its style supplies is the style's, and is not offered to the
+* paragraphs around it.
+*/
+const directListMembership = (node, numbering) => {
+	if (!node || node.type.name !== PARAGRAPH_NODE) return null;
+	const attrs = expectParagraphAttrs(node);
+	const numId = paragraphNumberingReferenceId(attrs.numPr);
+	if (numId === void 0 || numId === paragraphNumberingReferenceId(attrs.numPrFromStyle)) return null;
+	const ilvl = paragraphNumberingLevel(attrs.numPr) ?? 0;
+	const level = numbering?.getLevel(numId, ilvl) ?? null;
+	return level ? {
+		numId,
+		ilvl,
+		level
+	} : null;
+};
+/** The block directly before or after the paragraph `$pos` sits in. */
+const siblingOf = ($pos, direction) => {
+	const depth = $pos.depth;
+	if (depth === 0) return null;
+	const index = $pos.index(depth - 1);
+	return $pos.node(depth - 1).maybeChild(direction === "before" ? index - 1 : index + 1);
+};
+/** Every instance a paragraph of `doc` names: directly, through its style, or as a tracked change's previous state. */
+const referencedNumIds = (doc) => {
+	const referenced = /* @__PURE__ */ new Set();
+	const add = (numPr) => {
+		const numId = paragraphNumberingReferenceId(numPr ?? void 0);
+		if (numId !== void 0) referenced.add(numId);
+	};
+	doc.descendants((node) => {
+		if (node.type.name !== PARAGRAPH_NODE) return true;
+		const attrs = expectParagraphAttrs(node);
+		add(attrs.numPr);
+		add(attrs.numPrFromStyle);
+		for (const change of attrs._propertyChanges ?? []) add(change.previousFormatting?.numPr);
+		return false;
+	});
+	return referenced;
+};
+/**
+* An instance the package defines for `request` that nothing uses yet: a host
+* that prepares a document with an empty list of each kind means the first
+* list of that kind to be it. An instance tied to a paragraph style (a level
+* naming a `w:pStyle`, or a style link) belongs to that style and is never
+* offered.
+*/
+const unusedInstanceFor = (numbering, doc, request) => {
+	const referenced = referencedNumIds(doc);
+	return numbering.definitions.nums.find(({ numId, abstractNumId }) => {
+		const abstract = numbering.getAbstract(abstractNumId);
+		const level = numbering.getLevel(numId, 0);
+		return !referenced.has(numId) && abstract !== null && abstract.styleLink === void 0 && abstract.numStyleLink === void 0 && abstract.levels.every(({ pStyle }) => pStyle === void 0) && level !== null && levelMatches(level, request) && (level.start ?? 1) === (request.start ?? level.start ?? 1);
+	})?.numId;
+};
+/**
+* The list a paragraph range joins: the list directly above it, else the one
+* directly below it, when it matches one of `requests`; otherwise a new list:
+* an unused instance the package already defines for the first request, or
+* one defined for it.
+*/
+const resolveListTarget = ({ numbering, $from, $to, requests }) => {
+	const [first] = requests;
+	if (!first) return null;
+	for (const neighbour of [siblingOf($from, "before"), siblingOf($to, "after")]) {
+		const membership = directListMembership(neighbour, numbering);
+		if (numbering && membership && requests.some((request) => levelMatches(membership.level, request))) return {
+			numId: membership.numId,
+			ilvl: membership.ilvl,
+			numbering
+		};
+	}
+	const unused = numbering ? unusedInstanceFor(numbering, $from.doc, first) : void 0;
+	if (numbering && unused !== void 0) return {
+		numId: unused,
+		ilvl: 0,
+		numbering
+	};
+	const minted = mintListInstance(numbering?.definitions, first);
+	return {
+		numId: minted.numId,
+		ilvl: 0,
+		numbering: createNumberingMap(minted.definitions)
+	};
+};
+/** A paragraph's attrs as an item of `numId` at `ilvl`, resolved in `numbering`. */
+const listItemAttrs = (attrs, { numId, ilvl }, numbering) => ({
+	...attrs,
+	...listAttrsFromNumbering({
+		numId,
+		ilvl
+	}, numbering),
+	listImplicitChildLevelAdvances: attrs["listImplicitChildLevelAdvances"] ?? null,
+	listMarkerSecondSlotOffsetTwips: attrs["listMarkerSecondSlotOffsetTwips"] ?? null
+});
+/**
+* Write `updates` into `tr`, each recorded as a tracked change while the
+* editor is suggesting. `pos` is a position in `tr.doc`.
+*/
+const applyParagraphUpdates = ({ tr, state, updates }) => {
+	const rev = makeRevisionInfo(state);
+	const numbering = getDocumentNumbering(state);
+	for (const { pos, node, next } of updates) {
+		const attrs = rev ? trackListChange({
+			current: node,
+			next,
+			rev,
+			numbering
+		}) : next;
+		tr.setNodeMarkup(pos, void 0, attrs);
+	}
+	if (rev) tr.setMeta(SUGGESTION_META, true);
+};
+/** The paragraph the selection starts in, when it is a direct list item. */
+const selectedListParagraph = (state) => {
+	const { $from } = state.selection;
+	if ($from.parent.type.name !== PARAGRAPH_NODE || $from.depth === 0) return null;
+	const membership = directListMembership($from.parent, getDocumentNumbering(state));
+	return membership ? {
+		pos: $from.before(),
+		node: $from.parent,
+		membership
+	} : null;
+};
+/** Every direct item of `numId` from `fromPos` to the end of the document. */
+const itemsFrom = (state, numId, fromPos) => {
+	const numbering = getDocumentNumbering(state);
+	const items = [];
+	state.doc.descendants((node, pos) => {
+		if (node.type.name !== PARAGRAPH_NODE) return true;
+		if (pos >= fromPos) {
+			const membership = directListMembership(node, numbering);
+			if (membership?.numId === numId) items.push({
+				pos,
+				node,
+				membership
+			});
+		}
+		return false;
+	});
+	return items;
+};
+const moveItems = ({ state, items, numId, numbering }) => {
+	const tr = state.tr;
+	applyParagraphUpdates({
+		tr,
+		state,
+		updates: items.map(({ pos, node, membership }) => ({
+			pos,
+			node,
+			next: listItemAttrs(node.attrs, {
+				numId,
+				ilvl: membership.ilvl
+			}, numbering)
+		}))
+	});
+	return tr.scrollIntoView();
+};
+/**
+* Start the list over at `value` from the selected item: *Set Numbering
+* Value* with *Start new list*. The item and every later item of
+* its list move to a new instance of the same definition, whose
+* `w:startOverride` at the item's level is `value`.
+*/
+const setNumberingValue = (value) => (state, dispatch) => {
+	if (!Number.isSafeInteger(value) || value < 0) return false;
+	const selected = selectedListParagraph(state);
+	const numbering = getDocumentNumbering(state);
+	const abstractNumId = selected ? numbering?.getAbstractNumId(selected.membership.numId) : null;
+	if (!selected || !numbering || abstractNumId === null || abstractNumId === void 0) return false;
+	if (!dispatch) return true;
+	const restarted = restartListInstance(numbering.definitions, {
+		abstractNumId,
+		ilvl: selected.membership.ilvl,
+		start: value
+	});
+	dispatch(moveItems({
+		state,
+		items: itemsFrom(state, selected.membership.numId, selected.pos),
+		numId: restarted.numId,
+		numbering: createNumberingMap(restarted.definitions)
+	}));
+	return true;
+};
+/** *Restart at 1*: the selected item starts its list over at one. */
+const restartNumbering = (state, dispatch) => setNumberingValue(1)(state, dispatch);
+/** The nearest list before `beforePos` of the kind `membership` has, other than its own. */
+const previousListOfKind = (state, beforePos, membership) => {
+	const numbering = getDocumentNumbering(state);
+	const kind = levelKind(membership.level);
+	let found = null;
+	state.doc.descendants((node, pos) => {
+		if (pos >= beforePos) return false;
+		if (node.type.name !== PARAGRAPH_NODE) return true;
+		const candidate = directListMembership(node, numbering);
+		if (candidate && candidate.numId !== membership.numId && levelKind(candidate.level) === kind) found = candidate.numId;
+		return false;
+	});
+	return found;
+};
+/**
+* *Continue Numbering*: the selected item and the rest of its list
+* join the nearest earlier list of the same kind, so their numbers carry on
+* from it. Not applicable when no such list precedes the item.
+*/
+const continueNumbering = (state, dispatch) => {
+	const selected = selectedListParagraph(state);
+	const numbering = getDocumentNumbering(state);
+	if (!selected || !numbering) return false;
+	const previous = previousListOfKind(state, selected.pos, selected.membership);
+	if (previous === null) return false;
+	if (!dispatch) return true;
+	dispatch(moveItems({
+		state,
+		items: itemsFrom(state, selected.membership.numId, selected.pos),
+		numId: previous,
+		numbering
+	}));
+	return true;
+};
+const NO_LIST_NUMBERING_MENU = { type: "none" };
+/**
+* Whether the selection is in a list item whose numbering can be restarted
+* or set, and whether an earlier list lets it continue: the enabled state of
+* those menu entries.
+*/
+const listNumberingMenuState = (state) => restartNumbering(state) ? {
+	type: "listItem",
+	canContinue: continueNumbering(state)
+} : NO_LIST_NUMBERING_MENU;
+//#endregion
+export { NO_LIST_NUMBERING_MENU, applyParagraphUpdates, continueNumbering, listItemAttrs, listNumberingMenuState, rejectedListRenderingPatch, resolveListTarget, restartNumbering, setNumberingValue };

package/dist/prosemirror/listRenderingAttrs.d.ts

@@ -30,8 +30,17 @@ declare const LIST_RENDERING_ATTR_KEYS: readonly ListRenderingAttrKey[];
  * never authors them as `false` or `""` deliberately.
  */
 declare const listRenderingAttrPatch: (rendering: document_d_exports.ListRendering) => Partial<ParagraphAttrs>;
+/**
+ * Whether `attrs` carry what their numbering level renders as. Only a level
+ * the numbering defines gets a rendering (`toProseDoc` projects the parser's,
+ * a list command or operation writes the level's), so a reference without one
+ * names a level nothing defines: Word paints no marker for it.
+ */
+declare const hasListRendering: (attrs: Pick<ParagraphAttrs, "listMarker" | "listIsBullet" | "listNumFmt">) => boolean;
+/** The attrs a rendering is read back from: a paragraph's, or a recorded previous state's. */
+type ListRenderingSourceAttrs = Pick<ParagraphAttrs, ListRenderingAttrKey | "numPr">;
 type ListRenderingFromAttrsOptions = {
-  attrs: ParagraphAttrs;
+  attrs: ListRenderingSourceAttrs;
   numId: number;
 };
 /**
@@ -40,4 +49,4 @@ type ListRenderingFromAttrsOptions = {
  */
 declare const listRenderingFromAttrs: ({ attrs, numId }: ListRenderingFromAttrsOptions) => document_d_exports.ListRendering;
 //#endregion
-export { LIST_RENDERING_ATTR_BY_FIELD, LIST_RENDERING_ATTR_KEYS, ListRenderingAttrField, ListRenderingAttrKey, listRenderingAttrPatch, listRenderingFromAttrs };
+export { LIST_RENDERING_ATTR_BY_FIELD, LIST_RENDERING_ATTR_KEYS, ListRenderingAttrField, ListRenderingAttrKey, ListRenderingSourceAttrs, hasListRendering, listRenderingAttrPatch, listRenderingFromAttrs };

package/dist/prosemirror/listRenderingAttrs.js

@@ -60,6 +60,13 @@ const listRenderingAttrPatch = (rendering) => {
 	return definedAttrs(patch);
 };
 /**
+* Whether `attrs` carry what their numbering level renders as. Only a level
+* the numbering defines gets a rendering (`toProseDoc` projects the parser's,
+* a list command or operation writes the level's), so a reference without one
+* names a level nothing defines: Word paints no marker for it.
+*/
+const hasListRendering = (attrs) => attrs.listMarker != null || attrs.listIsBullet === true || attrs.listNumFmt != null;
+/**
 * Inverse of `listRenderingAttrPatch`. The caller decides whether the
 * paragraph is a list item at all; this only reassembles the fields.
 */
@@ -90,4 +97,4 @@ const listRenderingFromAttrs = ({ attrs, numId }) => {
 	};
 };
 //#endregion
-export { LIST_RENDERING_ATTR_BY_FIELD, LIST_RENDERING_ATTR_KEYS, listRenderingAttrPatch, listRenderingFromAttrs };
+export { LIST_RENDERING_ATTR_BY_FIELD, LIST_RENDERING_ATTR_KEYS, hasListRendering, listRenderingAttrPatch, listRenderingFromAttrs };