phormat 0.0.5

package/dist/editor/blocks/EditableTableCell.svelte

@@ -0,0 +1,89 @@
+<script lang="ts">
+	import EditableInlineSurface from './EditableInlineSurface.svelte';
+	import type { MarkdownEditor } from '../MarkdownEditor.svelte';
+	import type { EditorBlock, InlineNode, TableBlockData } from '../model/types';
+	import {
+		navigateTableCell,
+		tableCellDisplayPlain,
+		tableCellModelInlines
+	} from '../block-specs/table/edit';
+	import type { TableCellAlign } from '../block-specs/table/types';
+	import Icon from '@iconify/svelte';
+
+	let {
+		editor,
+		block,
+		blockIndex,
+		row,
+		col,
+		align,
+		header = false
+	}: {
+		editor: MarkdownEditor;
+		block: EditorBlock;
+		blockIndex: number;
+		row: number;
+		col: number;
+		align: TableCellAlign;
+		header?: boolean;
+	} = $props();
+
+	const tableCell = $derived({ row, col });
+	const data = $derived(block.data as TableBlockData);
+	const displayPlain = $derived(tableCellDisplayPlain(data, row, col));
+	const modelInlines = $derived(tableCellModelInlines(data, row, col));
+	const isActiveCell = $derived(
+		editor.documentSelection?.blockId === block.id &&
+			editor.documentSelection?.tableCell?.row === row &&
+			editor.documentSelection?.tableCell?.col === col
+	);
+
+	const alignClass: Record<NonNullable<TableCellAlign>, string> = {
+		left: 'text-left',
+		center: 'text-center',
+		right: 'text-right'
+	};
+
+	function cellAlignClass(a: TableCellAlign): string {
+		return a ? alignClass[a] : 'text-left';
+	}
+
+	function commitDraft(inlines: InlineNode[], plainCaret: number) {
+		editor.commitTableCellInlineDraftAt(blockIndex, row, col, inlines, plainCaret);
+	}
+
+	function onTableCellNavigate(
+		direction: 'next' | 'prev' | 'down' | 'up',
+		inlines: InlineNode[],
+		plainCaret: number
+	) {
+		const next = navigateTableCell(data, row, col, direction);
+		if (!next) return;
+		editor.navigateTableCellAt(blockIndex, { row, col }, next, inlines, plainCaret);
+	}
+</script>
+
+<svelte:element
+	this={header ? 'th' : 'td'}
+	class="border-r border-border-muted px-2 py-1 align-top relative {cellAlignClass(align)} {header
+		? 'bg-surface-base/60 font-semibold'
+		: ''} {isActiveCell ? 'bg-surface-overlay/20' : ''}"
+>
+	<EditableInlineSurface
+		{editor}
+		blockId={block.id}
+		{modelInlines}
+		{displayPlain}
+		{tableCell}
+		singleLine
+		suppressEnterCommand
+		supportsInlineWrap
+		ariaLabel={header ? `Table header column ${col + 1}` : `Table cell row ${row + 1} column ${col + 1}`}
+		ariaMultiline={false}
+		class="min-h-5 py-0 text-sm leading-snug"
+		onFocus={() => editor.beginPlainEditSession(blockIndex)}
+		onBlur={() => editor.commitPlainEditSession()}
+		onCommit={commitDraft}
+		{onTableCellNavigate}
+	/>
+</svelte:element>

package/dist/editor/blocks/EditableTableCell.svelte.d.ts

@@ -0,0 +1,15 @@
+import type { MarkdownEditor } from '../MarkdownEditor.svelte';
+import type { EditorBlock } from '../model/types';
+import type { TableCellAlign } from '../block-specs/table/types';
+type $$ComponentProps = {
+    editor: MarkdownEditor;
+    block: EditorBlock;
+    blockIndex: number;
+    row: number;
+    col: number;
+    align: TableCellAlign;
+    header?: boolean;
+};
+declare const EditableTableCell: import("svelte").Component<$$ComponentProps, {}, "">;
+type EditableTableCell = ReturnType<typeof EditableTableCell>;
+export default EditableTableCell;

package/dist/editor/blocks/EditableToggle.svelte

