@stll/folio-core 0.0.1-placeholder.0 → 0.1.1

package/dist/prosemirror/extensions/create.js

@@ -0,0 +1,129 @@
+import { Priority } from "./types.js";
+//#region src/prosemirror/extensions/create.ts
+/**
+* Extension Factory Functions
+*
+* Creates extension instances from definitions.
+* Each factory returns a function that accepts options and returns an extension instance.
+*/
+const copyOptions = (options) => ({ ...options });
+const mergeDefaultOptions = (defaultOptions, options) => ({
+	...defaultOptions,
+	...options
+});
+const extensionHasDefaultOptions = (def) => def.defaultOptions !== void 0;
+const nodeExtensionHasDefaultOptions = (def) => def.defaultOptions !== void 0;
+const markExtensionHasDefaultOptions = (def) => def.defaultOptions !== void 0;
+/**
+* Create a generic extension (plugins, commands, keymaps — no schema contribution)
+*/
+function createExtension(def) {
+	return (options) => {
+		if (extensionHasDefaultOptions(def)) {
+			const mergedOptions = mergeDefaultOptions(def.defaultOptions, options);
+			return {
+				type: "extension",
+				config: {
+					name: def.name,
+					priority: def.priority ?? Priority.Default,
+					options: copyOptions(mergedOptions)
+				},
+				onSchemaReady(ctx) {
+					return def.onSchemaReady(ctx, mergedOptions);
+				}
+			};
+		}
+		const mergedOptions = options ?? {};
+		return {
+			type: "extension",
+			config: {
+				name: def.name,
+				priority: def.priority ?? Priority.Default,
+				options: copyOptions(mergedOptions)
+			},
+			onSchemaReady(ctx) {
+				return def.onSchemaReady(ctx, mergedOptions);
+			}
+		};
+	};
+}
+/**
+* Create a node extension (contributes a NodeSpec to the schema)
+*/
+function createNodeExtension(def) {
+	return (options) => {
+		if (nodeExtensionHasDefaultOptions(def)) {
+			const mergedOptions = mergeDefaultOptions(def.defaultOptions, options);
+			const nodeSpec = typeof def.nodeSpec === "function" ? def.nodeSpec(mergedOptions) : def.nodeSpec;
+			return {
+				type: "node",
+				config: {
+					name: def.name,
+					priority: def.priority ?? Priority.Default,
+					options: copyOptions(mergedOptions),
+					schemaNodeName: def.schemaNodeName,
+					nodeSpec
+				},
+				onSchemaReady(ctx) {
+					return def.onSchemaReady?.(ctx, mergedOptions) ?? {};
+				}
+			};
+		}
+		const mergedOptions = options ?? {};
+		const nodeSpec = typeof def.nodeSpec === "function" ? def.nodeSpec(mergedOptions) : def.nodeSpec;
+		return {
+			type: "node",
+			config: {
+				name: def.name,
+				priority: def.priority ?? Priority.Default,
+				options: copyOptions(mergedOptions),
+				schemaNodeName: def.schemaNodeName,
+				nodeSpec
+			},
+			onSchemaReady(ctx) {
+				return def.onSchemaReady?.(ctx, mergedOptions) ?? {};
+			}
+		};
+	};
+}
+/**
+* Create a mark extension (contributes a MarkSpec to the schema)
+*/
+function createMarkExtension(def) {
+	return (options) => {
+		if (markExtensionHasDefaultOptions(def)) {
+			const mergedOptions = mergeDefaultOptions(def.defaultOptions, options);
+			const markSpec = typeof def.markSpec === "function" ? def.markSpec(mergedOptions) : def.markSpec;
+			return {
+				type: "mark",
+				config: {
+					name: def.name,
+					priority: def.priority ?? Priority.Default,
+					options: copyOptions(mergedOptions),
+					schemaMarkName: def.schemaMarkName,
+					markSpec
+				},
+				onSchemaReady(ctx) {
+					return def.onSchemaReady?.(ctx, mergedOptions) ?? {};
+				}
+			};
+		}
+		const mergedOptions = options ?? {};
+		const markSpec = typeof def.markSpec === "function" ? def.markSpec(mergedOptions) : def.markSpec;
+		return {
+			type: "mark",
+			config: {
+				name: def.name,
+				priority: def.priority ?? Priority.Default,
+				options: copyOptions(mergedOptions),
+				schemaMarkName: def.schemaMarkName,
+				markSpec
+			},
+			onSchemaReady(ctx) {
+				return def.onSchemaReady?.(ctx, mergedOptions) ?? {};
+			}
+		};
+	};
+}
+//#endregion
+export { createExtension, createMarkExtension, createNodeExtension };

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

