@stll/folio-core 0.1.3 → 0.2.0

package/dist/paged-layout/rangeProjection.js

@@ -77,6 +77,39 @@ const measureContentLeft = (pagesContainer, zoom) => {
 	}
 	return Number.isFinite(min) ? (min - overlayLeft) / zoom : null;
 };
+const measureDirectiveGutter = (pagesContainer, zoom) => {
+	if (zoom <= 0) return null;
+	const overlay = pagesContainer.parentElement?.querySelector("[data-testid=\"selection-overlay\"]");
+	const pages = pagesContainer.querySelectorAll(".layout-page");
+	if (!overlay || pages.length === 0) return null;
+	const overlayRect = overlay.getBoundingClientRect();
+	const pageBands = [];
+	let contentLeft = null;
+	let marginWidth = null;
+	for (const [domIndex, page] of pages.entries()) {
+		const contentEl = page.querySelector(".layout-page-content");
+		if (!contentEl) continue;
+		const pageNumberRaw = page.dataset["pageNumber"];
+		const pageIndex = pageNumberRaw ? Number(pageNumberRaw) - 1 : domIndex;
+		const contentRect = contentEl.getBoundingClientRect();
+		pageBands.push({
+			pageIndex,
+			top: (contentRect.top - overlayRect.top) / zoom,
+			bottom: (contentRect.bottom - overlayRect.top) / zoom
+		});
+		if (contentLeft === null) {
+			const pageRect = page.getBoundingClientRect();
+			contentLeft = (contentRect.left - overlayRect.left) / zoom;
+			marginWidth = Math.max(0, (contentRect.left - pageRect.left) / zoom);
+		}
+	}
+	if (contentLeft === null || marginWidth === null) return null;
+	return {
+		contentLeft,
+		marginWidth,
+		pageBands
+	};
+};
 /**
 * Sample the painted-run text style at each position in a single walk
 * over the rendered run spans. Positions outside the rendered buffer
@@ -150,4 +183,4 @@ const projectRangesToRects = async (ranges, ctx) => {
 	return result;
 };
 //#endregion
-export { collectRunFontsAtPmPositions, measureContentLeft, projectRangesToRects };
+export { collectRunFontsAtPmPositions, measureContentLeft, measureDirectiveGutter, projectRangesToRects };

package/dist/prosemirror/cellDragSelection.d.ts

@@ -0,0 +1,34 @@
+import { EditorView } from "prosemirror-view";
+
+//#region src/prosemirror/cellDragSelection.d.ts
+/**
+ * @deprecated No longer used. The tracker ignores pointer overflow so same-cell
+ * drags stay text selections. Kept only for backward-compatible imports; will be
+ * removed in a future major.
+ */
+declare const CELL_SELECT_OVERFLOW_PX = 5;
+/**
+ * Walk up from a PM position to the enclosing `tableCell`/`tableHeader` and
+ * return its `before(d)` position (what `CellSelection` resolves against), or
+ * null when the position isn't inside a table cell.
+ */
+declare function findCellPosFromPmPos(view: EditorView, pmPos: number): number | null;
+/** Dispatch a `CellSelection` spanning the two cell positions. */
+declare function applyCellSelection(view: EditorView, anchorCellPos: number, headCellPos: number): boolean;
+/**
+ * Per-gesture state machine for cell-drag selection. Create one per pointer
+ * handler; drive it from mousedown/mousemove/mouseup.
+ */
+type CellDragTracker = {
+  /** mousedown: record the cell under the press (or null when outside a table). */begin(cellPos: number | null): void;
+  /**
+   * mousemove: returns true when it applied a `CellSelection` and the caller
+   * should NOT also run its text-drag selection for this move.
+   */
+  update(view: EditorView, pmPos: number, clientX: number): boolean; /** mouseup / gesture end: clear the transient drag flags. */
+  end(): void; /** True while a cell drag is actively producing CellSelections. */
+  readonly isCellDragging: boolean;
+};
+declare function createCellDragTracker(): CellDragTracker;
+//#endregion
+export { CELL_SELECT_OVERFLOW_PX, CellDragTracker, applyCellSelection, createCellDragTracker, findCellPosFromPmPos };

