@stll/folio-core 0.46.0 → 0.47.1

package/dist/prosemirror/emptyRangeAnchor.d.ts

@@ -0,0 +1,53 @@
+import { ParagraphContent } from "../types/content.js";
+//#region src/prosemirror/emptyRangeAnchor.d.ts
+/** A marker that opens a range the editor otherwise projects as a mark. */
+type RangeStartType = Extract<ParagraphContent["type"], `${string}RangeStart`>;
+/**
+ * Which end closes which start.
+ *
+ * Both sides are derived from the model's own content union rather than
+ * listed, so a `…RangeStart` added to `ParagraphContent` fails this
+ * `satisfies` until somebody has said what closes it.
+ */
+declare const RANGE_END_FOR_START: {
+  readonly commentRangeStart: "commentRangeEnd";
+  readonly moveFromRangeStart: "moveFromRangeEnd";
+  readonly moveToRangeStart: "moveToRangeEnd";
+};
+/**
+ * The `rangeAnchor` node's attributes: a start and the end that closes it,
+ * with nothing between them.
+ *
+ * Distributing over the start types pairs each start with exactly its own end,
+ * so a comment start holding a move end is not a value this type has.
+ */
+type RangeAnchorAttrs = { [Start in RangeStartType]: {
+  start: Extract<ParagraphContent, {
+    type: Start;
+  }>;
+  end: Extract<ParagraphContent, {
+    type: (typeof RANGE_END_FOR_START)[Start];
+  }>;
+}; }[RangeStartType];
+/** Whether this content is one of the six range markers, either half. */
+declare const isRangeMarker: (content: ParagraphContent) => boolean;
+type EmptyRangePlan = {
+  /** The anchor to emit in place of the marker at this index. */
+  anchorAt: ReadonlyMap<number, RangeAnchorAttrs>;
+  /** An index whose marker an anchor at an earlier index already holds. */
+  closedAt: ReadonlySet<number>;
+};
+/**
+ * The empty ranges in one inline sequence, by the index each one's start sits
+ * at.
+ *
+ * The window a pair may close within is a maximal run of range markers and
+ * nothing else, which is what "spans no content" means once the transparent
+ * wrappers are lifted. Nesting inside such a run is not meaningful — neither
+ * order covers anything — so the pairs are taken nearest first and each anchor
+ * stays at its own start's index. A start whose end is outside the run is a
+ * range over content and keeps the mark path; so does an end with no start.
+ */
+declare const planEmptyRanges: (content: readonly ParagraphContent[]) => EmptyRangePlan;
+//#endregion
+export { EmptyRangePlan, RANGE_END_FOR_START, RangeAnchorAttrs, isRangeMarker, planEmptyRanges };

package/dist/prosemirror/emptyRangeAnchor.js

