@stll/folio-core 0.62.0 → 0.63.1

package/dist/prosemirror/copyOriginDom.d.ts

@@ -0,0 +1,8 @@
+import { CopyOriginAncestorList } from "@stll/docx-core/ops";
+//#region src/prosemirror/copyOriginDom.d.ts
+export declare const INTERNAL_CLIPBOARD_TOKEN_ATTRIBUTE = "data-docx-internal-clipboard";
+export declare const COPY_ORIGIN_ANCESTORS_ATTRIBUTE = "data-docx-copy-origin-ancestors";
+export declare const isInternalClipboardDom: (dom: HTMLElement, expectedToken: string | undefined) => boolean;
+export declare const copyOriginAncestorsFromInternalDom: (dom: HTMLElement, expectedToken: string | undefined) => CopyOriginAncestorList | undefined | false;
+export declare const copyOriginDomAttribute: (value: CopyOriginAncestorList | undefined, internalClipboardToken: string | undefined) => Record<string, string>;
+//#endregion

package/dist/prosemirror/copyOriginDom.js

@@ -0,0 +1,21 @@
+import "../reviewHistoryLimits.js";
+import { isCopyOriginAncestors } from "@stll/docx-core/ops";
+//#region src/prosemirror/copyOriginDom.ts
+const INTERNAL_CLIPBOARD_TOKEN_ATTRIBUTE = "data-docx-internal-clipboard";
+const COPY_ORIGIN_ANCESTORS_ATTRIBUTE = "data-docx-copy-origin-ancestors";
+const isInternalClipboardDom = (dom, expectedToken) => expectedToken !== void 0 && dom.getAttribute("data-docx-internal-clipboard") === expectedToken;
+const copyOriginAncestorsFromInternalDom = (dom, expectedToken) => {
+	if (!isInternalClipboardDom(dom, expectedToken)) return void 0;
+	const encoded = dom.getAttribute(COPY_ORIGIN_ANCESTORS_ATTRIBUTE);
+	if (encoded === null) return void 0;
+	if (encoded.length > 32768) return false;
+	try {
+		const parsed = JSON.parse(encoded);
+		return isCopyOriginAncestors(parsed) ? parsed : false;
+	} catch {
+		return false;
+	}
+};
+const copyOriginDomAttribute = (value, internalClipboardToken) => value === void 0 || internalClipboardToken === void 0 ? {} : { [COPY_ORIGIN_ANCESTORS_ATTRIBUTE]: JSON.stringify(value) };
+//#endregion
+export { COPY_ORIGIN_ANCESTORS_ATTRIBUTE, INTERNAL_CLIPBOARD_TOKEN_ATTRIBUTE, copyOriginAncestorsFromInternalDom, copyOriginDomAttribute, isInternalClipboardDom };

package/dist/prosemirror/copyOriginResolution.d.ts

@@ -0,0 +1,15 @@
+import { RevisionSelection } from "./keptRangeBoundaries.js";
+import { Node } from "prosemirror-model";
+//#region src/prosemirror/copyOriginResolution.d.ts
+/** Resolve copied-boundary ownership using the same nearest-first ordinals as DOCX ops. */
+export declare const copyOriginBoundaryAfterResolution: (node: Node, selection: RevisionSelection) => Node | null;
+export declare const copyOriginBoundaryAfterRemovingAddedAncestors: (node: Node) => Node | null;
+type CopyOriginBoundaryAttrsAfterResolutionOptions = {
+  source: Node;
+  current: Node;
+  baseAttrs: Node["attrs"];
+  selection: RevisionSelection;
+};
+export declare const copyOriginBoundaryAttrsAfterResolution: ({ source, current, baseAttrs, selection }: CopyOriginBoundaryAttrsAfterResolutionOptions) => Node["attrs"] | null;
+//#endregion
+export {};

package/dist/prosemirror/copyOriginResolution.js