package/dist/prosemirror/cellDragSelection.js

@@ -0,0 +1,69 @@
+import { CellSelection } from "prosemirror-tables";
+//#region src/prosemirror/cellDragSelection.ts
+/**
+* @deprecated No longer used. The tracker ignores pointer overflow so same-cell
+* drags stay text selections. Kept only for backward-compatible imports; will be
+* removed in a future major.
+*/
+const CELL_SELECT_OVERFLOW_PX = 5;
+/**
+* Walk up from a PM position to the enclosing `tableCell`/`tableHeader` and
+* return its `before(d)` position (what `CellSelection` resolves against), or
+* null when the position isn't inside a table cell.
+*/
+function findCellPosFromPmPos(view, pmPos) {
+	try {
+		const $pos = view.state.doc.resolve(pmPos);
+		for (let d = $pos.depth; d > 0; d--) {
+			const node = $pos.node(d);
+			if (node.type.name === "tableCell" || node.type.name === "tableHeader") return $pos.before(d);
+		}
+	} catch {}
+	return null;
+}
+/** Dispatch a `CellSelection` spanning the two cell positions. */
+function applyCellSelection(view, anchorCellPos, headCellPos) {
+	try {
+		const $a = view.state.doc.resolve(anchorCellPos);
+		const $h = view.state.doc.resolve(headCellPos);
+		view.dispatch(view.state.tr.setSelection(new CellSelection($a, $h)));
+		return true;
+	} catch {
+		return false;
+	}
+}
+function createCellDragTracker() {
+	let anchorCellPos = null;
+	let cellDragging = false;
+	return {
+		begin(cellPos) {
+			anchorCellPos = cellPos;
+			cellDragging = false;
+		},
+		update(view, pmPos, _clientX) {
+			if (anchorCellPos === null) return false;
+			if (cellDragging) {
+				const cur = findCellPosFromPmPos(view, pmPos);
+				if (cur !== null) {
+					applyCellSelection(view, anchorCellPos, cur);
+					return true;
+				}
+			}
+			const cur = findCellPosFromPmPos(view, pmPos);
+			if (cur !== null && cur !== anchorCellPos) {
+				cellDragging = true;
+				applyCellSelection(view, anchorCellPos, cur);
+				return true;
+			}
+			return false;
+		},
+		end() {
+			cellDragging = false;
+		},
+		get isCellDragging() {
+			return cellDragging;
+		}
+	};
+}
+//#endregion
+export { CELL_SELECT_OVERFLOW_PX, applyCellSelection, createCellDragTracker, findCellPosFromPmPos };

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

@@ -0,0 +1,15 @@
+import { Command } from "prosemirror-state";
+
+//#region src/prosemirror/commands/sectionBreak.d.ts
+/**
+ * Insert a "next page" section break at the cursor — starts a new section on a
+ * new page.
+ */
+declare const insertSectionBreakNextPage: Command;
+/**
+ * Insert a "continuous" section break at the cursor — starts a new section on
+ * the same page.
+ */
+declare const insertSectionBreakContinuous: Command;
+//#endregion
+export { insertSectionBreakContinuous, insertSectionBreakNextPage };

package/dist/prosemirror/commands/sectionBreak.js