@@ -0,0 +1,158 @@
+import { panic } from "better-result";
+//#region src/prosemirror/emptyRangeAnchor.ts
+/**
+* A comment or tracked-move range that spans no content, carried across the
+* editor projection as one zero-width atom.
+*
+* A reviewer who comments at an insertion point rather than over a selection
+* gets `w:commentRangeStart` immediately followed by `w:commentRangeEnd`, and
+* then the `w:commentReference` run. The editor spells a comment as a `comment`
+* mark over the inline content its range covers, and a range over nothing has
+* no leaf to mark, so the projection dropped both markers. The comment still
+* listed — the reference survives as its own atom — but its anchor position was
+* gone, and the save wrote a reference with no range at all. A tracked move
+* whose range spans nothing loses its `w:name` the same way, and with it the
+* only thing binding the move's source to its destination.
+*
+* The pair is one thing rather than two, so it is one node. Two adjacent
+* boundary nodes, which is what the bookmark precedent would suggest, would
+* leave a position between them for a caret to sit in; typing there would turn
+* a point comment into a range the reviewer never drew.
+*
+* What the node holds is the model's own markers, not a copy of their fields:
+* an attribute added to `CT_MoveBookmark` is carried without being named here.
+*
+* A range that spans a bookmark boundary, a comment reference or captured
+* markup is not in this class and needs no anchor: each of those is an inline
+* node that carries a mark, so the mark path already keeps the range. Only a
+* range with nothing whatever between its two markers has no carrier.
+*/
+/**
+* Which end closes which start.
+*
+* Both sides are derived from the model's own content union rather than
+* listed, so a `…RangeStart` added to `ParagraphContent` fails this
+* `satisfies` until somebody has said what closes it.
+*/
+const RANGE_END_FOR_START = {
+	commentRangeStart: "commentRangeEnd",
+	moveFromRangeStart: "moveFromRangeEnd",
+	moveToRangeStart: "moveToRangeEnd"
+};
+const RANGE_MARKER_TYPES = /* @__PURE__ */ new Set([...Object.keys(RANGE_END_FOR_START), ...Object.values(RANGE_END_FOR_START)]);
+/** Whether this content is one of the six range markers, either half. */
+const isRangeMarker = (content) => RANGE_MARKER_TYPES.has(content.type);
+const isRangeStart = (content) => content.type in RANGE_END_FOR_START;
+const isRangeEnd = (content) => content.type === "commentRangeEnd" || content.type === "moveFromRangeEnd" || content.type === "moveToRangeEnd";
+const NO_EMPTY_RANGES = {
+	anchorAt: /* @__PURE__ */ new Map(),
+	closedAt: /* @__PURE__ */ new Set()
+};
+/**
+* The empty ranges in one inline sequence, by the index each one's start sits
+* at.
+*
+* The window a pair may close within is a maximal run of range markers and
+* nothing else, which is what "spans no content" means once the transparent
+* wrappers are lifted. Nesting inside such a run is not meaningful — neither
+* order covers anything — so the pairs are taken nearest first and each anchor
+* stays at its own start's index. A start whose end is outside the run is a
+* range over content and keeps the mark path; so does an end with no start.
+*/
+const planEmptyRanges = (content) => {
+	const anchorAt = /* @__PURE__ */ new Map();
+	const closedAt = /* @__PURE__ */ new Set();
+	let index = 0;
+	while (index < content.length) {
+		const item = content[index];
+		if (item === void 0 || !isRangeMarker(item)) {
+			index += 1;
+			continue;
+		}
+		let runEnd = index;
+		while (runEnd < content.length) {
+			const candidate = content[runEnd];
+			if (candidate === void 0 || !isRangeMarker(candidate)) break;
+			runEnd += 1;
+		}
+		pairWithinRun({
+			content,
+			from: index,
+			to: runEnd,
+			anchorAt,
+			closedAt
+		});
+		index = runEnd;
+	}
+	if (anchorAt.size === 0) return NO_EMPTY_RANGES;
+	return {
+		anchorAt,
+		closedAt
+	};
+};
+/**
+* The two markers as one anchor, or `null` when the closer does not close this
+* start.
+*
+* The branches restate no pairing: `RangeAnchorAttrs` is derived from
+* {@link RANGE_END_FOR_START}, so a branch that named the wrong end would not
+* be assignable, and a start type the model gains fails the exhaustiveness
+* check below.
+*/
+const pairedAnchor = (opener, closer) => {
+	switch (opener.type) {
+		case "commentRangeStart": return closer.type === "commentRangeEnd" && closer.id === opener.id ? {
+			start: opener,
+			end: closer
+		} : null;
+		case "moveFromRangeStart": return closer.type === "moveFromRangeEnd" && closer.id === opener.id ? {
+			start: opener,
+			end: closer
+		} : null;
+		case "moveToRangeStart": return closer.type === "moveToRangeEnd" && closer.id === opener.id ? {
+			start: opener,
+			end: closer
+		} : null;
+		default: panic(`Unsupported range start: ${JSON.stringify(opener)}`);
+	}
+};
+const pairWithinRun = ({ content, from, to, anchorAt, closedAt }) => {
+	const endIndexesByTypeAndId = /* @__PURE__ */ new Map();
+	for (let end = from; end < to; end += 1) {
+		const closer = content[end];
+		if (closer === void 0 || !isRangeEnd(closer)) continue;
+		const key = rangeKey(closer.type, closer.id);
+		const indexes = endIndexesByTypeAndId.get(key);
+		if (indexes === void 0) {
+			endIndexesByTypeAndId.set(key, [end]);
+			continue;
+		}
+		indexes.push(end);
+	}
+	const nextEndByTypeAndId = /* @__PURE__ */ new Map();
+	for (let start = from; start < to; start += 1) {
+		const opener = content[start];
+		if (opener === void 0 || closedAt.has(start) || !isRangeStart(opener)) continue;
+		const key = rangeKey(RANGE_END_FOR_START[opener.type], opener.id);
+		const indexes = endIndexesByTypeAndId.get(key);
+		if (indexes === void 0) continue;
+		let nextEnd = nextEndByTypeAndId.get(key) ?? 0;
+		while (nextEnd < indexes.length && (indexes[nextEnd] ?? -1) <= start) nextEnd += 1;
+		const end = indexes[nextEnd];
+		if (end === void 0) {
+			nextEndByTypeAndId.set(key, nextEnd);
+			continue;
+		}
+		nextEndByTypeAndId.set(key, nextEnd + 1);
+		const closer = content[end];
+		if (closer === void 0) continue;
+		const anchor = pairedAnchor(opener, closer);
+		if (anchor === null) continue;
+		anchorAt.set(start, anchor);
+		closedAt.add(start);
+		closedAt.add(end);
+	}
+};
+const rangeKey = (type, id) => `${type}:${id}`;
+//#endregion
+export { RANGE_END_FOR_START, isRangeMarker, planEmptyRanges };

