@stll/folio-core 0.54.1 → 0.54.2

package/dist/layout-bridge/convert/fixedTableColumnWidths.js

@@ -0,0 +1,23 @@
+import { expectTableCellAttrs, expectTableRowAttrs } from "../../prosemirror/attrs/index.js";
+//#region src/layout-bridge/convert/fixedTableColumnWidths.ts
+/** Resolve absolute cell preferences for an unbounded fixed-layout grid (§17.4.53). */
+const fixedTableColumnWidths = (table, grid) => {
+	const preferred = /* @__PURE__ */ new Map();
+	for (let rowIndex = 0; rowIndex < table.childCount; rowIndex++) {
+		const row = table.child(rowIndex);
+		const rowAttrs = expectTableRowAttrs(row);
+		if (rowAttrs.trIns || rowAttrs.trDel || rowAttrs.hidden) return grid;
+		let column = Math.max(0, rowAttrs._originalFormatting?.gridBefore ?? 0);
+		for (let cellIndex = 0; cellIndex < row.childCount; cellIndex++) {
+			const attrs = expectTableCellAttrs(row.child(cellIndex));
+			if (attrs._omittedGridSlot) continue;
+			const width = attrs._authoredWidth;
+			if (attrs.colspan !== 1 || attrs.rowspan !== 1 || attrs._preserveVMergeRestart || attrs._originalFormatting?.vMerge !== void 0 || !width || width.type !== "dxa" || !Number.isFinite(width.value) || width.value <= 0) return grid;
+			if (column < grid.length) preferred.set(column, Math.max(preferred.get(column) ?? 0, width.value));
+			column++;
+		}
+	}
+	return grid.map((width, column) => preferred.get(column) ?? width);
+};
+//#endregion
+export { fixedTableColumnWidths };

package/dist/layout-bridge/convert/tableConversion.js

@@ -3,6 +3,7 @@ import { DEFAULT_TEXTBOX_MARGINS } from "../../layout-engine/types.js";
 import { expectParagraphAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs } from "../../prosemirror/attrs/index.js";
 import { textBoxHostParagraph } from "../../prosemirror/textBoxHostParagraph.js";
 import { normalizeShapeTextAnchor } from "../../types/documentEnumValues.js";
+import { fixedTableColumnWidths } from "./fixedTableColumnWidths.js";
 import { convertBorderSpecToLayout } from "./flowBorders.js";
 import { nextBlockId, twipsToPixels } from "./flowConversionShared.js";
 import { countPageBreakRuns, hasSingleLeadingProjectedPageBreak } from "./pageBreakSplitting.js";
@@ -183,7 +184,9 @@ function convertTable(node, startPos, options) {
 		if (child.type.name === "tableRow") rows.push(convertTableRow(child, offset, options, rowContext));
 		offset += child.nodeSize;
 	});