@@ -0,0 +1,54 @@
+import { TextSelection } from "prosemirror-state";
+//#region src/prosemirror/commands/sectionBreak.ts
+/**
+* Insert a section break at the current cursor position.
+*
+* In OOXML a section break is the `sectPr` carried by the *last* paragraph of a
+* section. So we split the current paragraph at the cursor, mark the first half
+* with `sectionBreakType` (it becomes the section end), and leave the cursor in
+* the second half (the first paragraph of the new section). Content after the
+* cursor therefore flows into the new section — onto a new page for `nextPage`,
+* or in place for `continuous`.
+*/
+function insertSectionBreakAtCursor(breakType) {
+	return (state, dispatch) => {
+		const { schema } = state;
+		const paragraphType = schema.nodes["paragraph"];
+		if (!paragraphType) return false;
+		const { $from } = state.selection;
+		if (!($from.parent.isTextblock ? state.doc.resolve($from.before()).depth === 0 : $from.depth === 0)) return false;
+		if (dispatch) {
+			const tr = state.tr;
+			let cursorPos;
+			if ($from.parent.isTextblock) {
+				const paraPos = $from.before();
+				tr.split($from.pos);
+				const firstPara = tr.doc.nodeAt(paraPos);
+				if (firstPara) tr.setNodeMarkup(paraPos, void 0, {
+					...firstPara.attrs,
+					sectionBreakType: breakType
+				});
+				cursorPos = tr.mapping.map($from.pos);
+			} else {
+				const pos = $from.pos;
+				tr.insert(pos, paragraphType.create({ sectionBreakType: breakType }));
+				cursorPos = pos + 1;
+			}
+			tr.setSelection(TextSelection.create(tr.doc, cursorPos));
+			dispatch(tr.scrollIntoView());
+		}
+		return true;
+	};
+}
+/**
+* Insert a "next page" section break at the cursor — starts a new section on a
+* new page.
+*/
+const insertSectionBreakNextPage = insertSectionBreakAtCursor("nextPage");
+/**
+* Insert a "continuous" section break at the cursor — starts a new section on
+* the same page.
+*/
+const insertSectionBreakContinuous = insertSectionBreakAtCursor("continuous");
+//#endregion
+export { insertSectionBreakContinuous, insertSectionBreakNextPage };

package/dist/prosemirror/commentIdAllocator.d.ts

@@ -0,0 +1,32 @@
+import { Comment } from "../types/content.js";
+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;
+type CommentIdAllocator = {
+  /** Allocate the next ID and advance the counter. */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;
+};
+/**
+ * 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.
+ */
+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;
+//#endregion
+export { CommentIdAllocator, PENDING_COMMENT_ID, createCommentIdAllocator, seedCommentAllocator };

package/dist/prosemirror/commentIdAllocator.js

@@ -0,0 +1,35 @@
+//#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.
+*/
+function createCommentIdAllocator() {
+	let nextId = 1;
+	return {
+		next: () => nextId++,
+		seedAbove(maxId) {
+			if (maxId >= nextId) nextId = maxId + 1;
+		}
+	};
+}
+/**
+* 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.
+*/
+function seedCommentAllocator(allocator, comments, view) {
+	let max = 0;
+	for (const comment of comments ?? []) max = Math.max(max, comment.id);
+	if (view) view.state.doc.descendants((node) => {
+		for (const mark of node.marks) if (mark.attrs["revisionId"] != null) max = Math.max(max, mark.attrs["revisionId"]);
+	});
+	allocator.seedAbove(max);
+}
+//#endregion
+export { PENDING_COMMENT_ID, createCommentIdAllocator, seedCommentAllocator };

package/dist/prosemirror/commentOps.d.ts