@@ -0,0 +1,94 @@
+<script lang="ts">
+	import type { MarkdownEditor } from '../MarkdownEditor.svelte';
+	import type { EditorBlock } from '../model/types';
+	import { serializeEditorBlock } from '../model';
+	import { toggleRenderer } from '../block-specs/toggle/ToggleRenderer.svelte';
+	import type { ToggleBlock } from '../block-specs/toggle/types';
+
+	let {
+		editor,
+		blockIndex,
+		block
+	}: {
+		editor: MarkdownEditor;
+		blockIndex: number;
+		block: EditorBlock;
+	} = $props();
+
+	let root = $state.raw<HTMLDivElement | null>(null);
+	let title = $state('');
+	let body = $state('');
+
+	function readToggle(): ToggleBlock {
+		return block.data as ToggleBlock;
+	}
+
+	function syncFromBlock() {
+		const d = readToggle();
+		title = d.title;
+		body = d.body;
+	}
+
+	$effect(() => {
+		void block.id;
+		void editor.document.source;
+		const el = root;
+		if (el?.contains(document.activeElement)) return;
+		syncFromBlock();
+	});
+
+	function focusLeavingComponent(ev: FocusEvent) {
+		const next = ev.relatedTarget as Node | null;
+		if (next && root?.contains(next)) return;
+		commit();
+	}
+
+	function commit() {
+		const prev = readToggle();
+		const data: ToggleBlock = {
+			title: title.trim(),
+			body,
+			startLineIndex: prev.startLineIndex
+		};
+		const synthetic: EditorBlock = { ...block, data };
+		editor.replaceBlockMarkdown(blockIndex, serializeEditorBlock(synthetic));
+	}
+
+	const previewToggle = $derived.by((): ToggleBlock => {
+		const prev = readToggle();
+		return {
+			title: title.trim(),
+			body,
+			startLineIndex: prev.startLineIndex
+		};
+	});
+</script>
+
+<div
+	class="rounded-md border border-border-muted/80 bg-surface-base/20 p-2"
+	bind:this={root}
+	onfocusout={focusLeavingComponent}
+>
+	<p class="mb-2 text-xs text-txt-tertiary">Toggle</p>
+	<label class="mb-2 block text-xs text-txt-tertiary" for="toggle-title-{blockIndex}"> Title </label>
+	<input
+		id="toggle-title-{blockIndex}"
+		type="text"
+		class="mb-3 w-full rounded border border-border-default bg-surface-sunken px-2 py-1.5 text-sm text-txt-primary outline-none focus-visible:border-focus-ring"
+		bind:value={title}
+	/>
+	<label class="mb-2 block text-xs text-txt-tertiary" for="toggle-body-{blockIndex}">
+		Body (Markdown lines between <code class="text-txt-tertiary">+++</code> delimiters)
+	</label>
+	<textarea
+		id="toggle-body-{blockIndex}"
+		draggable="false"
+		class="mb-3 min-h-[6rem] w-full resize-y rounded-md border border-border-default bg-surface-sunken p-3 font-mono text-sm leading-relaxed text-txt-primary ring-0 outline-none focus-visible:border-focus-ring"
+		spellcheck={false}
+		bind:value={body}
+	></textarea>
+	<p class="mb-1 text-xs text-txt-tertiary">Preview</p>
+	<div class="rounded border border-border-muted/60 bg-surface-sunken/40 p-2">
+		{@render toggleRenderer(previewToggle)}
+	</div>
+</div>

package/dist/editor/blocks/EditableToggle.svelte.d.ts

@@ -0,0 +1,10 @@
+import type { MarkdownEditor } from '../MarkdownEditor.svelte';
+import type { EditorBlock } from '../model/types';
+type $$ComponentProps = {
+    editor: MarkdownEditor;
+    blockIndex: number;
+    block: EditorBlock;
+};
+declare const EditableToggle: import("svelte").Component<$$ComponentProps, {}, "">;
+type EditableToggle = ReturnType<typeof EditableToggle>;
+export default EditableToggle;

package/dist/editor/commandMenu.d.ts

@@ -0,0 +1,18 @@
+import type { MenuItem } from 'phoundry-ui';
+import type { ContextMenuAPI } from 'phoundry-ui';
+import { type EditorCommandContext, type EditorCommandSurface } from './commandRegistry.js';
+export declare function editorCommandsToMenuItems(surface: EditorCommandSurface, ctx: EditorCommandContext, onCommand?: () => void): MenuItem[];
+export type OpenEditorCommandMenuOptions = {
+    surface: EditorCommandSurface;
+    ctx: EditorCommandContext;
+    x: number;
+    y: number;
+    ariaLabel: string;
+    onOpen?: () => void;
+    onClose?: (detail: {
+        commandSelected: boolean;
+    }) => void;
+};
+export declare function openEditorCommandMenu(api: ContextMenuAPI, opts: OpenEditorCommandMenuOptions): void;
+/** Reset scroll listener state — for tests only. */
+export declare function resetEditorCommandMenuScrollListenerForTests(): void;