@@ -0,0 +1,23 @@
+import { Extension } from "../types.js";
+import { EditorState, PluginKey } from "prosemirror-state";
+
+//#region src/prosemirror/extensions/features/AutoBidiDetectionExtension.d.ts
+declare const autoBidiDetectionKey: PluginKey<any>;
+/**
+ * Imperatively apply auto-bidi detection to a freshly built state (initial
+ * load: Markdown import, DOCX import, template). `appendTransaction` does not
+ * fire for the initial document, so seeded content needs this pass.
+ *
+ * Like the paraId allocator this is `ignoreTrackedChanges`, so a normalized
+ * paragraph the user never edits is not in `changedParaIds`. Full save (the
+ * default; and the only path for Markdown/template/new docs, which have no
+ * original buffer) serializes the whole PM doc, so the flag is written. The
+ * selective-save path (dark `selectiveSave` flag) intentionally preserves
+ * untouched original paragraphs byte-for-byte, so an imported DOCX whose Arabic
+ * arrived without `w:bidi` and is saved without any edit keeps the original
+ * bytes; editing the paragraph tracks it and the patch then includes `w:bidi`.
+ */
+declare const ensureBaseDirectionInState: (state: EditorState) => EditorState;
+declare const AutoBidiDetectionExtension: (options?: Partial<{}> | undefined) => Extension;
+//#endregion
+export { AutoBidiDetectionExtension, autoBidiDetectionKey, ensureBaseDirectionInState };

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