@@ -0,0 +1,202 @@
+import { expectBookmarkBoundaryAttrs } from "./bookmarkBoundaryAttrs.js";
+import { expectMoveRangeBoundaryAttrs } from "./moveRangeBoundaryAttrs.js";
+import { expectRangeAnchorAttrs } from "./rangeAnchorAttrs.js";
+import { trackedRevisionPathOf } from "./trackedRevisionPath.js";
+import { panic } from "better-result";
+import { acceptCopyOriginAncestors, rejectCopyOriginAncestors } from "@stll/docx-core/ops";
+//#region src/prosemirror/copyOriginResolution.ts
+const isTrackedChangeMark = (mark) => mark.type.name === "insertion" || mark.type.name === "deletion";
+const isAddedLayer = (layer) => layer.type === "insertion" || layer.type === "moveTo";
+const sameRevisionLayer = (left, right) => left.type === right.type && left.revisionId === right.revisionId;
+const sameOrigins = (left, right) => left === right || left !== void 0 && right !== void 0 && left.length === right.length && left.every((ordinal, index) => ordinal === right[index]);
+const trackedRevisionPathForBoundary = (node) => {
+	const paths = node.marks.filter(isTrackedChangeMark).map(trackedRevisionPathOf);
+	const path = paths.toSorted((left, right) => right.length - left.length).at(0);
+	if (path === void 0) return [];
+	if (paths.some((candidate) => candidate.length > path.length || candidate.some((layer, index) => path[index] === void 0 || !sameRevisionLayer(layer, path[index])))) return panic("A copied boundary carries conflicting tracked revision paths.");
+	return path;
+};
+const copyOriginBoundaryOf = (node) => {
+	if (node.type.name === "bookmarkBoundary" || node.type.name === "blockBookmarkBoundary") return {
+		kind: "bookmark",
+		origins: expectBookmarkBoundaryAttrs(node).copyOriginAncestors
+	};
+	if (node.type.name === "moveRangeBoundary" || node.type.name === "blockMoveRangeBoundary") return {
+		kind: "move",
+		origins: expectMoveRangeBoundaryAttrs(node).copyOriginAncestors
+	};
+};
+const withCopyOriginAncestors = ({ node, boundary, origins }) => {
+	if (boundary.kind === "bookmark") return node.type.create({
+		...node.attrs,
+		copyOriginAncestors: origins ?? null
+	}, node.content, node.marks);
+	const { copyOriginAncestors: _previousOrigins, ...withoutOrigins } = expectMoveRangeBoundaryAttrs(node);
+	return node.type.create({
+		...node.attrs,
+		marker: origins === void 0 ? withoutOrigins : {
+			...withoutOrigins,
+			copyOriginAncestors: origins
+		}
+	}, node.content, node.marks);
+};
+const withRangeAnchorCopyOrigins = ({ node, startOrigins, endOrigins }) => {
+	const { start, end } = expectRangeAnchorAttrs(node);
+	if (start.type === "commentRangeStart" || end.type === "commentRangeEnd") return node;
+	return node.type.create({
+		...node.attrs,
+		start: markerWithCopyOrigin(start, startOrigins),
+		end: markerWithCopyOrigin(end, endOrigins)
+	}, node.content, node.marks);
+};
+const markerWithCopyOrigin = (marker, origins) => {
+	const { copyOriginAncestors: _previousOrigins, ...withoutOrigins } = marker;
+	return origins === void 0 ? withoutOrigins : {
+		...withoutOrigins,
+		copyOriginAncestors: origins
+	};
+};
+const moveRangeNodeFor = (node, marker) => {
+	const type = node.type.schema.nodes["moveRangeBoundary"];
+	if (type === void 0) return panic("A move range boundary node is missing.");
+	return type.create({ marker }, null, node.marks);
+};
+const copyOriginAfterResolution = ({ origins, path, selection }) => {
+	if (origins === void 0) return { type: "retain" };
+	const addedLayers = path.filter(isAddedLayer);
+	if (addedLayers.length === 0 || origins.some((ordinal) => ordinal >= addedLayers.length)) return panic("A copied boundary has no matching added-revision ancestry.");
+	if (selection.mode === "accept") {
+		let copyOriginAncestors = origins;
+		for (let index = path.length - 1; index >= 0; index -= 1) {
+			const layer = path[index];
+			if (layer === void 0 || !isAddedLayer(layer) || !selection.resolves(layer.revisionId)) continue;
+			const acceptedOrdinal = path.slice(index + 1).filter((descendant) => isAddedLayer(descendant) && !selection.resolves(descendant.revisionId)).length;
+			copyOriginAncestors = acceptCopyOriginAncestors(copyOriginAncestors, acceptedOrdinal);
+		}
+		if (sameOrigins(copyOriginAncestors, origins)) return {
+			type: "retain",
+			copyOriginAncestors: origins
+		};
+		return copyOriginAncestors === void 0 ? { type: "retain" } : {
+			type: "retain",
+			copyOriginAncestors
+		};
+	}
+	const selectedOwnerIndex = path.findIndex((layer) => isAddedLayer(layer) && selection.resolves(layer.revisionId));
+	if (selectedOwnerIndex < 0) return {
+		type: "retain",
+		copyOriginAncestors: origins
+	};
+	const removedAddedAncestors = path.slice(selectedOwnerIndex).filter(isAddedLayer).length;
+	return rejectCopyOriginAncestors(origins, removedAddedAncestors);
+};
+/** Resolve copied-boundary ownership using the same nearest-first ordinals as DOCX ops. */
+const copyOriginBoundaryAfterResolution = (node, selection) => {
+	if (node.type.name === "rangeAnchor") {
+		const { start, end } = expectRangeAnchorAttrs(node);
+		if (start.type === "commentRangeStart" || end.type === "commentRangeEnd") return node;
+		const path = trackedRevisionPathForBoundary(node);
+		const startResult = copyOriginAfterResolution({
+			origins: start.copyOriginAncestors,
+			path,
+			selection
+		});
+		const endResult = copyOriginAfterResolution({
+			origins: end.copyOriginAncestors,
+			path,
+			selection
+		});
+		if (startResult.type === "drop") {
+			if (endResult.type === "drop") return null;
+			return moveRangeNodeFor(node, markerWithCopyOrigin(end, endResult.copyOriginAncestors));
+		}
+		if (endResult.type === "drop") return moveRangeNodeFor(node, markerWithCopyOrigin(start, startResult.copyOriginAncestors));
+		if (sameOrigins(start.copyOriginAncestors, startResult.copyOriginAncestors) && sameOrigins(end.copyOriginAncestors, endResult.copyOriginAncestors)) return node;
+		return withRangeAnchorCopyOrigins({
+			node,
+			startOrigins: startResult.copyOriginAncestors,
+			endOrigins: endResult.copyOriginAncestors
+		});
+	}
+	const boundary = copyOriginBoundaryOf(node);
+	if (boundary === void 0 || boundary.origins === void 0) return node;
+	const path = trackedRevisionPathForBoundary(node);
+	const result = copyOriginAfterResolution({
+		origins: boundary.origins,
+		path,
+		selection
+	});
+	if (result.type === "retain" && sameOrigins(result.copyOriginAncestors, boundary.origins)) return node;
+	return result.type === "drop" ? null : withCopyOriginAncestors({
+		node,
+		boundary,
+		origins: result.copyOriginAncestors
+	});
+};
+const copyOriginBoundaryAfterRemovingAddedAncestors = (node) => {
+	if (node.type.name === "rangeAnchor") {
+		const { start, end } = expectRangeAnchorAttrs(node);
+		if (start.type === "commentRangeStart" || end.type === "commentRangeEnd") return node;
+		const addedAncestors = trackedRevisionPathForBoundary(node).filter(isAddedLayer).length;
+		const remove = (origins) => {
+			if (origins?.some((ordinal) => ordinal >= addedAncestors)) return panic("A copied boundary has no matching removed ancestry.");
+			return rejectCopyOriginAncestors(origins, addedAncestors);
+		};
+		const startResult = remove(start.copyOriginAncestors);
+		const endResult = remove(end.copyOriginAncestors);
+		if (startResult.type === "drop") {
+			if (endResult.type === "drop") return null;
+			return moveRangeNodeFor(node, markerWithCopyOrigin(end, endResult.copyOriginAncestors));
+		}
+		if (endResult.type === "drop") return moveRangeNodeFor(node, markerWithCopyOrigin(start, startResult.copyOriginAncestors));
+		if (sameOrigins(start.copyOriginAncestors, startResult.copyOriginAncestors) && sameOrigins(end.copyOriginAncestors, endResult.copyOriginAncestors)) return node;
+		return withRangeAnchorCopyOrigins({
+			node,
+			startOrigins: startResult.copyOriginAncestors,
+			endOrigins: endResult.copyOriginAncestors
+		});
+	}
+	const boundary = copyOriginBoundaryOf(node);
+	if (boundary === void 0 || boundary.origins === void 0) return node;
+	const removedAddedAncestors = trackedRevisionPathForBoundary(node).filter(isAddedLayer).length;
+	if (boundary.origins.some((ordinal) => ordinal >= removedAddedAncestors)) return panic("A copied boundary has no matching removed ancestry.");
+	const result = rejectCopyOriginAncestors(boundary.origins, removedAddedAncestors);
+	if (result.type === "retain" && sameOrigins(result.copyOriginAncestors, boundary.origins)) return node;
+	return result.type === "drop" ? null : withCopyOriginAncestors({
+		node,
+		boundary,
+		origins: result.copyOriginAncestors
+	});
+};
+const copyOriginBoundaryAttrsAfterResolution = ({ source, current, baseAttrs, selection }) => {
+	const resolved = copyOriginBoundaryAfterResolution(source, selection);
+	if (resolved === null) return null;
+	const boundary = copyOriginBoundaryOf(source);
+	if (boundary === void 0) {
+		if (source.type.name === "rangeAnchor" && resolved.type.name === "rangeAnchor" && resolved !== source) return {
+			...baseAttrs,
+			start: resolved.attrs["start"],
+			end: resolved.attrs["end"]
+		};
+		if (source.type.name === "rangeAnchor" && resolved.type.name !== "rangeAnchor") return panic("A resolved point range changed shape outside subtree removal.");
+		return baseAttrs;
+	}
+	if (boundary.origins === void 0) return baseAttrs;
+	if (boundary.kind === "bookmark") return {
+		...baseAttrs,
+		copyOriginAncestors: resolved.attrs["copyOriginAncestors"]
+	};
+	const baseNode = current.type.create(baseAttrs, current.content, current.marks);
+	const currentMarker = expectMoveRangeBoundaryAttrs(baseNode);
+	const resolvedMarker = expectMoveRangeBoundaryAttrs(resolved);
+	const { copyOriginAncestors: _currentOrigins, ...markerWithoutOrigins } = currentMarker;
+	return {
+		...baseAttrs,
+		marker: resolvedMarker.copyOriginAncestors === void 0 ? markerWithoutOrigins : {
+			...markerWithoutOrigins,
+			copyOriginAncestors: resolvedMarker.copyOriginAncestors
+		}
+	};
+};
+//#endregion
+export { copyOriginBoundaryAfterRemovingAddedAncestors, copyOriginBoundaryAfterResolution, copyOriginBoundaryAttrsAfterResolution };