-	let columnWidths = attrs.columnWidths?.map(twipsToPixels);
+	const columnWidthsTwips = attrs.columnWidths;
+	const hasTableWidth = (attrs.widthType === "dxa" || attrs.widthType === "pct") && (attrs.width ?? 0) > 0;
+	let columnWidths = (columnWidthsTwips && attrs._originalFormatting?.layout === "fixed" && !hasTableWidth ? fixedTableColumnWidths(node, columnWidthsTwips) : columnWidthsTwips)?.map(twipsToPixels);
 	const width = attrs.width;
 	const widthType = attrs.widthType;
 	if (!columnWidths && rows.length > 0) {

package/dist/layout-painter/index.js

@@ -1,4 +1,4 @@
-import { prefersReducedMotionBehavior } from "../paged-layout/scrollNavigation.js";
+import { scrollEditorElementIntoView } from "../paged-layout/editorScrollRoot.js";
 import { createDefaultRegistry } from "./registry/modules.js";
 import { createFeatureRegistry } from "./registry/registry.js";
 import { FRAGMENT_CLASS_NAMES, renderFragment } from "./renderFragment.js";
@@ -167,10 +167,7 @@ var LayoutPainter = class {
 	*/
 	scrollToPage(pageNumber) {
 		const state = this.pageStates.find((s) => s.pageNumber === pageNumber);
-		if (state?.element) state.element.scrollIntoView({
-			behavior: prefersReducedMotionBehavior(),
-			block: "start"
-		});
+		if (state?.element) scrollEditorElementIntoView(state.element, { block: "start" });
 	}
 };
 /**

package/dist/paged-layout/editorScrollRoot.d.ts

@@ -0,0 +1,15 @@
+//#region src/paged-layout/editorScrollRoot.d.ts
+declare const getEditorScrollRoot: (element: HTMLElement | null) => HTMLElement | null;
+/** Resolve the root even when a caller holds a painted descendant or viewport. */
+declare const scrollEditorTo: (element: HTMLElement | null, options: ScrollToOptions) => void;
+declare const scrollEditorBy: (element: HTMLElement | null, delta: number) => void;
+type ScrollEditorElementOptions = {
+  block?: "start" | "center" | "end" | "nearest";
+  behavior?: ScrollBehavior;
+  /** Space to leave between the target and the visible root edge. */
+  margin?: number;
+};
+/** Scroll only the marked root, including when the target is inside a scaled viewport. */
+declare const scrollEditorElementIntoView: (element: HTMLElement | null, { block, behavior, margin }?: ScrollEditorElementOptions) => void;
+//#endregion
+export { getEditorScrollRoot, scrollEditorBy, scrollEditorElementIntoView, scrollEditorTo };

package/dist/paged-layout/editorScrollRoot.js

@@ -0,0 +1,72 @@
+import { prefersReducedMotionBehavior } from "./scrollNavigation.js";
+//#region src/paged-layout/editorScrollRoot.ts
+/** The marked editor owns scrolling; navigation must never move host ancestors. */
+const EDITOR_SCROLL_ROOT_SELECTOR = "[data-folio-scroll]";
+const getEditorScrollRoot = (element) => element?.closest(EDITOR_SCROLL_ROOT_SELECTOR) ?? null;
+/** Resolve the root even when a caller holds a painted descendant or viewport. */
+const scrollEditorTo = (element, options) => {
+	getEditorScrollRoot(element)?.scrollTo(options);
+};
+const scrollEditorBy = (element, delta) => {
+	const root = getEditorScrollRoot(element);
+	if (root) scrollEditorTo(root, {
+		top: root.scrollTop + delta,
+		behavior: "instant"
+	});
+};
+const nearestScrollOffset = ({ targetStart, targetEnd, viewportStart, viewportEnd }) => {
+	const above = targetStart < viewportStart;
+	const below = targetEnd > viewportEnd;
+	if (above && below) return 0;
+	const targetSize = targetEnd - targetStart;
+	const viewportSize = viewportEnd - viewportStart;
+	if (above && targetSize <= viewportSize || below && targetSize > viewportSize) return targetStart - viewportStart;
+	if (below && targetSize <= viewportSize || above && targetSize > viewportSize) return targetEnd - viewportEnd;
+	return 0;
+};
+/** Scroll only the marked root, including when the target is inside a scaled viewport. */
+const scrollEditorElementIntoView = (element, { block = "center", behavior = prefersReducedMotionBehavior(), margin = 0 } = {}) => {
+	const root = getEditorScrollRoot(element);
+	if (!root || !element) return;
+	const targetRect = element.getBoundingClientRect();
+	const rootRect = root.getBoundingClientRect();
+	const visibleTop = rootRect.top + root.clientTop;
+	const targetTop = targetRect.top - visibleTop + root.scrollTop;
+	const targetBottom = targetRect.bottom - visibleTop + root.scrollTop;
+	let top;
+	switch (block) {
+		case "start":
+			top = targetTop - margin;
+			break;
+		case "center":
+			top = targetTop - (root.clientHeight - targetRect.height) / 2;
+			break;
+		case "end":
+			top = targetBottom - root.clientHeight + margin;
+			break;
+		case "nearest":
+			top = root.scrollTop + nearestScrollOffset({
+				targetStart: targetTop,
+				targetEnd: targetBottom,
+				viewportStart: root.scrollTop + margin,
+				viewportEnd: root.scrollTop + root.clientHeight - margin
+			});
+			break;
+		default: return block;
+	}
+	const visibleLeft = rootRect.left + root.clientLeft;
+	const left = root.scrollLeft + nearestScrollOffset({
+		targetStart: targetRect.left,
+		targetEnd: targetRect.right,
+		viewportStart: visibleLeft,
+		viewportEnd: visibleLeft + root.clientWidth
+	});
+	if (top === root.scrollTop && left === root.scrollLeft) return;
+	scrollEditorTo(root, {
+		top: Math.max(0, top),
+		left: Math.max(0, left),
+		behavior
+	});
+};
+//#endregion
+export { getEditorScrollRoot, scrollEditorBy, scrollEditorElementIntoView, scrollEditorTo };

package/dist/paged-layout/scrollToPmPosition.js

@@ -1,6 +1,7 @@
 import { findBodyPmAnchor, findBodyPmAnchors } from "../layout-bridge/dom/findBodyPmSpans.js";
 import { findPageShellForPmPos } from "../layout-painter/renderPage.js";
-import { isValidPmScrollPosition, prefersReducedMotionBehavior } from "./scrollNavigation.js";
+import { getEditorScrollRoot, scrollEditorElementIntoView } from "./editorScrollRoot.js";
+import { isValidPmScrollPosition } from "./scrollNavigation.js";
 //#region src/paged-layout/scrollToPmPosition.ts
 /** Class on the pages container `PagedEditor` paints into. */
 const PAGES_CONTAINER_CLASS = "paged-editor__pages";
@@ -9,10 +10,7 @@ const scrollPagesToPmPosition = (pageContainer, pmPos) => {
 	if (!isValidPmScrollPosition(pmPos)) return;
 	const exact = findBodyPmAnchor(pageContainer, pmPos);
 	if (exact) {
-		exact.scrollIntoView({
-			behavior: prefersReducedMotionBehavior(),
-			block: "center"
-		});
+		scrollEditorElementIntoView(exact);
 		return;
 	}
 	let runMatch = null;
@@ -27,28 +25,19 @@ const scrollPagesToPmPosition = (pageContainer, pmPos) => {
 		}
 	}
 	if (runMatch) {
-		runMatch.scrollIntoView({
-			behavior: prefersReducedMotionBehavior(),
-			block: "center"
-		});
+		scrollEditorElementIntoView(runMatch);
 		return;
 	}
 	const shellHit = findPageShellForPmPos(pageContainer, pmPos);
 	if (!shellHit) return;
 	const { element: shell } = shellHit;
-	shell.scrollIntoView({
-		behavior: prefersReducedMotionBehavior(),
-		block: "center"
-	});
+	scrollEditorElementIntoView(shell);
 	let attempts = 0;
 	const refine = () => {
 		attempts++;
 		const exactInShell = findBodyPmAnchor(shell, pmPos);
 		if (exactInShell) {
-			exactInShell.scrollIntoView({
-				behavior: prefersReducedMotionBehavior(),
-				block: "center"
-			});
+			scrollEditorElementIntoView(exactInShell);
 			return;
 		}
 		let bestEl = null;
@@ -68,10 +57,7 @@ const scrollPagesToPmPosition = (pageContainer, pmPos) => {
 			}
 		}
 		if (bestEl) {
-			bestEl.scrollIntoView({
-				behavior: prefersReducedMotionBehavior(),
-				block: "center"
-			});
+			scrollEditorElementIntoView(bestEl);
 			return;
 		}
 		if (attempts < 20) requestAnimationFrame(refine);
@@ -86,7 +72,7 @@ const scrollPagesToPmPosition = (pageContainer, pmPos) => {
 * callers can fall back to coordinate-based scrolling.
 */
 const scrollFolioPositionIntoView = (view, pmPos) => {
-	const pageContainer = view.dom.closest("[data-folio-scroll]")?.querySelector(`.paged-editor__pages`) ?? null;
+	const pageContainer = getEditorScrollRoot(view.dom)?.querySelector(`.paged-editor__pages`) ?? null;
 	if (!pageContainer) return false;
 	scrollPagesToPmPosition(pageContainer, pmPos);
 	return true;

package/dist/prosemirror/commands/clearParagraphIndent.d.ts

@@ -0,0 +1,6 @@
+import { Command } from "prosemirror-state";
+//#region src/prosemirror/commands/clearParagraphIndent.d.ts
+/** Clear indentation at paragraph start before Backspace joins paragraphs. */
+declare const clearIndentOnBackspace: Command;
+//#endregion
+export { clearIndentOnBackspace };

package/dist/prosemirror/commands/clearParagraphIndent.js

@@ -0,0 +1,25 @@
+import { expectParagraphAttrs } from "../attrs/index.js";
+import { TextSelection } from "prosemirror-state";
+//#region src/prosemirror/commands/clearParagraphIndent.ts
+/** Clear indentation at paragraph start before Backspace joins paragraphs. */
+const clearIndentOnBackspace = (state, dispatch) => {
+	if (!(state.selection instanceof TextSelection)) return false;
+	const { $cursor } = state.selection;
+	if (!$cursor || $cursor.parentOffset !== 0 || $cursor.parent.type.name !== "paragraph") return false;
+	const attrs = expectParagraphAttrs($cursor.parent);
+	const hasFirstLine = typeof attrs.indentFirstLine === "number" && attrs.indentFirstLine > 0;
+	const hasIndentLeft = typeof attrs.indentLeft === "number" && attrs.indentLeft > 0;
+	if (!hasFirstLine && !attrs.hangingIndent && !hasIndentLeft) return false;
+	if (dispatch) {
+		const position = $cursor.before();
+		dispatch(state.tr.setNodeMarkup(position, void 0, {
+			...attrs,
+			indentFirstLine: null,
+			hangingIndent: null,
+			indentLeft: null
+		}).scrollIntoView());
+	}
+	return true;
+};
+//#endregion
+export { clearIndentOnBackspace };

package/dist/prosemirror/commentIdAllocator.d.ts

@@ -3,30 +3,23 @@ import { EditorView } from "prosemirror-view";
 //#region src/prosemirror/commentIdAllocator.d.ts
 /** Sentinel ID for a comment that hasn't been persisted yet (anchored to selection). */
 declare const PENDING_COMMENT_ID = -1;
+declare const CommentIdSpaceExhaustedError_base: import("better-result").TaggedErrorClass<"CommentIdSpaceExhaustedError">;
+declare class CommentIdSpaceExhaustedError extends CommentIdSpaceExhaustedError_base<{
+  message: string;
+}> {}
+/** Allocate a valid, unused comment ID in this realm. */
+declare function allocateCommentId(): number;
+/** Reserve a loaded ID and advance past it when the upper bound permits. */
+declare function seedCommentIdAbove(id: number): void;
 type CommentIdAllocator = {
-  /** Allocate the next ID and advance the counter. */
+  /** Allocate the next unused ID. */
   next(): number;
-  /**
-   * On document load, bump the counter above the highest ID found in the
-   * loaded comments and tracked-change marks so subsequent allocations don't
-   * collide with already-present IDs.
-   */
-  seedAbove(maxId: number): void;
+  /** Reserve a loaded ID and seed above it when possible. */
+  seedAbove(id: number): void;
 };
-/**
- * Create an instance-scoped monotonic comment/revision ID allocator. IDs are
- * never reused (deleting a comment does not free its ID), and the counter is
- * private to this allocator — multiple editors get independent ID spaces.
- */
+/** Every handle uses the same counter, including separate editor instances. */
 declare function createCommentIdAllocator(): CommentIdAllocator;
-/**
- * Seed an allocator above every comment/revision ID currently in the document
- * — comment objects (including replies, which carry no mark) plus
- * tracked-change `revisionId` marks. Because `seedAbove` only ever raises the
- * counter, this is safe to call on load (React) or before each allocation
- * (Vue): new IDs never collide with or reuse an existing one, and the comment
- * and revision ID spaces stay unified.
- */
-declare function seedCommentAllocator(allocator: CommentIdAllocator, comments: Comment[] | undefined, view: EditorView | null): void;
+/** Seed from comments, replies, and the document's conservative annotation maximum. */
+declare function seedCommentAllocator(allocator: CommentIdAllocator, comments: Comment[] | undefined, view: Pick<EditorView, "state"> | null): void;
 //#endregion
-export { CommentIdAllocator, PENDING_COMMENT_ID, createCommentIdAllocator, seedCommentAllocator };
+export { CommentIdAllocator, CommentIdSpaceExhaustedError, PENDING_COMMENT_ID, allocateCommentId, createCommentIdAllocator, seedCommentAllocator, seedCommentIdAbove };

package/dist/prosemirror/commentIdAllocator.js

@@ -1,40 +1,65 @@
 import { maxAnnotationIdInDoc, seedRevisionIdsAbove } from "./plugins/revisionIds.js";
+import { readRangeAnchorAttrs } from "./rangeAnchorAttrs.js";
+import { TaggedError } from "better-result";
 import { MAX_REVISION_ID } from "@stll/docx-core/model";
 //#region src/prosemirror/commentIdAllocator.ts
-/** Sentinel ID for a comment that hasn't been persisted yet (anchored to selection). */
-const PENDING_COMMENT_ID = -1;
 /**
-* Create an instance-scoped monotonic comment/revision ID allocator. IDs are
-* never reused (deleting a comment does not free its ID), and the counter is
-* private to this allocator — multiple editors get independent ID spaces.
+* Realm-wide comment ID allocation, shared by live editors and headless reviewers.
+* Loaded and issued IDs stay reserved even when a comment is deleted.
 */
+/** Sentinel ID for a comment that hasn't been persisted yet (anchored to selection). */
+const PENDING_COMMENT_ID = -1;
+var CommentIdSpaceExhaustedError = class extends TaggedError("CommentIdSpaceExhaustedError") {};
+let nextId = 1;
+const reservedIds = /* @__PURE__ */ new Set();
+/** Allocate a valid, unused comment ID in this realm. */
+function allocateCommentId() {
+	if (reservedIds.size >= MAX_REVISION_ID) throw new CommentIdSpaceExhaustedError({ message: "The OOXML comment ID space is exhausted." });
+	while (reservedIds.has(nextId)) nextId = nextId === MAX_REVISION_ID ? 1 : nextId + 1;
+	const id = nextId;
+	reservedIds.add(id);
+	nextId = id === MAX_REVISION_ID ? 1 : id + 1;
+	return id;
+}
+/** Reserve a loaded ID and advance past it when the upper bound permits. */
+function seedCommentIdAbove(id) {
+	if (!Number.isInteger(id) || id < 0 || id > MAX_REVISION_ID) return;
+	if (id > 0) reservedIds.add(id);
+	if (id >= nextId) nextId = id === MAX_REVISION_ID ? 1 : id + 1;
+}
+/** Every handle uses the same counter, including separate editor instances. */
 function createCommentIdAllocator() {
-	let nextId = 1;
 	return {
-		next: () => {
-			if (nextId > MAX_REVISION_ID) nextId = 1;
-			return nextId++;
-		},
-		seedAbove(maxId) {
-			if (!Number.isInteger(maxId) || maxId < 0 || maxId >= MAX_REVISION_ID) return;
-			if (maxId >= nextId) nextId = maxId + 1;
-		}
+		next: allocateCommentId,
+		seedAbove: seedCommentIdAbove
 	};
 }
-/**
-* Seed an allocator above every comment/revision ID currently in the document
-* — comment objects (including replies, which carry no mark) plus
-* tracked-change `revisionId` marks. Because `seedAbove` only ever raises the
-* counter, this is safe to call on load (React) or before each allocation
-* (Vue): new IDs never collide with or reuse an existing one, and the comment
-* and revision ID spaces stay unified.
-*/
+/** Seed from comments, replies, and the document's conservative annotation maximum. */
 function seedCommentAllocator(allocator, comments, view) {
 	let max = 0;
-	for (const comment of comments ?? []) if (Number.isInteger(comment.id) && comment.id > max && comment.id <= MAX_REVISION_ID) max = comment.id;
-	if (view) max = Math.max(max, maxAnnotationIdInDoc(view.state.doc));
+	for (const comment of comments ?? []) {
+		allocator.seedAbove(comment.id);
+		if (Number.isInteger(comment.id) && comment.id > max && comment.id <= MAX_REVISION_ID) max = comment.id;
+	}
+	if (view) {
+		view.state.doc.descendants((node) => {
+			for (const mark of node.marks) {
+				const id = mark.attrs["commentId"];
+				if (typeof id === "number") allocator.seedAbove(id);
+			}
+			if (node.type.name === "commentReference") {
+				const id = node.attrs["commentId"];
+				if (typeof id === "number") allocator.seedAbove(id);
+			}
+			if (node.type.name === "rangeAnchor") {
+				const attrs = readRangeAnchorAttrs(node);
+				if (attrs.ok && attrs.value.start.type === "commentRangeStart") allocator.seedAbove(attrs.value.start.id);
+			}
+		});
+		max = Math.max(max, maxAnnotationIdInDoc(view.state.doc));
+	}
 	allocator.seedAbove(max);
 	seedRevisionIdsAbove(max);
 }
 //#endregion
-export { PENDING_COMMENT_ID, createCommentIdAllocator, seedCommentAllocator };
+export { CommentIdSpaceExhaustedError, PENDING_COMMENT_ID, allocateCommentId, createCommentIdAllocator, seedCommentAllocator, seedCommentIdAbove };

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

@@ -1,5 +1,97 @@
 import { createExtension } from "../create.js";
-import { history, redo, undo } from "prosemirror-history";
+import { Plugin } from "prosemirror-state";
+import { closeHistory, history, isHistoryTransaction, redo, undo } from "prosemirror-history";
+//#region src/prosemirror/extensions/core/HistoryExtension.ts
+/**
+* History Extension — undo/redo via prosemirror-history
+*/
+/**
+* History adjacency is based on step maps, which differ for physical deletions
+* and suggestion marks. Group continuous typing and same-direction deletions explicitly; each
+* structural edit, paste, drop, or composition starts its own undo event.
+* Capture DOM input before the shared input router or a keymap handles it.
+*/
+const inputBoundaryPlugin = (newGroupDelay) => {
+	let previousKind;
+	let deletionGroup = 0;
+	let previousInputTime = 0;
+	let pendingDeletionGroup = null;
+	return new Plugin({
+		filterTransaction(tr) {
+			const pendingGroup = pendingDeletionGroup;
+			pendingDeletionGroup = null;
+			if (isHistoryTransaction(tr) || !tr.docChanged && tr.selectionSet) {
+				previousKind = void 0;
+				return true;
+			}
+			if (tr.docChanged && (previousKind === "deleteBackward" || previousKind === "deleteForward" || previousKind === "deletion")) {
+				if (pendingGroup !== null) tr.setMeta("composition", pendingGroup);
+				else if (!tr.getMeta("appendedTransaction")) previousKind = void 0;
+			}
+			return true;
+		},
+		view(view) {
+			const startInput = (kind) => {
+				const now = Date.now();
+				if (kind !== previousKind || kind === "structure" || kind === "paste" || kind === "drop" || now - previousInputTime > newGroupDelay) {
+					deletionGroup--;
+					view.dispatch(closeHistory(view.state.tr));
+				}
+				previousInputTime = now;
+				previousKind = kind;
+				pendingDeletionGroup = kind === "deleteBackward" || kind === "deleteForward" || kind === "deletion" ? deletionGroup : null;
+			};
+			const keydown = (event) => {
+				if (event.isComposing) return;
+				if (event.key === "Backspace" || event.key === "Delete") {
+					startInput(event.key === "Backspace" ? "deleteBackward" : "deleteForward");
+					return;
+				}
+				if (event.key === "Enter") {
+					startInput("structure");
+					return;
+				}
+				if (event.key.length === 1 && !event.metaKey && !event.ctrlKey) startInput("typing");
+			};
+			const beforeinput = (event) => {
+				if (event.inputType === "insertCompositionText" || event.isComposing) {
+					startInput("composition");
+					return;
+				}
+				if (event.inputType === "insertText" || event.inputType === "insertReplacementText") {
+					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");
+			};
+			const paste = () => startInput("paste");
+			const drop = () => startInput("drop");
+			const compositionstart = () => {
+				view.dispatch(closeHistory(view.state.tr));
+				previousKind = "composition";
+			};
+			view.dom.addEventListener("keydown", keydown, true);
+			view.dom.addEventListener("beforeinput", beforeinput, true);
+			view.dom.addEventListener("paste", paste, true);
+			view.dom.addEventListener("drop", drop, true);
+			view.dom.addEventListener("compositionstart", compositionstart, true);
+			return { destroy() {
+				view.dom.removeEventListener("keydown", keydown, true);
+				view.dom.removeEventListener("beforeinput", beforeinput, true);
+				view.dom.removeEventListener("paste", paste, true);
+				view.dom.removeEventListener("drop", drop, true);
+				view.dom.removeEventListener("compositionstart", compositionstart, true);
+			} };
+		}
+	});
+};
+const consumeHistoryShortcut = (command) => (state, dispatch, view) => {
+	command(state, dispatch, view);
+	return true;
+};
 const HistoryExtension = createExtension({
 	name: "history",
 	defaultOptions: {
@@ -12,15 +104,15 @@ const HistoryExtension = createExtension({
 			plugins: [history({
 				depth: options.depth,
 				newGroupDelay: options.newGroupDelay
-			})],
+			}), inputBoundaryPlugin(options.newGroupDelay)],
 			commands: {
 				undo: () => undo,
 				redo: () => redo
 			},
 			...options.shortcuts === "editor" && { keyboardShortcuts: {
-				"Mod-z": undo,
-				"Mod-y": redo,
-				"Mod-Shift-z": redo
+				"Mod-z": consumeHistoryShortcut(undo),
+				"Mod-y": consumeHistoryShortcut(redo),
+				"Mod-Shift-z": consumeHistoryShortcut(redo)
 			} }
 		};
 	}

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

@@ -1,3 +1,4 @@
+import { mintBookmarkId, reserveProseBookmarkIds } from "../../../docx/bookmarkIds.js";
 import { BUILT_IN_STYLE_NAME } from "../../../docx/builtInStyles.js";
 import { PROSE_PARAGRAPH_SOURCE_TOKEN_ATTR } from "../../../docx/paragraphPropertySource.js";
 import { isStyleSourcedParagraphNumbering } from "../../../internal/paragraphFormattingSerialization.js";
@@ -671,6 +672,7 @@ const ParagraphExtension = createNodeExtension({
 				if (!dispatch) return true;
 				const { schema: s } = state;
 				const tr = state.tr;
+				reserveProseBookmarkIds(state.doc);
 				const bookmarkEntries = [];
 				for (const h of headings) {
 					const bookmarkName = `_Toc${Math.floor(1e8 + Math.random() * 9e8)}`;
@@ -683,7 +685,7 @@ const ParagraphExtension = createNodeExtension({
 					const paragraphNode = tr.doc.resolve(mappedPos).nodeAfter;
 					if (paragraphNode && paragraphNode.type.name === "paragraph") {
 						const newBookmarks = [...(paragraphNode.attrs["bookmarks"] ?? []).filter((b) => !b.name.startsWith("_Toc")), {
-							id: Math.floor(Math.random() * 2147483647),
+							id: mintBookmarkId(),
 							name: bookmarkName
 						}];
 						tr.setNodeMarkup(mappedPos, void 0, {

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 { clearIndentOnBackspace } from "../../commands/clearParagraphIndent.js";
 import { keepSectionBreaksOnSurvivingMarks } from "../../commands/sectionBreak.js";
 import { getDocumentStyleResolver } from "../../plugins/documentStyleState.js";
 import { RUN_FORMATTING_MARK_NAMES } from "../../runFormattingMarkNames.js";
@@ -8,6 +9,7 @@ import { paragraphAttrsFromResolvedStyle } from "../../styles/resolvedStyleAttrs
 import { createExtension } from "../create.js";
 import { marksToTextFormatting, textFormattingToMarks } from "../marks/markUtils.js";
 import { Priority } from "../types.js";
+import { EditorState, TextSelection } from "prosemirror-state";
 import { baseKeymap, deleteSelection, joinBackward, joinForward, selectAll, selectParentNode, splitBlock } from "prosemirror-commands";
 //#region src/prosemirror/extensions/features/BaseKeymapExtension.ts
 /**
@@ -22,31 +24,6 @@ function chainCommands(...commands) {
 	};
 }
 /**
-* Backspace at the start of a paragraph clears first-line indent / hanging indent
-* before joining with the previous paragraph (matches Word behavior).
-*/
-const clearIndentOnBackspace = (state, dispatch) => {
-	const { $cursor } = state.selection;
-	if (!$cursor) return false;
-	if ($cursor.parentOffset !== 0) return false;
-	if ($cursor.parent.type.name !== "paragraph") return false;
-	const attrs = $cursor.parent.attrs;
-	const hasFirstLine = attrs["indentFirstLine"] !== null && attrs["indentFirstLine"] > 0;
-	const hasHanging = !!attrs["hangingIndent"];
-	const hasIndentLeft = attrs["indentLeft"] !== null && attrs["indentLeft"] > 0;
-	if (!hasFirstLine && !hasHanging && !hasIndentLeft) return false;
-	if (dispatch) {
-		const pos = $cursor.before();
-		dispatch(state.tr.setNodeMarkup(pos, void 0, {
-			...attrs,
-			indentFirstLine: null,
-			hangingIndent: null,
-			indentLeft: null
-		}).scrollIntoView());
-	}
-	return true;
-};
-/**
 * Custom Enter handler: splits the block, inherits style-related attrs,
 * clears paragraph borders, and preserves run formatting on the new paragraph.
 *
@@ -117,16 +94,33 @@ function applyNextParagraphStyle(tr, sourcePara, newPara, resolver) {
 	tr.setStoredMarks(resolved.runFormatting ? textFormattingToMarks(resolved.runFormatting, tr.doc.type.schema) : []);
 	return true;
 }
+const blockBoundaryDeletion = (state) => {
+	if (!(state.selection instanceof TextSelection) || state.selection.empty) return null;
+	const tr = state.tr.deleteSelection();
+	return tr.doc.resolve(tr.mapping.map(state.selection.from)).parent.isTextblock ? null : tr;
+};
 const splitBlockClearBorders = (state, dispatch, view) => {
-	const { $from: preSplitFrom } = state.selection;
+	const deletion = blockBoundaryDeletion(state);
+	const splitState = deletion ? EditorState.create({
+		doc: deletion.doc,
+		selection: deletion.selection,
+		storedMarks: deletion.storedMarks
+	}) : state;
+	const { $from: preSplitFrom } = splitState.selection;
 	const sourcePara = preSplitFrom.parent.type.name === "paragraph" ? preSplitFrom.parent : null;
-	const caretFormattingMarks = (state.storedMarks || preSplitFrom.marks()).filter((mark) => RUN_FORMATTING_MARK_NAMES.has(mark.type.name));
+	const caretFormattingMarks = (splitState.storedMarks || preSplitFrom.marks()).filter((mark) => RUN_FORMATTING_MARK_NAMES.has(mark.type.name));
 	const resolver = getDocumentStyleResolver(state);
 	const splitResult = { tr: null };
-	if (!splitBlock(state, dispatch ? (tr) => {
+	if (!splitBlock(splitState, dispatch ? (tr) => {
 		splitResult.tr = tr;
 	} : void 0, view)) return false;
 	if (dispatch && splitResult.tr !== null) {
+		if (deletion) {
+			for (const step of splitResult.tr.steps) deletion.step(step);
+			deletion.setSelection(splitResult.tr.selection.getBookmark().resolve(deletion.doc));
+			deletion.setStoredMarks(splitResult.tr.storedMarks);
+			splitResult.tr = deletion;
+		}
 		const tr = splitResult.tr;
 		const { $from } = tr.selection;
 		const newPara = $from.parent;

package/dist/prosemirror/extensions/nodes/ShapeExtension.js

@@ -268,9 +268,9 @@ function createShapeElement(type, w, h, adjustments) {
 		case "straightConnector1": {
 			const el = document.createElementNS(SVG_NS, "line");
 			setNum(el, "x1", 0);
-			setNum(el, "y1", h / 2);
+			setNum(el, "y1", 0);
 			setNum(el, "x2", w);
-			setNum(el, "y2", h / 2);
+			setNum(el, "y2", h);
 			return el;
 		}
 		case "rightBrace": {
@@ -537,9 +537,11 @@ const ShapeExtension = createNodeExtension({
 			const strokeWidth = finiteNumber(attrs.outlineWidth) ?? 1;
 			const svg = document.createElementNS(SVG_NS, "svg");
 			svg.setAttribute("xmlns", SVG_NS);
-			setNum(svg, "width", w);
-			setNum(svg, "height", h);
-			svg.setAttribute("viewBox", `0 0 ${w} ${h}`);
+			const viewportWidth = w === 0 ? 1 : w;
+			const viewportHeight = h === 0 ? 1 : h;
+			setNum(svg, "width", viewportWidth);
+			setNum(svg, "height", viewportHeight);
+			svg.setAttribute("viewBox", `0 0 ${viewportWidth} ${viewportHeight}`);
 			let gradient = null;
 			let fillAttr;
 			if (attrs.fillType === "gradient" && attrs.gradientStops) {
@@ -548,7 +550,7 @@ const ShapeExtension = createNodeExtension({
 				fillAttr = gradient ? `url(#${gradId})` : safeFillColor;
 			} else fillAttr = attrs.fillType === "none" ? "none" : safeFillColor;
 			const strokeAttr = attrs.outlineStyle === "none" ? "none" : safeStrokeColor;
-			svg.setAttribute("style", `fill:${fillAttr};stroke:${strokeAttr};stroke-width:${strokeWidth}`);
+			svg.setAttribute("style", `fill:${fillAttr};stroke:${strokeAttr};stroke-width:${strokeWidth};overflow:visible`);
 			if (gradient) {
 				const defs = document.createElementNS(SVG_NS, "defs");
 				defs.append(gradient);