@@ -0,0 +1,106 @@
+import { detectBaseDirection } from "../../../utils/baseDirection.js";
+import { directionIsAutoManaged } from "../../paragraphDirection.js";
+import { createExtension } from "../create.js";
+import { getTransactionDirtyRange } from "../../../paged-layout/transactionDirtyRange.js";
+import { ignoreTrackedChanges } from "./ParagraphChangeTrackerExtension.js";
+import { Plugin, PluginKey } from "prosemirror-state";
+//#region src/prosemirror/extensions/features/AutoBidiDetectionExtension.ts
+const autoBidiDetectionKey = new PluginKey("autoBidiDetection");
+const paragraphDirectionalText = (node) => {
+	let text = "";
+	node.descendants((child) => {
+		if (child.isText) {
+			if (!child.marks.some((mark) => mark.type.name === "deletion")) text += child.text ?? "";
+		} else if (child.type.name === "field") {
+			const display = child.attrs["displayText"];
+			if (typeof display === "string") text += display;
+		}
+	});
+	return text;
+};
+const evaluateParagraph = (node, pos) => {
+	const current = node.attrs["direction"];
+	if (!directionIsAutoManaged(current)) return null;
+	const wantRtl = detectBaseDirection(paragraphDirectionalText(node)) === "rtl";
+	if (current?.source === "auto" === wantRtl) return null;
+	const desired = wantRtl ? { source: "auto" } : null;
+	return {
+		pos,
+		attrs: {
+			...node.attrs,
+			direction: desired
+		}
+	};
+};
+const collectBidiUpdates = (doc) => {
+	const updates = [];
+	doc.descendants((node, pos) => {
+		if (node.type.name !== "paragraph") return;
+		const update = evaluateParagraph(node, pos);
+		if (update) updates.push(update);
+		return false;
+	});
+	return updates;
+};
+const collectBidiUpdatesInRange = (doc, range) => {
+	const from = Math.max(0, Math.min(range.from, doc.content.size));
+	const to = Math.max(from, Math.min(range.to, doc.content.size));
+	const seen = /* @__PURE__ */ new Set();
+	const updates = [];
+	doc.nodesBetween(from, to, (node, pos) => {
+		if (node.type.name === "paragraph" && !seen.has(pos)) {
+			seen.add(pos);
+			const update = evaluateParagraph(node, pos);
+			if (update) updates.push(update);
+		}
+	});
+	return updates;
+};
+const applyBidiUpdates = (state, updates) => {
+	const tr = state.tr;
+	for (const update of updates) tr.setNodeMarkup(update.pos, void 0, update.attrs);
+	ignoreTrackedChanges(tr);
+	tr.setMeta(autoBidiDetectionKey, "applied");
+	tr.setMeta("addToHistory", false);
+	return tr;
+};
+/**
+* Imperatively apply auto-bidi detection to a freshly built state (initial
+* load: Markdown import, DOCX import, template). `appendTransaction` does not
+* fire for the initial document, so seeded content needs this pass.
+*
+* Like the paraId allocator this is `ignoreTrackedChanges`, so a normalized
+* paragraph the user never edits is not in `changedParaIds`. Full save (the
+* default; and the only path for Markdown/template/new docs, which have no
+* original buffer) serializes the whole PM doc, so the flag is written. The
+* selective-save path (dark `selectiveSave` flag) intentionally preserves
+* untouched original paragraphs byte-for-byte, so an imported DOCX whose Arabic
+* arrived without `w:bidi` and is saved without any edit keeps the original
+* bytes; editing the paragraph tracks it and the patch then includes `w:bidi`.
+*/
+const ensureBaseDirectionInState = (state) => {
+	if (!autoBidiDetectionKey.get(state)) return state;
+	const updates = collectBidiUpdates(state.doc);
+	if (updates.length === 0) return state;
+	return state.apply(applyBidiUpdates(state, updates));
+};
+const createAutoBidiDetectionPlugin = () => new Plugin({
+	key: autoBidiDetectionKey,
+	appendTransaction(transactions, _oldState, newState) {
+		if (!transactions.some((t) => t.docChanged)) return null;
+		const [first, ...rest] = transactions;
+		const range = first && rest.length === 0 ? getTransactionDirtyRange(first) : null;
+		const updates = range ? collectBidiUpdatesInRange(newState.doc, range) : collectBidiUpdates(newState.doc);
+		if (updates.length === 0) return null;
+		return applyBidiUpdates(newState, updates);
+	}
+});
+const AutoBidiDetectionExtension = createExtension({
+	name: "autoBidiDetection",
+	defaultOptions: {},
+	onSchemaReady() {
+		return { plugins: [createAutoBidiDetectionPlugin()] };
+	}
+});
+//#endregion
+export { AutoBidiDetectionExtension, autoBidiDetectionKey, ensureBaseDirectionInState };

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

@@ -0,0 +1,8 @@
+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 };

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