@@ -0,0 +1,35 @@
+import { Comment } from "../types/content.js";
+import { CommentIdAllocator } from "./commentIdAllocator.js";
+import { EditorView } from "prosemirror-view";
+
+//#region src/prosemirror/commentOps.d.ts
+/** Build a Comment object with a freshly-allocated ID. */
+declare function createComment(allocator: CommentIdAllocator, text: string, authorName: string, parentId?: number): Comment;
+type AddCommentOptions = {
+  paraId: string;
+  text: string;
+  author: string;
+  search?: string;
+};
+/**
+ * Locate the comment range (paragraph, narrowed by `search`), add the comment
+ * mark, dispatch, and return the created Comment. Returns null when the schema
+ * lacks a comment mark or the range can't be resolved. The caller owns adding
+ * the comment to its own state and showing the sidebar.
+ */
+declare function addCommentToRange(view: EditorView, options: AddCommentOptions, allocator: CommentIdAllocator): Comment | null;
+type ProposeChangeOptions = {
+  paraId: string;
+  search: string;
+  replaceWith: string;
+  author: string;
+};
+/**
+ * Apply a tracked change (insertion / deletion / replace) to the located range.
+ * `search === ''` means a pure insertion at the paragraph end; `replaceWith ===
+ * ''` means a pure deletion. Refuses to layer onto an existing tracked change.
+ * Returns true when a change was dispatched, false otherwise.
+ */
+declare function applyProposedChange(view: EditorView, options: ProposeChangeOptions, allocator: CommentIdAllocator): boolean;
+//#endregion
+export { AddCommentOptions, ProposeChangeOptions, addCommentToRange, applyProposedChange, createComment };

package/dist/prosemirror/commentOps.js

@@ -0,0 +1,104 @@
+import { findParagraphByParaId } from "./utils/findParagraphByParaId.js";
+import { findTextInPmParagraph } from "./paraText.js";
+//#region src/prosemirror/commentOps.ts
+/** Build a Comment object with a freshly-allocated ID. */
+function createComment(allocator, text, authorName, parentId) {
+	return {
+		id: allocator.next(),
+		author: authorName,
+		date: (/* @__PURE__ */ new Date()).toISOString(),
+		content: [{
+			type: "paragraph",
+			formatting: {},
+			content: [{
+				type: "run",
+				formatting: {},
+				content: [{
+					type: "text",
+					text
+				}]
+			}]
+		}],
+		...parentId !== void 0 && { parentId }
+	};
+}
+/**
+* Locate the comment range (paragraph, narrowed by `search`), add the comment
+* mark, dispatch, and return the created Comment. Returns null when the schema
+* lacks a comment mark or the range can't be resolved. The caller owns adding
+* the comment to its own state and showing the sidebar.
+*/
+function addCommentToRange(view, options, allocator) {
+	const { schema } = view.state;
+	if (!schema.marks["comment"]) return null;
+	const range = findParagraphByParaId(view.state.doc, options.paraId);
+	if (!range) return null;
+	let from = range.from + 1;
+	let to = range.to - 1;
+	if (options.search) {
+		const textRange = findTextInPmParagraph(view.state.doc, range.from, range.to, options.search);
+		if (!textRange) return null;
+		from = textRange.from;
+		to = textRange.to;
+	}
+	if (from >= to) return null;
+	const comment = createComment(allocator, options.text, options.author);
+	view.dispatch(view.state.tr.addMark(from, to, schema.marks["comment"].create({ commentId: comment.id })));
+	return comment;
+}
+/**
+* Apply a tracked change (insertion / deletion / replace) to the located range.
+* `search === ''` means a pure insertion at the paragraph end; `replaceWith ===
+* ''` means a pure deletion. Refuses to layer onto an existing tracked change.
+* Returns true when a change was dispatched, false otherwise.
+*/
+function applyProposedChange(view, options, allocator) {
+	const { schema } = view.state;
+	if (!schema.marks["deletion"] || !schema.marks["insertion"]) return false;
+	const range = findParagraphByParaId(view.state.doc, options.paraId);
+	if (!range) return false;
+	const isInsertion = options.search === "";
+	const isDeletion = options.replaceWith === "";
+	if (isInsertion && isDeletion) return false;
+	let textFrom;
+	let textTo;
+	if (isInsertion) {
+		textFrom = range.to - 1;
+		textTo = range.to - 1;
+	} else {
+		const textRange = findTextInPmParagraph(view.state.doc, range.from, range.to, options.search);
+		if (!textRange) return false;
+		textFrom = textRange.from;
+		textTo = textRange.to;
+	}
+	if (textFrom < textTo) {
+		let overlaps = false;
+		view.state.doc.nodesBetween(textFrom, textTo, (node) => {
+			for (const m of node.marks) if (m.type === schema.marks["insertion"] || m.type === schema.marks["deletion"]) {
+				overlaps = true;
+				return false;
+			}
+			return true;
+		});
+		if (overlaps) return false;
+	}
+	const revisionId = allocator.next();
+	const date = (/* @__PURE__ */ new Date()).toISOString();
+	const deletionMark = schema.marks["deletion"].create({
+		revisionId,
+		author: options.author,
+		date
+	});
+	const insertionMark = schema.marks["insertion"].create({
+		revisionId,
+		author: options.author,
+		date
+	});
+	let tr = view.state.tr;
+	if (!isInsertion) tr = tr.addMark(textFrom, textTo, deletionMark);
+	if (!isDeletion) tr = tr.insert(textTo, schema.text(options.replaceWith, [insertionMark]));
+	view.dispatch(tr);
+	return true;
+}
+//#endregion
+export { addCommentToRange, applyProposedChange, createComment };