package/dist/editor/commandMenu.js

@@ -0,0 +1,83 @@
+import { commandsByGroup } from './commandRegistry.js';
+function runCommand(cmd, ctx) {
+    const blockIndex = ctx.editor.document.blocks.findIndex((b) => b.id === ctx.blockId);
+    if (blockIndex < 0)
+        return;
+    cmd.run({ ...ctx, blockIndex });
+}
+export function editorCommandsToMenuItems(surface, ctx, onCommand) {
+    const grouped = commandsByGroup(surface, ctx);
+    if (surface === 'slash') {
+        const items = [{ type: 'label', label: 'Blocks' }];
+        for (const { commands } of grouped) {
+            for (const cmd of commands) {
+                items.push({
+                    type: 'action',
+                    id: cmd.id,
+                    label: cmd.label,
+                    disabled: !cmd.isEnabled(ctx),
+                    action: () => {
+                        onCommand?.();
+                        runCommand(cmd, ctx);
+                    }
+                });
+            }
+        }
+        return items;
+    }
+    const items = [];
+    for (const [gi, { group, commands }] of grouped.entries()) {
+        if (gi > 0)
+            items.push({ type: 'separator' });
+        if (group === 'turnInto') {
+            items.push({ type: 'label', label: 'Turn into' });
+        }
+        for (const cmd of commands) {
+            items.push({
+                type: 'action',
+                id: cmd.id,
+                label: cmd.label,
+                disabled: !cmd.isEnabled(ctx),
+                shortcut: cmd.shortcut?.ariaKeyShortcuts,
+                action: () => {
+                    onCommand?.();
+                    runCommand(cmd, ctx);
+                }
+            });
+        }
+    }
+    return items;
+}
+let scrollCleanup = null;
+function cleanupScrollListener() {
+    scrollCleanup?.();
+    scrollCleanup = null;
+}
+export function openEditorCommandMenu(api, opts) {
+    cleanupScrollListener();
+    if (api.state) {
+        api.close();
+    }
+    let commandSelected = false;
+    opts.onOpen?.();
+    function onCloseWrapper() {
+        cleanupScrollListener();
+        opts.onClose?.({ commandSelected });
+        commandSelected = false;
+    }
+    function onScroll() {
+        api.close();
+    }
+    window.addEventListener('scroll', onScroll, true);
+    scrollCleanup = () => window.removeEventListener('scroll', onScroll, true);
+    api.open(() => editorCommandsToMenuItems(opts.surface, opts.ctx, () => {
+        commandSelected = true;
+    }), opts.x, opts.y, {
+        ariaLabel: opts.ariaLabel,
+        onClose: onCloseWrapper
+    });
+}
+/** Reset scroll listener state — for tests only. */
+export function resetEditorCommandMenuScrollListenerForTests() {
+    cleanupScrollListener();
+}

package/dist/editor/commandRegistry.d.ts

@@ -0,0 +1,48 @@
+import type { MarkdownEditor } from './MarkdownEditor.svelte';
+import type { EditorBlockType } from './model/types';
+export type EditorCommandSurface = 'slash' | 'blockMenu';
+export type SlashKind = 'paragraph' | 'heading';
+export type EditorCommandContext = {
+    editor: MarkdownEditor;
+    blockIndex: number;
+    blockId: string;
+    blockType: EditorBlockType;
+    blockSynthetic: boolean;
+    canMoveUp: boolean;
+    canMoveDown: boolean;
+    /** Leaf row id when the command targets a nested row inside a container block. */
+    nestedRowBlockId?: string;
+    /** Leaf row type for nested command filtering and inline marks. */
+    nestedRowBlockType?: EditorBlockType;
+    /** Set when resolving slash-visible commands */
+    slashKind?: SlashKind;
+};
+export type EditorCommandShortcut = {
+    /** e.g. Alt+Shift+ArrowUp for aria-keyshortcuts */
+    ariaKeyShortcuts: string;
+};
+export type EditorCommand = {
+    id: string;
+    label: string;
+    /** Logical section for UI separators */
+    group: 'structure' | 'turnInto' | 'inline';
+    surfaces: EditorCommandSurface[];
+    /** If set, command appears only for these block types (block menu). Slash ignores blockType when slashKind matches. */
+    blockTypes?: EditorBlockType[];
+    /** When true, command appears only on nested row chrome (not top-level block chrome). */
+    nestedRowOnly?: boolean;
+    /** Slash palette: limit by editable surface kind */
+    slashKinds?: SlashKind[];
+    isEnabled: (ctx: EditorCommandContext) => boolean;
+    run: (ctx: EditorCommandContext) => void;
+    shortcut?: EditorCommandShortcut;
+};
+/** Structural and shared inline commands (block-specific commands come from BlockSpec registry). */
+export declare const editorCommands: EditorCommand[];
+export type EditorCommandId = (typeof editorCommands)[number]['id'];
+export declare function getCommandsForSurface(surface: EditorCommandSurface, ctx: EditorCommandContext): EditorCommand[];
+export type CommandGroupEntry = {
+    group: EditorCommand['group'];
+    commands: EditorCommand[];
+};
+export declare function commandsByGroup(surface: EditorCommandSurface, ctx: EditorCommandContext): CommandGroupEntry[];