package/dist/prosemirror/extensions/StarterKit.js

@@ -17,7 +17,8 @@ import { ParagraphChangeTrackerExtension } from "./features/ParagraphChangeTrack
 import { PasteCleanupExtension } from "./features/PasteCleanupExtension.js";
 import { PasteStyleInlinerExtension } from "./features/PasteStyleInlinerExtension.js";
 import { SelectionTrackerExtension } from "./features/SelectionTrackerExtension.js";
-import { MARK_EXTENSIONS } from "./markRegistry.js";
+import { MARK_EXTENSIONS, MARK_NESTING_ORDER } from "./markRegistry.js";
+import { BlockBookmarkBoundaryExtension } from "./nodes/BlockBookmarkBoundaryExtension.js";
 import { BlockSdtExtension } from "./nodes/BlockSdtExtension.js";
 import { BookmarkBoundaryExtension } from "./nodes/BookmarkBoundaryExtension.js";
 import { CommentReferenceExtension } from "./nodes/CommentReferenceExtension.js";
@@ -26,10 +27,12 @@ import { HardBreakExtension } from "./nodes/HardBreakExtension.js";
 import { HorizontalRuleExtension } from "./nodes/HorizontalRuleExtension.js";
 import { ImageExtension } from "./nodes/ImageExtension.js";
 import { MathExtension } from "./nodes/MathExtension.js";
+import { MoveRangeBoundaryExtension } from "./nodes/MoveRangeBoundaryExtension.js";
 import { PageBreakExtension } from "./nodes/PageBreakExtension.js";
 import { PageBreakRunExtension } from "./nodes/PageBreakRunExtension.js";
 import { PreservedBlockExtension } from "./nodes/PreservedBlockExtension.js";
 import { PreservedXmlExtension } from "./nodes/PreservedXmlExtension.js";
+import { RangeAnchorExtension } from "./nodes/RangeAnchorExtension.js";
 import { RenderedPageBreakExtension } from "./nodes/RenderedPageBreakExtension.js";
 import { SdtExtension } from "./nodes/SdtExtension.js";
 import { ShapeExtension } from "./nodes/ShapeExtension.js";
@@ -60,9 +63,12 @@ function createStarterKit(options = {}) {
 		...options.historyDepth !== void 0 ? { depth: options.historyDepth } : {},
 		...options.historyNewGroupDelay !== void 0 ? { newGroupDelay: options.historyNewGroupDelay } : {}
 	}));
-	for (const [name, extension] of Object.entries(MARK_EXTENSIONS)) add(name, extension());
+	for (const name of MARK_NESTING_ORDER) add(name, MARK_EXTENSIONS[name]());
 	add("bookmarkBoundary", BookmarkBoundaryExtension({ getInternalClipboardToken }));
+	add("blockBookmarkBoundary", BlockBookmarkBoundaryExtension());
 	add("commentReference", CommentReferenceExtension({ getInternalClipboardToken }));
+	add("moveRangeBoundary", MoveRangeBoundaryExtension({ getInternalClipboardToken }));
+	add("rangeAnchor", RangeAnchorExtension({ getInternalClipboardToken }));
 	add("hardBreak", HardBreakExtension());
 	add("tab", TabExtension());
 	add("symbol", SymbolExtension());

package/dist/prosemirror/extensions/core/DocExtension.js

@@ -13,7 +13,7 @@ const DocExtension = createNodeExtension({
 			_finalSectionStart: { default: null },
 			_adjustLineHeightInTable: { default: false }
 		},
-		content: "(paragraph | horizontalRule | pageBreak | table | textBox | blockSdt | preservedBlock)+"
+		content: "(paragraph | horizontalRule | pageBreak | table | textBox | blockSdt | preservedBlock | blockBookmarkBoundary)+"
 	}
 });
 //#endregion

package/dist/prosemirror/extensions/core/ParagraphExtension.js

@@ -6,12 +6,15 @@ import { collectHeadings } from "../../../utils/headingCollector.js";
 import { tableOfContentsStyleLevel } from "../../../utils/tableOfContentsStyle.js";
 import { expectParagraphAttrs } from "../../attrs/index.js";
 import { autospacingMatchesBase } from "../../autospacingBase.js";