@@ -0,0 +1,172 @@
+import { mergeFontFamily } from "../../../utils/fontFamilyMerge.js";
+import { Priority } from "../types.js";
+import { createExtension } from "../create.js";
+import { paragraphAttrsFromResolvedStyle } from "../../styles/resolvedStyleAttrs.js";
+import { getDocumentStyleResolver } from "../../plugins/documentStyles.js";
+import { textFormattingToMarks } from "../marks/markUtils.js";
+import { baseKeymap, deleteSelection, joinBackward, joinForward, selectAll, selectParentNode, splitBlock } from "prosemirror-commands";
+//#region src/prosemirror/extensions/features/BaseKeymapExtension.ts
+/**
+* Base Keymap Extension — wraps prosemirror-commands baseKeymap
+*
+* Priority: Low (150) — must be the last keymap so other extensions can override keys
+*/
+function chainCommands(...commands) {
+	return (state, dispatch, view) => {
+		for (const cmd of commands) if (cmd(state, dispatch, view)) return true;
+		return false;
+	};
+}
+/**
+* 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 font marks on the new paragraph.
+*
+* splitBlock creates a new paragraph with default attrs (all null),
+* so we must manually copy style-related attrs from the source paragraph.
+* Word does NOT propagate paragraph borders (w:pBdr) on Enter.
+*/
+const INHERITED_PARA_ATTRS = [
+	"defaultTextFormatting",
+	"styleId",
+	"lineSpacing",
+	"lineSpacingRule",
+	"spaceAfter",
+	"spaceBefore",
+	"contextualSpacing"
+];
+/** Mark types that represent style-inherited formatting (font, size, color). */
+const STYLE_MARK_NAMES = /* @__PURE__ */ new Set([
+	"fontFamily",
+	"fontSize",
+	"textColor"
+]);
+/**
+* If `sourcePara`'s style defines a `w:next`, replace the empty `newPara`
+* with that style's resolved attrs and seed stored marks from its run
+* formatting. Returns true when a switch happened (caller should dispatch
+* the transaction as-is), false when the source style has no `w:next` and
+* the caller should fall back to the regular inheritance path.
+*/
+function applyNextParagraphStyle(tr, sourcePara, newPara, resolver) {
+	const nextStyleId = resolver.getNextStyleId(sourcePara.attrs["styleId"]);
+	if (!nextStyleId) return false;
+	const resolved = resolver.resolveParagraphStyle(nextStyleId);
+	const { $from } = tr.selection;
+	tr.setNodeMarkup($from.before(), void 0, {
+		...newPara.attrs,
+		styleId: nextStyleId,
+		...paragraphAttrsFromResolvedStyle(resolved)
+	});
+	tr.setStoredMarks(resolved.runFormatting ? textFormattingToMarks(resolved.runFormatting, tr.doc.type.schema) : []);
+	return true;
+}
+const splitBlockClearBorders = (state, dispatch, view) => {
+	const { $from: preSplitFrom } = state.selection;
+	const sourcePara = preSplitFrom.parent.type.name === "paragraph" ? preSplitFrom.parent : null;
+	const styleMarks = (state.storedMarks || preSplitFrom.marks()).filter((m) => STYLE_MARK_NAMES.has(m.type.name));
+	const splitResult = { tr: null };
+	if (!splitBlock(state, dispatch ? (tr) => {
+		splitResult.tr = tr;
+	} : void 0, view)) return false;
+	if (dispatch && splitResult.tr !== null) {
+		const tr = splitResult.tr;
+		const { $from } = tr.selection;
+		const newPara = $from.parent;
+		if (newPara.type.name === "paragraph") {
+			const resolver = getDocumentStyleResolver(state);
+			if (resolver !== null && sourcePara !== null && newPara.content.size === 0 && applyNextParagraphStyle(tr, sourcePara, newPara, resolver)) {
+				dispatch(tr.scrollIntoView());
+				return true;
+			}
+			const newAttrs = { ...newPara.attrs };
+			let attrsChanged = false;
+			if (sourcePara) for (const key of INHERITED_PARA_ATTRS) {
+				const srcVal = sourcePara.attrs[key];
+				if (srcVal !== null && newAttrs[key] === null) {
+					newAttrs[key] = srcVal;
+					attrsChanged = true;
+				}
+			}
+			if (newAttrs["borders"]) {
+				newAttrs["borders"] = null;
+				attrsChanged = true;
+			}
+			if (attrsChanged) tr.setNodeMarkup($from.before(), void 0, newAttrs);
+			if (newPara.textContent.length === 0) {
+				let effectiveMarks = styleMarks;
+				if (effectiveMarks.length === 0 && sourcePara) {
+					const dtf = sourcePara.attrs["defaultTextFormatting"];
+					if (dtf) effectiveMarks = textFormattingToMarks(dtf, state.schema).filter((m) => STYLE_MARK_NAMES.has(m.type.name));
+				}
+				if (effectiveMarks.length > 0) {
+					const dtf = { ...newAttrs["defaultTextFormatting"] };
+					let dtfChanged = false;
+					for (const m of effectiveMarks) {
+						if (m.type.name === "fontSize" && m.attrs["size"] !== dtf.fontSize) {
+							dtf.fontSize = m.attrs["size"];
+							dtfChanged = true;
+						}
+						if (m.type.name === "fontFamily") {
+							const ascii = m.attrs["ascii"];
+							if (ascii && (!dtf.fontFamily || dtf.fontFamily.ascii !== ascii)) {
+								const nextFontFamily = { ascii };
+								const hAnsi = m.attrs["hAnsi"];
+								if (hAnsi !== void 0) nextFontFamily.hAnsi = hAnsi;
+								dtf.fontFamily = mergeFontFamily(dtf.fontFamily, nextFontFamily);
+								dtfChanged = true;
+							}
+						}
+					}
+					if (dtfChanged) tr.setNodeMarkup($from.before(), void 0, {
+						...newAttrs,
+						defaultTextFormatting: dtf
+					});
+					tr.setStoredMarks(effectiveMarks);
+				}
+			}
+		}
+		dispatch(tr.scrollIntoView());
+	}
+	return true;
+};
+const BaseKeymapExtension = createExtension({
+	name: "baseKeymap",
+	priority: Priority.Low,
+	onSchemaReady(_ctx) {
+		return { keyboardShortcuts: {
+			...baseKeymap,
+			Enter: splitBlockClearBorders,
+			Backspace: chainCommands(deleteSelection, clearIndentOnBackspace, joinBackward),
+			Delete: chainCommands(deleteSelection, joinForward),
+			"Mod-a": selectAll,
+			Escape: selectParentNode
+		} };
+	}
+});
+//#endregion
+export { BaseKeymapExtension, splitBlockClearBorders };

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