package/dist/prosemirror/documentSchema.d.ts

@@ -1,8 +1,7 @@
 import { MarkType, Schema } from "prosemirror-model";
 //#region src/prosemirror/documentSchema.d.ts
 /** `type`'s counterpart in the schema of `state`. */
-declare const documentMarkType: (state: {
+export declare const documentMarkType: (state: {
   readonly schema: Schema;
 }, type: MarkType) => MarkType;
-//#endregion
-export { documentMarkType };
+//#endregion

package/dist/prosemirror/emptyFieldResultRuns.d.ts

@@ -1,7 +1,7 @@
 import { document_d_exports } from "../types/document.js";
 //#region src/prosemirror/emptyFieldResultRuns.d.ts
 /** The single field mark lists every revision held by its invisible result runs. */
-declare const emptyFieldRunPropertyChanges: (runs: readonly document_d_exports.Run[]) => document_d_exports.RunPropertyChange[];
+export declare const emptyFieldRunPropertyChanges: (runs: readonly document_d_exports.Run[]) => document_d_exports.RunPropertyChange[];
 type ResolveEmptyFieldResultRunsOptions = {
   runs: readonly document_d_exports.Run[];
   mode: "accept" | "reject";
@@ -13,6 +13,6 @@ type ResolvedEmptyFieldResultRuns = {
   visibleFormattingChanged: boolean;
 };
 /** Resolve each authored run separately; a field mark carries their combined revisions. */
-declare const resolveEmptyFieldResultRuns: ({ runs, mode, revisionIds }: ResolveEmptyFieldResultRunsOptions) => ResolvedEmptyFieldResultRuns | null;
+export declare const resolveEmptyFieldResultRuns: ({ runs, mode, revisionIds }: ResolveEmptyFieldResultRunsOptions) => ResolvedEmptyFieldResultRuns | null;
 //#endregion
-export { emptyFieldRunPropertyChanges, resolveEmptyFieldResultRuns };
+export {};

package/dist/prosemirror/emptyRangeAnchor.d.ts

@@ -9,7 +9,7 @@ type RangeStartType = Extract<ParagraphContent["type"], `${string}RangeStart`>;
  * listed, so a `…RangeStart` added to `ParagraphContent` fails this
  * `satisfies` until somebody has said what closes it.
  */
-declare const RANGE_END_FOR_START: {
+export declare const RANGE_END_FOR_START: {
   readonly commentRangeStart: "commentRangeEnd";
   readonly moveFromRangeStart: "moveFromRangeEnd";
   readonly moveToRangeStart: "moveToRangeEnd";
@@ -21,7 +21,7 @@ declare const RANGE_END_FOR_START: {
  * 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]: {
+export type RangeAnchorAttrs = { [Start in RangeStartType]: {
   start: Extract<ParagraphContent, {
     type: Start;
   }>;
@@ -30,8 +30,8 @@ type RangeAnchorAttrs = { [Start in RangeStartType]: {
   }>;
 }; }[RangeStartType];
 /** Whether this content is one of the six range markers, either half. */
-declare const isRangeMarker: (content: ParagraphContent) => boolean;
-type EmptyRangePlan = {
+export declare const isRangeMarker: (content: ParagraphContent) => boolean;
+export 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. */
@@ -48,6 +48,6 @@ type EmptyRangePlan = {
  * 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;
+export declare const planEmptyRanges: (content: readonly ParagraphContent[]) => EmptyRangePlan;
 //#endregion
-export { EmptyRangePlan, RANGE_END_FOR_START, RangeAnchorAttrs, isRangeMarker, planEmptyRanges };
+export {};

package/dist/prosemirror/executeEditorCommand.d.ts

@@ -2,10 +2,9 @@ import { Command } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
 //#region src/prosemirror/executeEditorCommand.d.ts
 /** The view's controller owns canonical command interpretation. */
-declare const registerEditorCommandOwner: (view: EditorView, execute: (command: Command) => boolean | undefined) => () => void;
+export declare const registerEditorCommandOwner: (view: EditorView, execute: (command: Command) => boolean | undefined) => () => void;
 /** Keep commands on their selected view; a handled refusal must not fall through. */
-declare const executeEditorCommand: (view: EditorView, command: Command) => boolean;
+export declare const executeEditorCommand: (view: EditorView, command: Command) => boolean;
 /** Legacy command chains stop at the first owner decision, including refusal. */
-declare const executeFirstEditorCommand: (view: EditorView, commands: readonly Command[]) => boolean;
-//#endregion
-export { executeEditorCommand, executeFirstEditorCommand, registerEditorCommandOwner };
+export declare const executeFirstEditorCommand: (view: EditorView, commands: readonly Command[]) => boolean;
+//#endregion

package/dist/prosemirror/extensions/ExtensionManager.d.ts

@@ -2,7 +2,7 @@ import { AnyExtension, CommandFactory, CommandMap, FolioCommandArguments, FolioC
 import { Schema } from "prosemirror-model";
 import { Plugin } from "prosemirror-state";
 //#region src/prosemirror/extensions/ExtensionManager.d.ts
-declare class ExtensionManager {
+export declare class ExtensionManager {
   private readonly extensions;
   private schema;
   private plugins;
@@ -41,5 +41,4 @@ declare class ExtensionManager {
    */
   destroy(): void;
 }
-//#endregion
-export { ExtensionManager };
+//#endregion

package/dist/prosemirror/extensions/StarterKit.d.ts

@@ -2,7 +2,7 @@ import { AnyExtension } from "./types.js";
 import { HistoryShortcutOwner } from "./core/HistoryExtension.js";
 import { SelectionChangeCallback } from "../plugins/selectionTracker.js";
 //#region src/prosemirror/extensions/StarterKit.d.ts
-type StarterKitOptions = {
+export type StarterKitOptions = {
   /** Extensions to disable by name */
   disable?: string[];
   /** History depth (default: 100) */
@@ -17,6 +17,5 @@ type StarterKitOptions = {
 /**
  * Create the full set of extensions for the DOCX editor
  */
-declare function createStarterKit(options?: StarterKitOptions): AnyExtension[];
-//#endregion
-export { StarterKitOptions, createStarterKit };
+export declare function createStarterKit(options?: StarterKitOptions): AnyExtension[];
+//#endregion

package/dist/prosemirror/extensions/StarterKit.js

@@ -21,8 +21,10 @@ import { SelectionTrackerExtension } from "./features/SelectionTrackerExtension.
 import { MARK_EXTENSIONS, MARK_NESTING_ORDER } from "./markRegistry.js";
 import { BlockBookmarkBoundaryExtension } from "./nodes/BlockBookmarkBoundaryExtension.js";
 import { BlockCustomXmlExtension } from "./nodes/BlockCustomXmlExtension.js";
+import { BlockMoveRangeBoundaryExtension } from "./nodes/BlockMoveRangeBoundaryExtension.js";
 import { BlockSdtExtension } from "./nodes/BlockSdtExtension.js";
 import { BookmarkBoundaryExtension } from "./nodes/BookmarkBoundaryExtension.js";
+import { CommentRangeBoundaryExtension } from "./nodes/CommentRangeBoundaryExtension.js";
 import { CommentReferenceExtension } from "./nodes/CommentReferenceExtension.js";
 import { FieldExtension, StructuredFieldExtension } from "./nodes/FieldExtension.js";
 import { HardBreakExtension } from "./nodes/HardBreakExtension.js";
@@ -69,8 +71,10 @@ function createStarterKit(options = {}) {
 	}));
 	for (const name of MARK_NESTING_ORDER) add(name, MARK_EXTENSIONS[name]());
 	add("bookmarkBoundary", BookmarkBoundaryExtension({ getInternalClipboardToken }));
-	add("blockBookmarkBoundary", BlockBookmarkBoundaryExtension());
+	add("blockBookmarkBoundary", BlockBookmarkBoundaryExtension({ getInternalClipboardToken }));
+	add("blockMoveRangeBoundary", BlockMoveRangeBoundaryExtension({ getInternalClipboardToken }));
 	add("commentReference", CommentReferenceExtension({ getInternalClipboardToken }));
+	add("commentRangeBoundary", CommentRangeBoundaryExtension({ getInternalClipboardToken }));
 	add("moveRangeBoundary", MoveRangeBoundaryExtension({ getInternalClipboardToken }));
 	add("rangeAnchor", RangeAnchorExtension({ getInternalClipboardToken }));
 	add("hardBreak", HardBreakExtension());

package/dist/prosemirror/extensions/core/DocExtension.d.ts

@@ -1,8 +1,4 @@
 import { NodeExtension } from "../types.js";
 //#region src/prosemirror/extensions/core/DocExtension.d.ts
-/**
- * Doc Extension — top-level document node
- */
-declare const DocExtension: (options?: Partial<Record<string, unknown>> | undefined) => NodeExtension;
-//#endregion
-export { DocExtension };
+export declare const DocExtension: (options?: Partial<Record<string, unknown>> | undefined) => NodeExtension;
+//#endregion

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

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

package/dist/prosemirror/extensions/core/HistoryExtension.d.ts

@@ -1,20 +1,17 @@
 import { Extension } from "../types.js";
 //#region src/prosemirror/extensions/core/HistoryExtension.d.ts
-/**
- * History Extension — undo/redo via prosemirror-history
- */
 /**
  * Who answers the undo and redo keys (Mod-z, Mod-y, Mod-Shift-z).
  *  - `"editor"`: the extension binds them. Default.
  *  - `"host"`: nothing binds them. The host keeps its own undo stack and runs
  *    the `undo` / `redo` commands itself, so one press never undoes twice.
  */
-type HistoryShortcutOwner = "editor" | "host";
+export type HistoryShortcutOwner = "editor" | "host";
 type HistoryOptions = {
   depth: number;
   newGroupDelay: number;
   shortcuts: HistoryShortcutOwner;
 };
-declare const HistoryExtension: (options?: Partial<HistoryOptions> | undefined) => Extension;
+export declare const HistoryExtension: (options?: Partial<HistoryOptions> | undefined) => Extension;
 //#endregion
-export { HistoryExtension, HistoryShortcutOwner };
+export {};

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

@@ -62,10 +62,11 @@ const inputBoundaryPlugin = (newGroupDelay) => {
 					startInput("typing");
 					return;
 				}
-				if (event.inputType.startsWith("delete")) if (event.inputType.endsWith("Backward")) startInput("deleteBackward");
-				else if (event.inputType.endsWith("Forward")) startInput("deleteForward");
-				else startInput("deletion");
-				else if (event.inputType === "insertParagraph" || event.inputType === "insertLineBreak") startInput("structure");
+				if (event.inputType.startsWith("delete")) {
+					if (event.inputType.endsWith("Backward")) startInput("deleteBackward");
+					else if (event.inputType.endsWith("Forward")) startInput("deleteForward");
+					else startInput("deletion");
+				} else if (event.inputType === "insertParagraph" || event.inputType === "insertLineBreak") startInput("structure");
 			};
 			const paste = () => startInput("paste");
 			const drop = () => startInput("drop");

package/dist/prosemirror/extensions/core/ParagraphExtension.d.ts

@@ -3,7 +3,7 @@ import { NumberingMap } from "../../../docx/numberingParser.js";
 import { NodeExtension } from "../types.js";
 import { EditorState } from "prosemirror-state";
 //#region src/prosemirror/extensions/core/ParagraphExtension.d.ts
-type ResolvedStyleAttrs = {
+export type ResolvedStyleAttrs = {
   paragraphFormatting?: document_d_exports.ParagraphFormatting;
   runFormatting?: document_d_exports.TextFormatting;
   /** Canonical OOXML style name, used when the document-local style id is localized. */
@@ -17,10 +17,10 @@ type ResolvedStyleAttrs = {
    */
   numbering?: NumberingMap | null;
 };
-declare function getParagraphAlignment(state: EditorState): document_d_exports.ParagraphAlignment | null;
-declare function getParagraphTabs(state: EditorState): document_d_exports.TabStop[] | null;
-declare function getStyleId(state: EditorState): string | null;
-declare function getParagraphBidi(state: EditorState): boolean;
+export declare function getParagraphAlignment(state: EditorState): document_d_exports.ParagraphAlignment | null;
+export declare function getParagraphTabs(state: EditorState): document_d_exports.TabStop[] | null;
+export declare function getStyleId(state: EditorState): string | null;
+export declare function getParagraphBidi(state: EditorState): boolean;
 /**
  * What a generated table of contents needs from its caller.
  *
@@ -30,10 +30,9 @@ declare function getParagraphBidi(state: EditorState): boolean;
  * is wrong in every document that is not in English. The host passes the
  * string it already renders its own UI with.
  */
-type GenerateTableOfContentsOptions = {
+export type GenerateTableOfContentsOptions = {
   /** Heading text for the table, in the document's language. */
   title: string;
 };
-declare const ParagraphExtension: (options?: Partial<Record<string, unknown>> | undefined) => NodeExtension;
-//#endregion
-export { GenerateTableOfContentsOptions, ParagraphExtension, ResolvedStyleAttrs, getParagraphAlignment, getParagraphBidi, getParagraphTabs, getStyleId };
+export declare const ParagraphExtension: (options?: Partial<Record<string, unknown>> | undefined) => NodeExtension;
+//#endregion

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

@@ -9,7 +9,7 @@ import { tableOfContentsStyleLevel } from "../../../utils/tableOfContentsStyle.j
 import { expectParagraphAttrs } from "../../attrs/index.js";
 import { autospacingMatchesBase } from "../../autospacingBase.js";
 import { withCanonicalCommand, withCanonicalParagraphFormatting, withCanonicalStartParagraphFormatting } from "../../canonicalCommands.js";
-import { removeSectionBreakAtSelection, setSectionBreakType } from "../../commands/sectionBreak.js";
+import { removeSectionBreakAtSelection, sectionBreakSelectionIsTopLevel, setSectionBreakType } from "../../commands/sectionBreak.js";
 import { CLEARED_LIST_RENDERING_ATTRS } from "../../listMarker.js";
 import { effectiveParagraphNumberingReference, paragraphNumberingSourcesFromBoundary } from "../../numberingAttr.js";
 import { directParagraphAlignment } from "../../paragraphAlignment.js";
@@ -42,7 +42,7 @@ function paragraphAttrsToDOMStyle(attrs) {
 		numPrFromStyle: attrs.numPrFromStyle
 	}));
 	if (numbering !== void 0 && (rawIndentLeft === null || rawIndentLeft === void 0)) indentLeft = (numbering.ilvl + 1) * 720;
-	const style = paragraphToStyle({
+	const formatting = {
 		...attrs.alignment !== void 0 ? { alignment: attrs.alignment } : {},
 		...attrs.spaceBefore !== void 0 ? { spaceBefore: attrs.spaceBefore } : {},
 		...attrs.spaceAfter !== void 0 ? { spaceAfter: attrs.spaceAfter } : {},
@@ -56,7 +56,8 @@ function paragraphAttrsToDOMStyle(attrs) {
 		...attrs.shading !== void 0 ? { shading: attrs.shading } : {},
 		...autospacingMatchesBase(attrs._autospacingBase, "before", attrs.spaceBefore) ? { beforeAutospacing: true } : {},
 		...autospacingMatchesBase(attrs._autospacingBase, "after", attrs.spaceAfter) ? { afterAutospacing: true } : {}
-	});
+	};
+	const style = paragraphToStyle(formatting);
 	const customStyle = {};
 	if (style.marginTop) customStyle["--docx-space-before"] = style.marginTop;
 	if (style.marginBottom) customStyle["--docx-space-after"] = style.marginBottom;
@@ -180,10 +181,12 @@ function extractParagraphAttrsFromStyle(element) {
 	}
 	if (style.textIndent) {
 		const twips = cssLengthToTwips(style.textIndent);
-		if (twips !== void 0) if (twips < 0) {
-			attrs.indentFirstLine = Math.abs(twips);
-			attrs.hangingIndent = true;
-		} else attrs.indentFirstLine = twips;
+		if (twips !== void 0) {
+			if (twips < 0) {
+				attrs.indentFirstLine = Math.abs(twips);
+				attrs.hangingIndent = true;
+			} else attrs.indentFirstLine = twips;
+		}
 	}
 	if (style.lineHeight) {
 		const spacing = cssLineHeightToSpacing(style.lineHeight);
@@ -215,6 +218,8 @@ const paragraphNodeSpec = {
 		alignment: { default: null },
 		alignmentFromStyle: { default: void 0 },
 		kinsoku: { default: null },
+		autoSpaceDE: { default: null },
+		autoSpaceDN: { default: null },
 		overflowPunctuation: { default: null },
 		suppressAutoHyphens: { default: null },
 		spaceBefore: { default: null },
@@ -726,8 +731,11 @@ const ParagraphExtension = createNodeExtension({
 					numbering: getDocumentNumbering(state)
 				})(state, dispatch);
 			}, { styleId: null }),
-			insertSectionBreak: (breakType) => setSectionBreakType(breakType),
-			removeSectionBreak: () => removeSectionBreakAtSelection,
+			insertSectionBreak: (breakType) => withCanonicalCommand(setSectionBreakType(breakType), (state) => sectionBreakSelectionIsTopLevel(state) ? [{
+				type: "setSectionBreak",
+				breakType
+			}] : void 0),
+			removeSectionBreak: () => withCanonicalCommand(removeSectionBreakAtSelection, (state) => sectionBreakSelectionIsTopLevel(state) ? [{ type: "removeSectionBreak" }] : void 0),
 			generateTOC: ({ title }) => withCanonicalCommand((state, dispatch) => {
 				const builtInStyles = getDocumentBuiltInStyles(state);
 				const headings = collectHeadings(state.doc, builtInStyles);

package/dist/prosemirror/extensions/core/TextExtension.d.ts

@@ -1,8 +1,4 @@
 import { NodeExtension } from "../types.js";
 //#region src/prosemirror/extensions/core/TextExtension.d.ts
-/**
- * Text Extension — inline text node
- */
-declare const TextExtension: (options?: Partial<Record<string, unknown>> | undefined) => NodeExtension;
-//#endregion
-export { TextExtension };
+export declare const TextExtension: (options?: Partial<Record<string, unknown>> | undefined) => NodeExtension;
+//#endregion

package/dist/prosemirror/extensions/create.d.ts

@@ -3,14 +3,13 @@ import { Extension, ExtensionDefinition, MarkExtension, MarkExtensionDefinition,
 /**
  * Create a generic extension (plugins, commands, keymaps — no schema contribution)
  */
-declare function createExtension<TOptions extends Record<string, unknown> = Record<string, unknown>>(def: ExtensionDefinition<TOptions>): (options?: Partial<TOptions>) => Extension;
+export declare function createExtension<TOptions extends Record<string, unknown> = Record<string, unknown>>(def: ExtensionDefinition<TOptions>): (options?: Partial<TOptions>) => Extension;
 /**
  * Create a node extension (contributes a NodeSpec to the schema)
  */
-declare function createNodeExtension<TOptions extends Record<string, unknown> = Record<string, unknown>>(def: NodeExtensionDefinition<TOptions>): (options?: Partial<TOptions>) => NodeExtension;
+export declare function createNodeExtension<TOptions extends Record<string, unknown> = Record<string, unknown>>(def: NodeExtensionDefinition<TOptions>): (options?: Partial<TOptions>) => NodeExtension;
 /**
  * Create a mark extension (contributes a MarkSpec to the schema)
  */
-declare function createMarkExtension<TOptions extends Record<string, unknown> = Record<string, unknown>>(def: MarkExtensionDefinition<TOptions>): (options?: Partial<TOptions>) => MarkExtension;
-//#endregion
-export { createExtension, createMarkExtension, createNodeExtension };
+export declare function createMarkExtension<TOptions extends Record<string, unknown> = Record<string, unknown>>(def: MarkExtensionDefinition<TOptions>): (options?: Partial<TOptions>) => MarkExtension;
+//#endregion

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

@@ -1,9 +1,9 @@
 import { Extension } from "../types.js";
-import { EditorState, Plugin } from "prosemirror-state";
+import { EditorState, Plugin, PluginKey } from "prosemirror-state";
 //#region src/prosemirror/extensions/features/AutoBidiDetectionExtension.d.ts
-declare const autoBidiDetectionKey: Readonly<{
+export declare const autoBidiDetectionKey: Readonly<{
   key: string;
-  createKey: () => import("prosemirror-state").PluginKey<unknown>;
+  createKey: () => PluginKey<unknown>;
   owns: (plugin: Plugin<unknown>) => boolean;
   get: (state: EditorState) => Plugin<unknown> | undefined;
   getState: (state: EditorState) => unknown;
@@ -22,7 +22,6 @@ declare const autoBidiDetectionKey: Readonly<{
  * otherwise edited. A manual toggle, or a paragraph whose `w:bidi` the source
  * document already carried, is unaffected — it always round-trips.
  */
-declare const ensureBaseDirectionInState: (state: EditorState) => EditorState;
-declare const AutoBidiDetectionExtension: (options?: Partial<{}> | undefined) => Extension;
-//#endregion
-export { AutoBidiDetectionExtension, autoBidiDetectionKey, ensureBaseDirectionInState };
+export declare const ensureBaseDirectionInState: (state: EditorState) => EditorState;
+export declare const AutoBidiDetectionExtension: (options?: Partial<{}> | undefined) => Extension;
+//#endregion

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

@@ -1,7 +1,6 @@
 import { Extension } from "../types.js";
 import { Command } from "prosemirror-state";
 //#region src/prosemirror/extensions/features/BaseKeymapExtension.d.ts
-declare const splitBlockClearBorders: Command;
-declare const BaseKeymapExtension: (options?: Partial<Record<string, unknown>> | undefined) => Extension;
-//#endregion
-export { BaseKeymapExtension, splitBlockClearBorders };
+export declare const splitBlockClearBorders: Command;
+export declare const BaseKeymapExtension: (options?: Partial<Record<string, unknown>> | undefined) => Extension;
+//#endregion