package/dist/editor/commandRegistry.js

@@ -0,0 +1,133 @@
+import { registeredBlockSpecs } from './block-specs/registry';
+function inlinePlainSelectionOk(ctx) {
+    if (ctx.blockSynthetic)
+        return false;
+    const type = ctx.nestedRowBlockType ?? ctx.blockType;
+    if (type !== 'paragraph' && type !== 'heading' && type !== 'listItem')
+        return false;
+    if (ctx.nestedRowBlockId) {
+        const r = ctx.editor.getDocumentSelectionPlain(ctx.nestedRowBlockId);
+        return r !== null && r.start !== r.end;
+    }
+    const r = ctx.editor.getInlinePlainFocus(ctx.blockIndex);
+    return r !== null && r.start !== r.end;
+}
+function inlineCmd(id, label, kind, linkHref) {
+    return {
+        id,
+        label,
+        group: 'inline',
+        surfaces: ['blockMenu'],
+        blockTypes: ['paragraph', 'heading', 'listItem'],
+        isEnabled: (ctx) => inlinePlainSelectionOk(ctx),
+        run: (ctx) => {
+            if (ctx.nestedRowBlockId) {
+                const r = ctx.editor.getDocumentSelectionPlain(ctx.nestedRowBlockId);
+                if (!r)
+                    return;
+                ctx.editor.applyInlineWrapOnNestedRow(ctx.blockIndex, ctx.nestedRowBlockId, r.start, r.end, kind, linkHref);
+                return;
+            }
+            const r = ctx.editor.getInlinePlainFocus(ctx.blockIndex);
+            if (!r)
+                return;
+            ctx.editor.applyInlineWrapAt(ctx.blockIndex, r.start, r.end, kind, linkHref);
+        }
+    };
+}
+const structuralAndInlineCommands = [
+    {
+        id: 'duplicateBlock',
+        label: 'Duplicate',
+        group: 'structure',
+        surfaces: ['blockMenu'],
+        isEnabled: (ctx) => !ctx.nestedRowBlockId && !ctx.blockSynthetic,
+        run: (ctx) => {
+            ctx.editor.duplicateBlockAt(ctx.blockIndex);
+        }
+    },
+    {
+        id: 'deleteBlock',
+        label: 'Delete',
+        group: 'structure',
+        surfaces: ['blockMenu'],
+        isEnabled: (ctx) => !ctx.nestedRowBlockId,
+        run: (ctx) => {
+            ctx.editor.deleteBlockAt(ctx.blockIndex);
+        }
+    },
+    {
+        id: 'moveBlockUp',
+        label: 'Move up',
+        group: 'structure',
+        surfaces: ['blockMenu'],
+        isEnabled: (ctx) => !ctx.nestedRowBlockId && ctx.canMoveUp && !ctx.blockSynthetic,
+        run: (ctx) => {
+            ctx.editor.moveBlockUpAt(ctx.blockIndex);
+        },
+        shortcut: { ariaKeyShortcuts: 'Alt+Shift+ArrowUp' }
+    },
+    {
+        id: 'moveBlockDown',
+        label: 'Move down',
+        group: 'structure',
+        surfaces: ['blockMenu'],
+        isEnabled: (ctx) => !ctx.nestedRowBlockId && ctx.canMoveDown && !ctx.blockSynthetic,
+        run: (ctx) => {
+            ctx.editor.moveBlockDownAt(ctx.blockIndex);
+        },
+        shortcut: { ariaKeyShortcuts: 'Alt+Shift+ArrowDown' }
+    },
+    inlineCmd('inlineBold', 'Bold', 'strong'),
+    inlineCmd('inlineItalic', 'Italic', 'emphasis'),
+    inlineCmd('inlineCode', 'Code', 'code'),
+    inlineCmd('inlineLink', 'Link', 'link', ''),
+    inlineCmd('inlineStrikethrough', 'Strikethrough', 'strikethrough'),
+    inlineCmd('inlineHighlight', 'Highlight', 'highlight')
+];
+/** Structural and shared inline commands (block-specific commands come from BlockSpec registry). */
+export const editorCommands = structuralAndInlineCommands;
+function allEditorCommands() {
+    return [
+        ...structuralAndInlineCommands,
+        ...registeredBlockSpecs().flatMap((spec) => spec.commands)
+    ];
+}
+const topLevelStructuralCommandIds = new Set([
+    'duplicateBlock',
+    'deleteBlock',
+    'moveBlockUp',
+    'moveBlockDown'
+]);
+export function getCommandsForSurface(surface, ctx) {
+    return allEditorCommands().filter((cmd) => {
+        if (!cmd.surfaces.includes(surface))
+            return false;
+        if (ctx.nestedRowBlockId && topLevelStructuralCommandIds.has(cmd.id))
+            return false;
+        if (cmd.nestedRowOnly && !ctx.nestedRowBlockId)
+            return false;
+        const typeForFilter = ctx.nestedRowBlockType ?? ctx.blockType;
+        if (cmd.blockTypes && !cmd.blockTypes.includes(typeForFilter))
+            return false;
+        if (surface === 'slash' && cmd.slashKinds) {
+            const k = ctx.slashKind;
+            if (!k || !cmd.slashKinds.includes(k))
+                return false;
+        }
+        return true;
+    });
+}
+export function commandsByGroup(surface, ctx) {
+    const list = getCommandsForSurface(surface, ctx);
+    const order = ['structure', 'turnInto', 'inline'];
+    const map = new Map();
+    for (const g of order)
+        map.set(g, []);
+    for (const cmd of list) {
+        map.get(cmd.group).push(cmd);
+    }
+    return order
+        .map((group) => ({ group, commands: map.get(group) }))
+        .filter((e) => e.commands.length > 0);
+}