@@ -0,0 +1,16 @@
+import { Extension } from "../types.js";
+
+//#region src/prosemirror/extensions/features/BidiShortcutExtension.d.ts
+/**
+ * Bidi Shortcut Extension — Ctrl/Cmd+Left Shift → LTR, Ctrl/Cmd+Right Shift → RTL
+ *
+ * Uses KeyboardEvent.code to distinguish ShiftLeft vs ShiftRight, matching the
+ * standard Google Docs shortcut behavior. The keydown/keyup state machine lives
+ * in {@link createBidiShortcutController}; this module only wires it to the
+ * editor view and dispatches the schema command on keyup.
+ *
+ * Priority: High (50) — should intercept before other keymaps
+ */
+declare const BidiShortcutExtension: (options?: Partial<Record<string, unknown>> | undefined) => Extension;
+//#endregion
+export { BidiShortcutExtension };

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

@@ -0,0 +1,38 @@
+import { Priority } from "../types.js";
+import { createExtension } from "../create.js";
+import { createBidiShortcutController } from "./bidiShortcutController.js";
+import { singletonManager } from "../../schema/index.js";
+import { Plugin } from "prosemirror-state";
+//#region src/prosemirror/extensions/features/BidiShortcutExtension.ts
+/**
+* Bidi Shortcut Extension — Ctrl/Cmd+Left Shift → LTR, Ctrl/Cmd+Right Shift → RTL
+*
+* Uses KeyboardEvent.code to distinguish ShiftLeft vs ShiftRight, matching the
+* standard Google Docs shortcut behavior. The keydown/keyup state machine lives
+* in {@link createBidiShortcutController}; this module only wires it to the
+* editor view and dispatches the schema command on keyup.
+*
+* Priority: High (50) — should intercept before other keymaps
+*/
+const BidiShortcutExtension = createExtension({
+	name: "bidiShortcut",
+	priority: Priority.High,
+	onSchemaReady(_ctx) {
+		const controller = createBidiShortcutController();
+		return { plugins: [new Plugin({ props: {
+			handleKeyDown(_view, event) {
+				controller.handleKeyDown(event);
+				return false;
+			},
+			handleDOMEvents: { keyup(view, event) {
+				const direction = controller.handleKeyUp(event);
+				if (!direction) return false;
+				const cmds = singletonManager.getCommands();
+				(direction === "ltr" ? cmds["setLtr"] : cmds["setRtl"])?.()(view.state, view.dispatch);
+				return false;
+			} }
+		} })] };
+	}
+});
+//#endregion
+export { BidiShortcutExtension };

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