package/dist/prosemirror/conversion/toProseDoc.js

@@ -5,6 +5,7 @@ import { setAutospacingBaseValue } from "../autospacingBase.js";
 import { shadingToRunShadingAttrs } from "./runShadingMark.js";
 import { assertValidProseMirrorDocument } from "../validation.js";
 import { mergeTextFormatting } from "../../utils/textFormattingMerge.js";
+import { mergeParagraphFormatting } from "../../utils/paragraphFormattingMerge.js";
 import { marksToTextFormatting } from "./fromProseDoc.js";
 import { createStyleEngine } from "../../style-engine/styleEngine.js";
 import { buildRunFormattingOverrideAttrs } from "../extensions/marks/RunFormattingOverrideExtension.js";
@@ -77,8 +78,8 @@ function convertBlockSdt(blockSdt, convertBlocks) {
 * Resolves style-based text formatting and passes it to runs so that
 * paragraph styles (like Heading1) apply their font size, color, etc.
 */
-function convertParagraph(paragraph, styleResolver, activeCommentIds, extraRunFormatting) {
-	const attrs = paragraphFormattingToAttrs(paragraph, styleResolver);
+function convertParagraph(paragraph, styleResolver, activeCommentIds, extraRunFormatting, tableParagraphOverlay) {
+	const attrs = paragraphFormattingToAttrs(paragraph, styleResolver, tableParagraphOverlay);
 	const inlineNodes = [];
 	let inlineOffset = 0;
 	let bookmarksArr;
@@ -202,7 +203,7 @@ function canCarryTrackedRunMark(node, markType) {
 * If a styleResolver is provided, resolves style-based formatting and merges
 * with inline formatting. Inline formatting takes precedence.
 */
-function paragraphFormattingToAttrs(paragraph, styleResolver) {
+function paragraphFormattingToAttrs(paragraph, styleResolver, tableParagraphOverlay) {
 	const formatting = paragraph.formatting;
 	const styleId = formatting?.styleId;
 	const attrs = {};
@@ -233,7 +234,7 @@ function paragraphFormattingToAttrs(paragraph, styleResolver) {
 	};
 	let stylePpr;
 	if (styleResolver) {
-		stylePpr = styleResolver.resolveParagraphStyle(styleId).paragraphFormatting;
+		stylePpr = styleResolver.resolveParagraphStyleInTable(styleId, tableParagraphOverlay).paragraphFormatting;
 		set("alignment", formatting?.alignment ?? stylePpr?.alignment);
 		set("spaceBefore", formatting?.spaceBefore ?? stylePpr?.spaceBefore);
 		set("spaceAfter", formatting?.spaceAfter ?? stylePpr?.spaceAfter);
@@ -299,6 +300,22 @@ function paragraphFormattingToAttrs(paragraph, styleResolver) {
 	return attrs;
 }
 /**
+* Pick the paragraph-spacing fields out of a table style's (or conditional
+* region's) `w:pPr` for use as the cell-paragraph cascade overlay. Narrower
+* than the full `ParagraphFormatting` bag — see
+* {@link TableCellParagraphSpacingOverlay}.
+*/
+function extractTableParagraphSpacingOverlay(pPr) {
+	if (!pPr) return;
+	const overlay = {};
+	if (pPr.spaceBefore !== void 0) overlay.spaceBefore = pPr.spaceBefore;
+	if (pPr.spaceAfter !== void 0) overlay.spaceAfter = pPr.spaceAfter;
+	if (pPr.lineSpacing !== void 0) overlay.lineSpacing = pPr.lineSpacing;
+	if (pPr.lineSpacingRule !== void 0) overlay.lineSpacingRule = pPr.lineSpacingRule;
+	if (pPr.contextualSpacing !== void 0) overlay.contextualSpacing = pPr.contextualSpacing;
+	return Object.keys(overlay).length > 0 ? overlay : void 0;
+}
+/**
 * Resolve table style conditional formatting
 */
 function resolveTableStyleConditional(styleResolver, tableStyleId, conditionType) {
@@ -308,9 +325,11 @@ function resolveTableStyleConditional(styleResolver, tableStyleId, conditionType
 	const conditional = style.tblStylePr.find((p) => p.type === conditionType);
 	if (!conditional) return;
 	const mergedRunProps = mergeTextFormatting(conditional.pPr?.runProperties ? resolveTextFormatting(conditional.pPr.runProperties, styleResolver) : void 0, conditional.rPr ? resolveTextFormatting(conditional.rPr, styleResolver) : void 0);
+	const paragraphSpacingOverlay = extractTableParagraphSpacingOverlay(conditional.pPr);
 	const result = {};
 	if (conditional.tcPr) result.tcPr = conditional.tcPr;
 	if (mergedRunProps) result.rPr = mergedRunProps;
+	if (paragraphSpacingOverlay) result.pPr = paragraphSpacingOverlay;
 	return result;
 }
 function resolveTableBaseStyle(styleResolver, tableStyleId) {
@@ -318,10 +337,12 @@ function resolveTableBaseStyle(styleResolver, tableStyleId) {
 	const style = styleResolver.getStyle(tableStyleId);
 	if (!style) return;
 	const mergedRunProps = mergeTextFormatting(style.pPr?.runProperties ? resolveTextFormatting(style.pPr.runProperties, styleResolver) : void 0, style.rPr ? resolveTextFormatting(style.rPr, styleResolver) : void 0);
+	const paragraphSpacingOverlay = extractTableParagraphSpacingOverlay(style.pPr);
 	const result = {};
 	if (style.tcPr) result.tcPr = style.tcPr;
 	if (mergedRunProps) result.rPr = mergedRunProps;
-	return result.tcPr || result.rPr ? result : void 0;
+	if (paragraphSpacingOverlay) result.pPr = paragraphSpacingOverlay;
+	return result.tcPr || result.rPr || result.pPr ? result : void 0;
 }
 function mergeConditionalStyles(base, override) {
 	if (!base && !override) return;
@@ -351,6 +372,8 @@ function mergeConditionalStyles(base, override) {
 	}
 	const mergedRPr = mergeTextFormatting(base.rPr, override.rPr);
 	if (mergedRPr) merged.rPr = mergedRPr;
+	const mergedPPr = mergeParagraphFormatting(base.pPr, override.pPr);
+	if (mergedPPr) merged.pPr = mergedPPr;
 	return merged;
 }
 function hasDirectRunFormatting(formatting) {
@@ -725,7 +748,7 @@ function convertTableCell(cell, styleResolver, isHeader, gridWidthPercent, condi
 	if (preserveVMergeRestart) attrs._preserveVMergeRestart = true;
 	if (vMergeContinuationCells && vMergeContinuationCells.length > 0) attrs._docxVMergeContinuationCells = vMergeContinuationCells;
 	const contentNodes = [];
-	for (const content of cell.content) if (content.type === "paragraph") contentNodes.push(convertParagraph(content, styleResolver, void 0, conditionalStyle?.rPr));
+	for (const content of cell.content) if (content.type === "paragraph") contentNodes.push(convertParagraph(content, styleResolver, void 0, conditionalStyle?.rPr, conditionalStyle?.pPr));
 	else contentNodes.push(convertTable(content, styleResolver, theme));
 	if (contentNodes.length === 0) contentNodes.push(schema.node("paragraph", {}, []));
 	const nodeType = isHeader ? "tableHeader" : "tableCell";

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

@@ -0,0 +1,3 @@
+import { ExtensionManager } from "./ExtensionManager.js";
+import { StarterKitOptions, createStarterKit } from "./StarterKit.js";
+export { ExtensionManager, type StarterKitOptions, createStarterKit };

package/dist/prosemirror/extensions/index.js

@@ -0,0 +1,3 @@
+import { ExtensionManager } from "./ExtensionManager.js";
+import { createStarterKit } from "./StarterKit.js";
+export { ExtensionManager, createStarterKit };

package/dist/prosemirror/imageCommit.d.ts

@@ -0,0 +1,42 @@
+import { Node } from "prosemirror-model";
+import { EditorView } from "prosemirror-view";
+
+//#region src/prosemirror/imageCommit.d.ts
+/**
+ * An image resize handle: the 4 corners ('nw'/'ne'/'se'/'sw') resize both axes
+ * and keep the aspect ratio; the 4 edge midpoints ('n'/'s'/'e'/'w') resize a
+ * single axis so the user can deliberately stretch the image (break aspect).
+ */
+type ImageResizeHandle = "nw" | "ne" | "se" | "sw" | "n" | "s" | "e" | "w";
+/**
+ * New image dimensions for a resize drag, shared by the React and Vue overlays
+ * (issue #266). Corner handles drive both axes (aspect-locked unless
+ * `lockAspect` is false, e.g. Shift held); edge handles drive one axis and
+ * never lock. The non-driven axis is returned unchanged. Driven axes are
+ * clamped to a sane pixel range.
+ */
+declare function calculateResizedImageDimensions(handle: ImageResizeHandle, deltaX: number, deltaY: number, startWidth: number, startHeight: number, lockAspect: boolean): {
+  width: number;
+  height: number;
+};
+/** True when the image is floating (anchored) rather than inline. */
+declare function isFloatingImage(node: Node): boolean;
+/**
+ * Resize commit: set the image node's `width`/`height`. Returns `pmPos` to
+ * re-select, or null if the position no longer holds an image.
+ */
+declare function commitImageResize(view: EditorView, pmPos: number, newWidth: number, newHeight: number): number | null;
+/**
+ * Floating drag commit: rewrite the anchor's margin-relative `position`
+ * offsets (in EMU) so the image lands at the drop point while staying
+ * floating. Returns `pmPos` to re-select, or null on no-op / failure.
+ */
+declare function commitImageFloatMove(view: EditorView, pmPos: number, hOffsetEmu: number, vOffsetEmu: number): number | null;
+/**
+ * Inline drag commit: move the image node to `dropPos` via a delete + insert
+ * pair. Returns the PM position to re-select, or null when the drop is a
+ * no-op (same slot) or fails.
+ */
+declare function commitImageInlineMove(view: EditorView, pmPos: number, dropPos: number): number | null;
+//#endregion
+export { ImageResizeHandle, calculateResizedImageDimensions, commitImageFloatMove, commitImageInlineMove, commitImageResize, isFloatingImage };