package/dist/editor/context/assetBaseUrl.d.ts

@@ -0,0 +1,6 @@
+export type AssetBaseUrlContext = {
+    current: string | undefined;
+};
+export declare function setAssetBaseUrlContext(ctx: AssetBaseUrlContext): void;
+/** Safe href for DOM display; resolves relative paths when an asset base URL is set. */
+export declare function hrefForDisplay(href: string): string | null;

package/dist/editor/context/assetBaseUrl.js

@@ -0,0 +1,20 @@
+import { getContext, setContext } from 'svelte';
+import { safeHref } from '../plugins/links-images/parse-links-images.js';
+import { resolveAssetUrlForDom } from '../plugins/links-images/resolve-asset-url.js';
+const ASSET_BASE_URL_KEY = Symbol('phormat-asset-base-url');
+export function setAssetBaseUrlContext(ctx) {
+    setContext(ASSET_BASE_URL_KEY, ctx);
+}
+function getAssetBaseUrlContext() {
+    return getContext(ASSET_BASE_URL_KEY)?.current;
+}
+/** Safe href for DOM display; resolves relative paths when an asset base URL is set. */
+export function hrefForDisplay(href) {
+    const safe = safeHref(href);
+    if (!safe)
+        return null;
+    const base = getAssetBaseUrlContext();
+    if (!base)
+        return safe;
+    return resolveAssetUrlForDom(safe, base);
+}

package/dist/editor/dom/editorHistoryKeydown.d.ts

@@ -0,0 +1,6 @@
+import type { MarkdownEditor } from '../MarkdownEditor.svelte';
+/**
+ * Intercept editor undo/redo shortcuts on plain edit surfaces.
+ * Returns true when the event was handled.
+ */
+export declare function handleEditorUndoRedoKeydown(editor: MarkdownEditor, e: KeyboardEvent): boolean;

package/dist/editor/dom/editorHistoryKeydown.js