@@ -0,0 +1,16 @@
+import { Extension } from "../types.js";
+
+//#region src/prosemirror/extensions/features/ContentControlWidgetsExtension.d.ts
+/**
+ * Content-Control Widgets Extension — wires the interactive widget plugin
+ * into the editor so clicking inside a typed content control invokes the
+ * appropriate transaction.
+ *
+ * The plugin owns checkbox toggling outright; dropdown / date picker chrome
+ * is delegated to the editor shell via the `onWidgetEvent` callback (the
+ * shell renders the menu / picker and dispatches via `dispatchDropdownPick`
+ * / `dispatchDatePick`).
+ */
+declare const ContentControlWidgetsExtension: (options?: Partial<Record<string, unknown>> | undefined) => Extension;
+//#endregion
+export { ContentControlWidgetsExtension };

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

@@ -0,0 +1,21 @@
+import { createExtension } from "../create.js";
+import { createContentControlWidgetsPlugin } from "../../plugins/contentControlWidgets.js";
+//#region src/prosemirror/extensions/features/ContentControlWidgetsExtension.ts
+/**
+* Content-Control Widgets Extension — wires the interactive widget plugin
+* into the editor so clicking inside a typed content control invokes the
+* appropriate transaction.
+*
+* The plugin owns checkbox toggling outright; dropdown / date picker chrome
+* is delegated to the editor shell via the `onWidgetEvent` callback (the
+* shell renders the menu / picker and dispatches via `dispatchDropdownPick`
+* / `dispatchDatePick`).
+*/
+const ContentControlWidgetsExtension = createExtension({
+	name: "contentControlWidgets",
+	onSchemaReady(_ctx) {
+		return { plugins: [createContentControlWidgetsPlugin()] };
+	}
+});
+//#endregion
+export { ContentControlWidgetsExtension };

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

@@ -0,0 +1,12 @@
+import { Extension } from "../types.js";
+
+//#region src/prosemirror/extensions/features/DropCursorExtension.d.ts
+/**
+ * Drop Cursor Extension — shows a visual indicator when dragging content
+ *
+ * Uses prosemirror-dropcursor to display a cursor line at the drop position
+ * when dragging images or other content within the editor.
+ */
+declare const DropCursorExtension: (options?: Partial<Record<string, unknown>> | undefined) => Extension;
+//#endregion
+export { DropCursorExtension };

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

@@ -0,0 +1,20 @@
+import { createExtension } from "../create.js";
+import { dropCursor } from "prosemirror-dropcursor";
+//#region src/prosemirror/extensions/features/DropCursorExtension.ts
+/**
+* Drop Cursor Extension — shows a visual indicator when dragging content
+*
+* Uses prosemirror-dropcursor to display a cursor line at the drop position
+* when dragging images or other content within the editor.
+*/
+const DropCursorExtension = createExtension({
+	name: "dropCursor",
+	onSchemaReady() {
+		return { plugins: [dropCursor({
+			color: "var(--doc-primary, #4285f4)",
+			width: 2
+		})] };
+	}
+});
+//#endregion
+export { DropCursorExtension };

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

@@ -0,0 +1,8 @@
+import { Extension } from "../types.js";
+import { PluginKey } from "prosemirror-state";
+
+//#region src/prosemirror/extensions/features/EmptyParagraphFormatExtension.d.ts
+declare const emptyParagraphFormatKey: PluginKey<any>;
+declare const EmptyParagraphFormatExtension: (options?: Partial<Record<string, unknown>> | undefined) => Extension;
+//#endregion
+export { EmptyParagraphFormatExtension, emptyParagraphFormatKey };

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