+import { removeSectionBreakAtSelection, setSectionBreakType } from "../../commands/sectionBreak.js";
 import { directParagraphAlignment } from "../../paragraphAlignment.js";
 import { directionIsRtl } from "../../paragraphDirection.js";
 import { withDirectParagraphSpacing } from "../../paragraphSpacing.js";
 import { getDocumentBuiltInStyles } from "../../plugins/documentStyles.js";
+import { mintSectionProperties, parseSectionBreakType, sectionBreakTypeOf } from "../../sectionCarrier.js";
 import { listAttrsFromResolvedStyle, paragraphAttrsFromResolvedStyle } from "../../styles/resolvedStyleAttrs.js";
 import { createNodeExtension } from "../create.js";
+import { headingOutlineLevel, paragraphNumberingLevel, paragraphNumberingReferenceId } from "@stll/docx-core/model";
 import { Fragment } from "prosemirror-model";
 //#region src/prosemirror/extensions/core/ParagraphExtension.ts
 /**
@@ -24,7 +27,7 @@ import { Fragment } from "prosemirror-model";
 function paragraphAttrsToDOMStyle(attrs) {
 	const rawIndentLeft = Reflect.get(attrs, "indentLeft");
 	let indentLeft = typeof rawIndentLeft === "number" ? rawIndentLeft : void 0;
-	if (attrs.numPr?.numId && (rawIndentLeft === null || rawIndentLeft === void 0)) indentLeft = ((attrs.numPr.ilvl ?? 0) + 1) * 720;
+	if (paragraphNumberingReferenceId(attrs.numPr) !== void 0 && (rawIndentLeft === null || rawIndentLeft === void 0)) indentLeft = ((paragraphNumberingLevel(attrs.numPr) ?? 0) + 1) * 720;
 	const style = paragraphToStyle({
 		...attrs.alignment !== void 0 ? { alignment: attrs.alignment } : {},
 		...attrs.spaceBefore !== void 0 ? { spaceBefore: attrs.spaceBefore } : {},
@@ -60,8 +63,8 @@ function numFmtToClass(numFmt) {
 	}
 }
 function getListClass(numPr, listIsBullet, listNumFmt) {
-	if (!numPr?.numId) return "";
-	const level = numPr.ilvl ?? 0;
+	if (paragraphNumberingReferenceId(numPr) === void 0) return "";
+	const level = paragraphNumberingLevel(numPr) ?? 0;
 	if (listIsBullet) return `docx-list-bullet docx-list-level-${level}`;
 	return `docx-list-numbered ${numFmtToClass(listNumFmt)} docx-list-level-${level}`;
 }
@@ -92,11 +95,11 @@ function cssLengthToTwips(value) {
 */
 function cssTextAlignToAlignment(value) {
 	switch (value.trim().toLowerCase()) {
-		case "left":
-		case "start": return "left";
+		case "left": return "left";
+		case "start": return "start";
 		case "center": return "center";
-		case "right":
-		case "end": return "right";
+		case "right": return "right";
+		case "end": return "end";
 		case "justify": return "both";
 		default: return;
 	}
@@ -244,7 +247,6 @@ const paragraphNodeSpec = {
 		runInWithNext: { default: null },
 		defaultTextFormatting: { default: null },
 		_tableRunFormatting: { default: void 0 },
-		sectionBreakType: { default: null },
 		direction: { default: null },
 		outlineLevel: { default: null },
 		bookmarks: { default: null },
@@ -269,14 +271,14 @@ const paragraphNodeSpec = {
 			const alignmentFromStyle = parseParagraphAlignment(element.dataset["alignmentFromStyle"]);
 			const styleId = element.dataset["styleId"];
 			const tableOfContentsLevel = Number(element.dataset["tableOfContentsLevel"]);
-			const sectionBreakType = element.dataset["sectionBreak"];
+			const sectionBreakType = parseSectionBreakType(element.dataset["sectionBreak"]);
 			const attrs = {
 				...paraId ? { paraId } : {},
 				...alignment ? { alignment } : {},
 				...alignmentFromStyle ? { alignmentFromStyle } : {},
 				...styleId ? { styleId } : {},
 				...Number.isSafeInteger(tableOfContentsLevel) && tableOfContentsLevel > 0 ? { _tableOfContentsLevel: tableOfContentsLevel } : {},
-				...sectionBreakType ? { sectionBreakType } : {}
+				...sectionBreakType ? { _sectionProperties: mintSectionProperties(sectionBreakType) } : {}
 			};
 			const styleAttrs = extractParagraphAttrsFromStyle(element);
 			const mergedAlignment = attrs.alignment || styleAttrs.alignment;
@@ -304,11 +306,12 @@ const paragraphNodeSpec = {
 		getAttrs(dom) {
 			const level = Number.parseInt(tag.charAt(1), 10);
 			const styleAttrs = extractParagraphAttrsFromStyle(dom);
+			const outlineLevel = headingOutlineLevel(level - 1);
 			return {
 				...styleAttrs,
 				...styleAttrs.alignment ? { _originalFormatting: { alignment: styleAttrs.alignment } } : {},
 				styleId: `Heading${level}`,
-				outlineLevel: level - 1
+				...outlineLevel === void 0 ? {} : { outlineLevel }
 			};
 		}
 	}))],