@@ -0,0 +1,31 @@
+function isMacPlatform() {
+    if (typeof navigator === 'undefined')
+        return false;
+    return /mac/i.test(navigator.platform);
+}
+/**
+ * Intercept editor undo/redo shortcuts on plain edit surfaces.
+ * Returns true when the event was handled.
+ */
+export function handleEditorUndoRedoKeydown(editor, e) {
+    if ((!e.metaKey && !e.ctrlKey) || e.altKey)
+        return false;
+    const key = e.key.toLowerCase();
+    if (key === 'z' && !e.shiftKey) {
+        e.preventDefault();
+        editor.undo();
+        return true;
+    }
+    const isMac = isMacPlatform();
+    if (key === 'z' && e.shiftKey) {
+        e.preventDefault();
+        editor.redo();
+        return true;
+    }
+    if (key === 'y' && !e.shiftKey && !isMac) {
+        e.preventDefault();
+        editor.redo();
+        return true;
+    }
+    return false;
+}

package/dist/editor/dom/plainEnterKeydown.d.ts

@@ -0,0 +1,12 @@
+import type { MarkdownEditor } from '../MarkdownEditor.svelte';
+export type PlainEnterSurface = {
+    blockId: string;
+    getPlainText: () => string;
+    getPlainOffset: () => number;
+};
+/** Shared plain Enter handler — Shift+Enter stays deferred (preventDefault, no-op). */
+export declare function handlePlainEnterKeydown(editor: MarkdownEditor, e: KeyboardEvent, surface: PlainEnterSurface): boolean;
+export declare function plainEnterFromContentEditable(editor: MarkdownEditor, e: KeyboardEvent, blockId: string, node: HTMLDivElement): boolean;
+/** Reinforce keydown Enter handling — handle `insertParagraph` before the browser mutates. */
+export declare function plainEnterFromBeforeInput(editor: MarkdownEditor, e: InputEvent, blockId: string, node: HTMLDivElement): boolean;
+export declare function plainEnterFromInput(editor: MarkdownEditor, e: KeyboardEvent, blockId: string, input: HTMLInputElement): boolean;

package/dist/editor/dom/plainEnterKeydown.js

@@ -0,0 +1,53 @@
+import { plainOffsets } from './plaintextCaret';
+/** Shared plain Enter handler — Shift+Enter stays deferred (preventDefault, no-op). */
+export function handlePlainEnterKeydown(editor, e, surface) {
+    if (e.key === 'Enter' && e.shiftKey) {
+        e.preventDefault();
+        return true;
+    }
+    if (e.key === 'Enter' && !e.shiftKey) {
+        e.preventDefault();
+        if (editor.shouldSuppressPlainInputForBlock(surface.blockId)) {
+            return true;
+        }
+        editor.enterAt({
+            blockId: surface.blockId,
+            plainOffset: surface.getPlainOffset(),
+            plainText: surface.getPlainText()
+        });
+        return true;
+    }
+    return false;
+}
+export function plainEnterFromContentEditable(editor, e, blockId, node) {
+    return handlePlainEnterKeydown(editor, e, {
+        blockId,
+        getPlainText: () => node.textContent ?? '',
+        getPlainOffset: () => {
+            const { start, end } = plainOffsets(node);
+            return Math.min(start, end);
+        }
+    });
+}
+/** Reinforce keydown Enter handling — handle `insertParagraph` before the browser mutates. */
+export function plainEnterFromBeforeInput(editor, e, blockId, node) {
+    if (e.inputType !== 'insertParagraph')
+        return false;
+    e.preventDefault();
+    if (editor.shouldSuppressPlainInputForBlock(blockId))
+        return true;
+    const { start, end } = plainOffsets(node);
+    editor.enterAt({
+        blockId,
+        plainOffset: Math.min(start, end),
+        plainText: node.textContent ?? ''
+    });
+    return true;
+}
+export function plainEnterFromInput(editor, e, blockId, input) {
+    return handlePlainEnterKeydown(editor, e, {
+        blockId,
+        getPlainText: () => input.value,
+        getPlainOffset: () => input.selectionStart ?? 0
+    });
+}

package/dist/editor/dom/plaintextCaret.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Map DOM Selection inside a `contenteditable="plaintext-only"` root to plain-text offsets.
+ * Indices are UTF-16 code units, aligned with {@link EditorSelection} and {@link DOMString}.
+ */
+export declare function plainOffsets(root: HTMLElement): {
+    start: number;
+    end: number;
+};
+/** Move caret to a plain offset inside `root` (collapsed selection). */
+export declare function setCaretPlainOffset(root: HTMLElement, offset: number): void;
+/** True when `offset` is the start of a logical line in `plain` (after `\n` or at 0). */
+export declare function offsetAtLineStart(plain: string, offset: number): boolean;