@@ -0,0 +1,44 @@
+import { createExtension } from "../create.js";
+import { textFormattingToMarks } from "../marks/markUtils.js";
+import { Plugin, PluginKey } from "prosemirror-state";
+//#region src/prosemirror/extensions/features/EmptyParagraphFormatExtension.ts
+const emptyParagraphFormatKey = new PluginKey("emptyParagraphFormat");
+/**
+* Run-formatting properties the painter does NOT reproduce from
+* `defaultTextFormatting` on its own (it forwards only font family + size).
+* When an empty paragraph's defaults carry any of these, typed text must
+* acquire real marks or it would render unstyled. Kept in sync with the
+* properties `textFormattingToMarks` can turn into marks — listing one it
+* can't (e.g. allCaps) would gate work that produces nothing.
+*/
+function hasNonFontDefaults(dtf) {
+	return !!(dtf.bold || dtf.italic || dtf.underline || dtf.strike || dtf.doubleStrike || dtf.color || dtf.highlight || dtf.vertAlign || dtf.rtl);
+}
+function createEmptyParagraphFormatPlugin(schema) {
+	return new Plugin({
+		key: emptyParagraphFormatKey,
+		appendTransaction(transactions, _oldState, newState) {
+			if (!transactions.some((t) => t.selectionSet || t.docChanged)) return null;
+			const { selection } = newState;
+			if (!selection.empty) return null;
+			if (newState.storedMarks !== null) return null;
+			const para = selection.$from.parent;
+			if (para.type.name !== "paragraph" || para.content.size !== 0) return null;
+			const dtf = para.attrs["defaultTextFormatting"];
+			if (!dtf || !hasNonFontDefaults(dtf)) return null;
+			const marks = textFormattingToMarks(dtf, schema);
+			if (marks.length === 0) return null;
+			const tr = newState.tr.setStoredMarks(marks);
+			tr.setMeta("addToHistory", false);
+			return tr;
+		}
+	});
+}
+const EmptyParagraphFormatExtension = createExtension({
+	name: "emptyParagraphFormat",
+	onSchemaReady(ctx) {
+		return { plugins: [createEmptyParagraphFormatPlugin(ctx.schema)] };
+	}
+});
+//#endregion
+export { EmptyParagraphFormatExtension, emptyParagraphFormatKey };

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

@@ -0,0 +1,19 @@
+import { Extension } from "../types.js";
+
+//#region src/prosemirror/extensions/features/GapCursorExtension.d.ts
+/**
+ * GapCursor Extension — provides a caret slot before / between / after
+ * isolating block nodes (notably `blockSdt`).
+ *
+ * Without gapcursor, a user cannot place the caret before a doc-starting
+ * SDT, between two adjacent SDTs, or after a doc-final SDT — the
+ * `isolating` boundary makes regular text selections refuse those
+ * positions. The prosemirror-gapcursor plugin paints a thin "gap" caret
+ * at those slots so the document stays fully navigable.
+ *
+ * The plugin also exposes `Backspace` / `Delete` handlers that join the
+ * gap into the neighbour when sensible.
+ */
+declare const GapCursorExtension: (options?: Partial<Record<string, unknown>> | undefined) => Extension;
+//#endregion
+export { GapCursorExtension };

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

@@ -0,0 +1,24 @@
+import { createExtension } from "../create.js";
+import { gapCursor } from "prosemirror-gapcursor";
+//#region src/prosemirror/extensions/features/GapCursorExtension.ts
+/**
+* GapCursor Extension — provides a caret slot before / between / after
+* isolating block nodes (notably `blockSdt`).
+*
+* Without gapcursor, a user cannot place the caret before a doc-starting
+* SDT, between two adjacent SDTs, or after a doc-final SDT — the
+* `isolating` boundary makes regular text selections refuse those
+* positions. The prosemirror-gapcursor plugin paints a thin "gap" caret
+* at those slots so the document stays fully navigable.
+*
+* The plugin also exposes `Backspace` / `Delete` handlers that join the
+* gap into the neighbour when sensible.
+*/
+const GapCursorExtension = createExtension({
+	name: "gapCursor",
+	onSchemaReady(_ctx) {
+		return { plugins: [gapCursor()] };
+	}
+});
+//#endregion
+export { GapCursorExtension };