@@ -328,8 +331,9 @@ const paragraphNodeSpec = {
 		if (typeof attrs._tableOfContentsLevel === "number") domAttrs["data-table-of-contents-level"] = String(attrs._tableOfContentsLevel);
 		if (attrs.listMarker) domAttrs["data-list-marker"] = attrs.listMarker;
 		if (directionIsRtl(attrs.direction)) domAttrs["dir"] = "rtl";
-		if (attrs.sectionBreakType) {
-			domAttrs["data-section-break"] = attrs.sectionBreakType;
+		const sectionBreakType = sectionBreakTypeOf(attrs._sectionProperties);
+		if (sectionBreakType) {
+			domAttrs["data-section-break"] = sectionBreakType;
 			domAttrs["class"] = `${domAttrs["class"] ? `${domAttrs["class"]} ` : ""}docx-section-break`;
 		}
 		return [
@@ -604,8 +608,8 @@ const ParagraphExtension = createNodeExtension({
 				styleId: null,
 				_tableOfContentsLevel: null
 			}),
-			insertSectionBreak: (breakType) => setParagraphAttr("sectionBreakType", breakType),
-			removeSectionBreak: () => setParagraphAttr("sectionBreakType", null),
+			insertSectionBreak: (breakType) => setSectionBreakType(breakType),
+			removeSectionBreak: () => removeSectionBreakAtSelection,
 			generateTOC: ({ title }) => (state, dispatch) => {
 				const builtInStyles = getDocumentBuiltInStyles(state);
 				const headings = collectHeadings(state.doc, builtInStyles);

package/dist/prosemirror/extensions/features/BaseKeymapExtension.js

@@ -1,5 +1,6 @@
 import { mergeTextFormatting } from "../../../utils/textFormattingMerge.js";
 import { expectCharacterStyleMarkAttrs, expectRunFormattingOverrideMarkAttrs } from "../../attrs/index.js";
+import { keepSectionBreaksOnSurvivingMarks } from "../../commands/sectionBreak.js";
 import { getDocumentStyleResolver } from "../../plugins/documentStyles.js";
 import { RUN_FORMATTING_MARK_NAMES } from "../../runFormattingMarkNames.js";
 import { authoredRunFormattingFromAttrs } from "../../runFormattingProvenance.js";
@@ -185,8 +186,8 @@ const BaseKeymapExtension = createExtension({
 		return { keyboardShortcuts: {
 			...baseKeymap,
 			Enter: splitBlockClearBorders,
-			Backspace: chainCommands(deleteSelection, clearIndentOnBackspace, joinBackward),
-			Delete: chainCommands(deleteSelection, joinForward),
+			Backspace: keepSectionBreaksOnSurvivingMarks(chainCommands(deleteSelection, clearIndentOnBackspace, joinBackward)),
+			Delete: keepSectionBreaksOnSurvivingMarks(chainCommands(deleteSelection, joinForward)),
 			"Mod-a": selectAll,
 			Escape: selectParentNode
 		} };

package/dist/prosemirror/extensions/features/ListExtension.js

@@ -1,8 +1,11 @@
-import { isNumberingReference } from "../../../docx/numberingReference.js";
+import { isBulletLevel } from "../../../docx/numberingParser.js";
+import { NO_PARAGRAPH_NUMBERING, paragraphNumberingLevel, paragraphNumberingReference, paragraphNumberingReferenceId } from "../../../docx/numberingReference.js";
 import { expectParagraphAttrs } from "../../attrs/index.js";
 import { PPR_CHANGE_SCOPED_ATTR_KEYS, hasSerializableParagraphPropertyChange } from "../../commands/propertyChangeScope.js";
 import { CLEARED_LIST_RENDERING_ATTRS } from "../../listMarker.js";
 import { LIST_RENDERING_ATTR_KEYS } from "../../listRenderingAttrs.js";
+import { resolveListState } from "../../listState.js";
+import { paragraphNumberingAttr } from "../../numberingAttr.js";
 import { getDocumentNumbering } from "../../plugins/documentNumbering.js";
 import { SUGGESTION_META, makeRevisionInfo } from "../../plugins/suggestionMode.js";
 import { listLevelAttrPatch } from "../../styles/resolvedStyleAttrs.js";
@@ -49,11 +52,7 @@ function getPreviousListFormatting(attrs) {
 	return previousFormatting;
 }
 function clearListAttrs(attrs) {
-	const styleNumPr = attrs.numPrFromStyle;
-	const numPr = isNumberingReference(styleNumPr?.numId) ? {
-		numId: 0,
-		ilvl: attrs.numPr?.ilvl ?? styleNumPr?.ilvl ?? 0
-	} : null;
+	const numPr = paragraphNumberingReferenceId(attrs.numPrFromStyle) === void 0 ? null : paragraphNumberingAttr(NO_PARAGRAPH_NUMBERING);
 	return {
 		...attrs,
 		numPr,
@@ -61,14 +60,31 @@ function clearListAttrs(attrs) {
 	};
 }
 function hasActiveListNumbering(attrs) {
-	return isNumberingReference(attrs.numPr?.numId);
+	return attrs.numPr?.kind === "reference";
 }
-function toggleList(numId) {
+/**
+* The numbering instances Folio mints for its own toolbar lists. They are the
+* ids the autoformat rules and the list buttons create; a document Folio did
+* not create numbers its lists however its author did, which is why nothing
+* reads a list's kind off its id any more.
+*/
+const FOLIO_BULLET_NUM_ID = 1;
+const FOLIO_NUMBERED_NUM_ID = 2;
+const targetNumIdForIntent = (numbering, preferredNumId, ilvl, intent) => {
+	const matchesIntent = (numId) => {
+		const level = numbering?.getLevel(numId, ilvl) ?? null;
+		return level !== null && (isBulletLevel(level) ? "bullet" : "numbered") === intent;
+	};
+	if (matchesIntent(preferredNumId)) return preferredNumId;
+	return numbering?.definitions.nums.find(({ numId }) => matchesIntent(numId))?.numId ?? preferredNumId;
+};
+function toggleList(numId, intent) {
 	return (state, dispatch) => {
 		const { $from, $to } = state.selection;
 		const paragraph = $from.parent;
 		if (paragraph.type.name !== "paragraph") return false;
-		const isInSameList = paragraph.attrs["numPr"]?.numId === numId;
+		const numbering = getDocumentNumbering(state);
+		const isInSameList = resolveListState(numbering, expectParagraphAttrs(paragraph).numPr).type === intent;
 		const rev = makeRevisionInfo(state);
 		if (rev) {
 			let hasPendingChange = false;
@@ -89,16 +105,19 @@ function toggleList(numId) {
 				let nextAttrs;
 				if (isInSameList) nextAttrs = clearListAttrs(expectParagraphAttrs(node));
 				else {
-					const isBullet = numId === 1;
+					const ilvl = paragraphNumberingLevel(expectParagraphAttrs(node).numPr) ?? 0;
+					const targetNumId = targetNumIdForIntent(numbering, numId, ilvl, intent);
+					const definition = numbering?.getLevel(targetNumId, ilvl) ?? null;
+					const isBullet = definition === null ? intent === "bullet" : isBulletLevel(definition);
 					nextAttrs = {
 						...node.attrs,
 						...CLEARED_LIST_RENDERING_ATTRS,
-						numPr: {
-							numId,
-							ilvl: node.attrs["numPr"]?.ilvl || 0
-						},
+						numPr: paragraphNumberingAttr(paragraphNumberingReference({
+							numId: targetNumId,
+							ilvl
+						})),
 						listIsBullet: isBullet,
-						listNumFmt: isBullet ? null : "decimal"
+						listNumFmt: isBullet ? null : definition?.numFmt ?? "decimal"
 					};
 				}
 				if (rev) {
@@ -113,8 +132,8 @@ function toggleList(numId) {
 		return true;
 	};
 }
-const toggleBulletList = (state, dispatch) => toggleList(1)(state, dispatch);
-const toggleNumberedList = (state, dispatch) => toggleList(2)(state, dispatch);
+const toggleBulletList = (state, dispatch) => toggleList(FOLIO_BULLET_NUM_ID, "bullet")(state, dispatch);
+const toggleNumberedList = (state, dispatch) => toggleList(FOLIO_NUMBERED_NUM_ID, "numbered")(state, dispatch);
 const attrsForListLevel = (state, attrs, level) => {
 	if (!hasActiveListNumbering(attrs)) panic("Cannot change the level of a list without a numbering id");
 	return {
@@ -131,7 +150,7 @@ const increaseListLevel = (state, dispatch) => {
 	if (paragraph.type.name !== "paragraph") return false;
 	const attrs = expectParagraphAttrs(paragraph);
 	if (!hasActiveListNumbering(attrs)) return false;
-	const currentLevel = attrs.numPr.ilvl || 0;
+	const currentLevel = attrs.numPr.ilvl ?? 0;
 	if (currentLevel >= 8) return false;
 	if (!dispatch) return true;
 	const paragraphPos = $from.before($from.depth);
@@ -144,7 +163,7 @@ const decreaseListLevel = (state, dispatch) => {
 	if (paragraph.type.name !== "paragraph") return false;
 	const attrs = expectParagraphAttrs(paragraph);
 	if (!hasActiveListNumbering(attrs)) return false;
-	const currentLevel = attrs.numPr.ilvl || 0;
+	const currentLevel = attrs.numPr.ilvl ?? 0;
 	if (!dispatch) return true;
 	const paragraphPos = $from.before($from.depth);
 	if (currentLevel <= 0) dispatch(state.tr.setNodeMarkup(paragraphPos, void 0, {
@@ -184,7 +203,7 @@ function getListInfo(state) {
 	if (!hasActiveListNumbering(attrs)) return null;
 	return {
 		numId: attrs.numPr.numId,
-		ilvl: attrs.numPr.ilvl || 0
+		ilvl: attrs.numPr.ilvl ?? 0
 	};
 }
 function exitListOnEmptyEnter() {
@@ -240,7 +259,7 @@ function increaseListIndent() {
 			if (node.type.name === "paragraph") {
 				const attrs = expectParagraphAttrs(node);
 				if (!hasActiveListNumbering(attrs)) return;
-				if ((attrs.numPr?.ilvl ?? 0) < 8) positions.push({
+				if ((attrs.numPr.ilvl ?? 0) < 8) positions.push({
 					pos,
 					attrs
 				});
@@ -249,7 +268,7 @@ function increaseListIndent() {
 		if (positions.length === 0) return false;
 		if (dispatch) {
 			let tr = state.tr;
-			for (const { pos, attrs } of positions) tr = tr.setNodeMarkup(pos, void 0, attrsForListLevel(state, attrs, (attrs.numPr?.ilvl ?? 0) + 1));
+			for (const { pos, attrs } of positions) tr = tr.setNodeMarkup(pos, void 0, attrsForListLevel(state, attrs, (attrs.numPr.ilvl ?? 0) + 1));
 			dispatch(tr);
 		}
 		return true;
@@ -272,7 +291,7 @@ function decreaseListIndent() {
 		if (dispatch) {
 			let tr = state.tr;
 			for (const { pos, attrs } of positions) {
-				const currentLevel = attrs.numPr?.ilvl ?? 0;
+				const currentLevel = attrs.numPr.ilvl ?? 0;
 				if (currentLevel <= 0) tr = tr.setNodeMarkup(pos, void 0, {
 					...clearListAttrs(attrs),
 					indentLeft: null,
@@ -318,7 +337,7 @@ const listAutoformat = (marker, toggleCommand) => new InputRule(marker, (state,
 	const { $from } = state.selection;
 	if ($from.parent.type.name !== "paragraph") return null;
 	if (start !== $from.start()) return null;
-	if (expectParagraphAttrs($from.parent).numPr?.numId) return null;
+	if (paragraphNumberingReferenceId(expectParagraphAttrs($from.parent).numPr) !== void 0) return null;
 	if (makeRevisionInfo(state)) return null;
 	const toggled = captureTransaction(toggleCommand, state);
 	if (!toggled) return null;

package/dist/prosemirror/extensions/features/ParagraphChangeTrackerExtension.js

@@ -1,4 +1,5 @@
 import { canonicalJson } from "../../../utils/canonicalJson.js";
+import { sectionPropertiesOf } from "../../sectionCarrier.js";
 import { createExtension } from "../create.js";
 import { AddMarkStep, AddNodeMarkStep, AttrStep, RemoveMarkStep, RemoveNodeMarkStep } from "prosemirror-transform";
 import { Plugin, PluginKey } from "prosemirror-state";
@@ -22,13 +23,13 @@ function countDocumentStructure(doc) {
 		parent.forEach((node, _offset, index) => {
 			if (node.type.name === "paragraph") {
 				paragraphs++;
-				if (node.attrs["_sectionProperties"] != null || node.attrs["sectionBreakType"] != null) {
+				const sectionProperties = sectionPropertiesOf(node);
+				if (sectionProperties !== null) {
 					sectionEndpoints++;
 					endpointRecords.push({
 						path: parentPath.length === 0 ? `${index}` : `${parentPath}.${index}`,
 						paraId: node.attrs["paraId"] ?? null,
-						sectionBreakType: node.attrs["sectionBreakType"] ?? null,
-						sectionProperties: node.attrs["_sectionProperties"] ?? null
+						sectionProperties
 					});
 				}
 				return;

package/dist/prosemirror/extensions/features/PasteCleanupExtension.d.ts

@@ -11,9 +11,9 @@ import { Extension } from "../types.js";
  *    default clipboard parser; ProseMirror chains every plugin's
  *    `transformPastedHTML`, so this cooperates with the inliner rather than
  *    replacing it, and `<style>` blocks are left intact for it to resolve.
- * 2. `transformPasted` — drops unpaired bookmark boundaries, then points
- *    pasted headings at the open document's own heading style (see
- *    {@link retargetPastedHeadingStyles}).
+ * 2. `transformPasted` — drops unpaired bookmark and move-range boundaries,
+ *    then points pasted headings at the open document's own heading style
+ *    (see {@link retargetPastedHeadingStyles}).
  * 3. `Mod-Alt-v` — "paste without formatting", inserting clipboard text with
  *    the source formatting stripped (see {@link pasteWithoutFormatting}).
  */

package/dist/prosemirror/extensions/features/PasteCleanupExtension.js

@@ -1,7 +1,7 @@
 import { pasteWithoutFormatting } from "../../commands/pastePlainText.js";
 import { createExtension } from "../create.js";
 import { Priority } from "../types.js";
-import { cleanPastedHtml, removeUnpairedBookmarkBoundaries } from "./pasteCleanup.js";
+import { cleanPastedHtml, removeUnpairedBookmarkBoundaries, removeUnpairedMoveRangeBoundaries } from "./pasteCleanup.js";
 import { retargetPastedHeadingStyles } from "./pastedHeadingStyles.js";
 import { Plugin } from "prosemirror-state";
 //#region src/prosemirror/extensions/features/PasteCleanupExtension.ts
@@ -16,9 +16,9 @@ import { Plugin } from "prosemirror-state";
 *    default clipboard parser; ProseMirror chains every plugin's
 *    `transformPastedHTML`, so this cooperates with the inliner rather than
 *    replacing it, and `<style>` blocks are left intact for it to resolve.
-* 2. `transformPasted` — drops unpaired bookmark boundaries, then points
-*    pasted headings at the open document's own heading style (see
-*    {@link retargetPastedHeadingStyles}).
+* 2. `transformPasted` — drops unpaired bookmark and move-range boundaries,
+*    then points pasted headings at the open document's own heading style
+*    (see {@link retargetPastedHeadingStyles}).
 * 3. `Mod-Alt-v` — "paste without formatting", inserting clipboard text with
 *    the source formatting stripped (see {@link pasteWithoutFormatting}).
 */
@@ -32,7 +32,7 @@ const PasteCleanupExtension = createExtension({
 					const internalClipboardToken = options.getInternalClipboardToken?.();
 					return cleanPastedHtml(html, { ...internalClipboardToken ? { internalClipboardToken } : {} });
 				},
-				transformPasted: (slice, view) => retargetPastedHeadingStyles(removeUnpairedBookmarkBoundaries(slice), view)
+				transformPasted: (slice, view) => retargetPastedHeadingStyles(removeUnpairedMoveRangeBoundaries(removeUnpairedBookmarkBoundaries(slice)), view)
 			} })],
 			keyboardShortcuts: { "Mod-Alt-v": pasteWithoutFormatting }
 		};

package/dist/prosemirror/extensions/features/pasteCleanup.d.ts

@@ -14,5 +14,7 @@ type CleanPastedHtmlOptions = {
 declare function cleanPastedHtml(html: string, options?: CleanPastedHtmlOptions): string;
 /** Remove incomplete or duplicate bookmark pairs at copied slice edges. */
 declare function removeUnpairedBookmarkBoundaries(slice: Slice): Slice;
+/** Remove incomplete, duplicate, or reversed tracked-move pairs at copied slice edges. */
+declare function removeUnpairedMoveRangeBoundaries(slice: Slice): Slice;
 //#endregion
-export { cleanPastedHtml, removeUnpairedBookmarkBoundaries };
+export { cleanPastedHtml, removeUnpairedBookmarkBoundaries, removeUnpairedMoveRangeBoundaries };