phormat 0.0.5

package/dist/editor/dom/plaintextCaret.js

@@ -0,0 +1,61 @@
+/**
+ * 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 function plainOffsets(root) {
+    const sel = getSelection();
+    if (!sel?.rangeCount) {
+        const len = root.textContent?.length ?? 0;
+        return { start: len, end: len };
+    }
+    const range = sel.getRangeAt(0);
+    if (!root.contains(range.startContainer)) {
+        const len = root.textContent?.length ?? 0;
+        return { start: len, end: len };
+    }
+    const toOffset = (container, offset) => {
+        const r = document.createRange();
+        r.selectNodeContents(root);
+        r.setEnd(container, offset);
+        return r.toString().length;
+    };
+    return {
+        start: toOffset(range.startContainer, range.startOffset),
+        end: toOffset(range.endContainer, range.endOffset)
+    };
+}
+/** Move caret to a plain offset inside `root` (collapsed selection). */
+export function setCaretPlainOffset(root, offset) {
+    const sel = getSelection();
+    if (!sel)
+        return;
+    const max = root.textContent?.length ?? 0;
+    const o = Math.max(0, Math.min(offset, max));
+    const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+    let remaining = o;
+    let node = walker.nextNode();
+    while (node) {
+        const len = node.textContent?.length ?? 0;
+        if (remaining <= len) {
+            const range = document.createRange();
+            range.setStart(node, remaining);
+            range.collapse(true);
+            sel.removeAllRanges();
+            sel.addRange(range);
+            return;
+        }
+        remaining -= len;
+        node = walker.nextNode();
+    }
+    const range = document.createRange();
+    range.selectNodeContents(root);
+    range.collapse(false);
+    sel.removeAllRanges();
+    sel.addRange(range);
+}
+/** True when `offset` is the start of a logical line in `plain` (after `\n` or at 0). */
+export function offsetAtLineStart(plain, offset) {
+    const lastNl = plain.lastIndexOf('\n', offset - 1);
+    const lineStart = lastNl === -1 ? 0 : lastNl + 1;
+    return offset === lineStart;
+}

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

@@ -0,0 +1,17 @@
+import type { DocumentSelection, TableCellAddress } from '../model/types';
+export type DocumentSelectionFocusBinding = {
+    blockId: string;
+    tableCell?: TableCellAddress;
+    getNode: () => HTMLElement | null;
+    isFocused: () => boolean;
+    setFocused: (focused: boolean) => void;
+    getDisplayPlain: () => string;
+    setLocalPlain: (plain: string) => void;
+    /** When set, resync styled inline DOM instead of `textContent`. */
+    resyncDom?: () => void;
+    setCaret: (node: HTMLElement, offset: number) => void;
+    documentSelection: DocumentSelection | null;
+    takePendingFocus: (blockId: string, tableCell?: TableCellAddress) => boolean;
+};
+/** Apply post-split focus and resync source blocks when selection moves away. */
+export declare function syncDocumentSelectionFocus(binding: DocumentSelectionFocusBinding): void;

package/dist/editor/dom/syncDocumentSelectionFocus.js

@@ -0,0 +1,56 @@
+import { tick } from 'svelte';
+function tableCellMatches(a, b) {
+    if (!a && !b)
+        return true;
+    if (!a || !b)
+        return false;
+    return a.row === b.row && a.col === b.col;
+}
+/** Apply post-split focus and resync source blocks when selection moves away. */
+export function syncDocumentSelectionFocus(binding) {
+    const sel = binding.documentSelection;
+    const node = binding.getNode();
+    if (!node || !sel?.plain)
+        return;
+    const plain = binding.getDisplayPlain();
+    if (sel.blockId === binding.blockId) {
+        if (!tableCellMatches(sel.tableCell, binding.tableCell)) {
+            // Table cells share one block id. A selection in another cell should not
+            // resync this cell's draft; doing so creates a focus/selection update loop.
+            return;
+        }
+        if (binding.takePendingFocus(binding.blockId, binding.tableCell)) {
+            binding.setFocused(true);
+            binding.setLocalPlain(plain);
+            if (binding.resyncDom)
+                binding.resyncDom();
+            else if (node.textContent !== plain)
+                node.textContent = plain;
+            if (document.activeElement !== node)
+                node.focus();
+            void tick().then(() => {
+                const target = binding.getNode();
+                if (!target)
+                    return;
+                if (document.activeElement !== target)
+                    target.focus();
+                binding.setCaret(target, sel.plain.end);
+            });
+            return;
+        }
+        if (plain.length > 0 && (node.textContent ?? '') === '' && !binding.resyncDom) {
+            // Post-split target: model has body text before the surface received input.
+            binding.setLocalPlain(plain);
+            node.textContent = plain;
+            binding.setCaret(node, sel.plain.end);
+        }
+        return;
+    }
+    if (binding.isFocused() && document.activeElement === node && sel.blockId !== binding.blockId) {
+        binding.setLocalPlain(plain);
+        if (binding.resyncDom)
+            binding.resyncDom();
+        else if (node.textContent !== plain)
+            node.textContent = plain;
+    }
+}

package/dist/editor/draftPersistence.d.ts

@@ -0,0 +1,27 @@
+/** Best-effort identity for browser-only reopen (same physical file as last session under typical OS metadata). Not a path or cryptographic id. */
+export declare function fileFingerprint(file: Pick<File, 'name' | 'size' | 'lastModified'>): string;
+export declare function draftKeyUntitled(): string;
+export declare function draftKeyForFileFingerprint(fingerprint: string): string;
+/** Pre–Phase 4 keys used only the display file name. */
+export declare function legacyDraftKeyForFileName(fileName: string): string;
+export type StoredDraft = {
+    source: string;
+    savedAt: number;
+    fileName?: string | null;
+    fingerprint?: string | null;
+};
+export type SaveDraftMeta = {
+    fileName?: string | null;
+    fingerprint?: string | null;
+    /** When migrating or preserving an existing timestamp */
+    savedAt?: number;
+};
+export declare function saveDraft(key: string, source: string, meta?: SaveDraftMeta): void;
+export declare function loadDraft(key: string): StoredDraft | null;
+export declare function clearDraft(key: string): void;
+/**
+ * Prefer fingerprint key; if empty, migrate legacy `md-editor-draft:<fileName>` into the fingerprint key.
+ */
+export declare function loadDraftForFileWithLegacy(fingerprint: string, fileName: string): StoredDraft | null;
+/** @deprecated Use {@link draftKeyUntitled} or {@link draftKeyForFileFingerprint} with {@link fileFingerprint}. */
+export declare function draftStorageKey(fileName: string | null): string;

package/dist/editor/draftPersistence.js

@@ -0,0 +1,83 @@
+const PREFIX = 'md-editor-draft:';
+/** Best-effort identity for browser-only reopen (same physical file as last session under typical OS metadata). Not a path or cryptographic id. */
+export function fileFingerprint(file) {
+    return `${file.name}\u001f${file.size}\u001f${file.lastModified}`;
+}
+export function draftKeyUntitled() {
+    return `${PREFIX}untitled`;
+}
+export function draftKeyForFileFingerprint(fingerprint) {
+    return `${PREFIX}file:${encodeURIComponent(fingerprint)}`;
+}
+/** Pre–Phase 4 keys used only the display file name. */
+export function legacyDraftKeyForFileName(fileName) {
+    return `${PREFIX}${fileName}`;
+}
+export function saveDraft(key, source, meta) {
+    if (typeof localStorage === 'undefined')
+        return;
+    try {
+        const payload = {
+            source,
+            savedAt: meta?.savedAt ?? Date.now()
+        };
+        if (meta?.fileName !== undefined)
+            payload.fileName = meta.fileName;
+        if (meta?.fingerprint !== undefined)
+            payload.fingerprint = meta.fingerprint;
+        localStorage.setItem(key, JSON.stringify(payload));
+    }
+    catch {
+        /* quota / private mode */
+    }
+}
+export function loadDraft(key) {
+    if (typeof localStorage === 'undefined')
+        return null;
+    try {
+        const raw = localStorage.getItem(key);
+        if (!raw)
+            return null;
+        const v = JSON.parse(raw);
+        if (typeof v?.source !== 'string' || typeof v?.savedAt !== 'number')
+            return null;
+        return v;
+    }
+    catch {
+        return null;
+    }
+}
+export function clearDraft(key) {
+    if (typeof localStorage === 'undefined')
+        return;
+    try {
+        localStorage.removeItem(key);
+    }
+    catch {
+        /* ignore */
+    }
+}
+/**
+ * Prefer fingerprint key; if empty, migrate legacy `md-editor-draft:<fileName>` into the fingerprint key.
+ */
+export function loadDraftForFileWithLegacy(fingerprint, fileName) {
+    const newKey = draftKeyForFileFingerprint(fingerprint);
+    const existing = loadDraft(newKey);
+    if (existing)
+        return existing;
+    const legacyKey = legacyDraftKeyForFileName(fileName);
+    const legacy = loadDraft(legacyKey);
+    if (!legacy)
+        return null;
+    saveDraft(newKey, legacy.source, {
+        fileName,
+        fingerprint,
+        savedAt: legacy.savedAt
+    });
+    clearDraft(legacyKey);
+    return loadDraft(newKey);
+}
+/** @deprecated Use {@link draftKeyUntitled} or {@link draftKeyForFileFingerprint} with {@link fileFingerprint}. */
+export function draftStorageKey(fileName) {
+    return fileName ? legacyDraftKeyForFileName(fileName) : draftKeyUntitled();
+}

package/dist/editor/editorHistoryHandle.d.ts

@@ -0,0 +1,16 @@
+/** Narrow embedder surface for in-session undo/redo (matches Phials {@link EditorHistoryHandle}). */
+export interface EditorHistoryHandle {
+    undo: () => boolean;
+    redo: () => boolean;
+    canUndo: boolean;
+    canRedo: boolean;
+}
+export type EditorHistoryHandleWithSync = EditorHistoryHandle & {
+    sync: () => void;
+};
+export declare function createEditorHistoryHandle(deps: {
+    undo: () => boolean;
+    redo: () => boolean;
+    getCanUndo: () => boolean;
+    getCanRedo: () => boolean;
+}): EditorHistoryHandleWithSync;

package/dist/editor/editorHistoryHandle.js

@@ -0,0 +1,22 @@
+export function createEditorHistoryHandle(deps) {
+    const handle = {
+        canUndo: false,
+        canRedo: false,
+        undo() {
+            const ok = deps.undo();
+            handle.sync();
+            return ok;
+        },
+        redo() {
+            const ok = deps.redo();
+            handle.sync();
+            return ok;
+        },
+        sync() {
+            handle.canUndo = deps.getCanUndo();
+            handle.canRedo = deps.getCanRedo();
+        }
+    };
+    handle.sync();
+    return handle;
+}

package/dist/editor/inlineChrome/InlineChromeCoordinator.svelte

@@ -0,0 +1,174 @@
+<script lang="ts">
+	import { getPopoverManager } from 'phoundry-ui';
+	import type { MarkdownEditor } from '../MarkdownEditor.svelte';
+	import { findBlockLocation } from '../model/blockTree';
+	import { selectionBoundingRect } from './selectionRect';
+	import { inlineChromeState } from './inlineChromeState.svelte';
+	import { resolveLinkHoverFromElement } from './inlineChromeActions';
+
+	let { editor, root }: { editor: MarkdownEditor; root: HTMLElement } = $props();
+
+	const popover = getPopoverManager();
+	const chrome = inlineChromeState;
+
+	let linkHideTimer: ReturnType<typeof setTimeout> | null = null;
+	let suppressLinkHover = $state(false);
+
+	$effect(() => {
+		chrome.editor = editor;
+	});
+
+	function closeChrome() {
+		popover.close();
+		chrome.reset();
+	}
+
+	function openSelectionToolbar() {
+		const sel = editor.documentSelection;
+		if (!sel?.plain || sel.plain.start === sel.plain.end) {
+			closeChrome();
+			return;
+		}
+		const rect = selectionBoundingRect();
+		if (!rect) {
+			closeChrome();
+			return;
+		}
+		const loc = findBlockLocation(editor.document.blocks, sel.blockId);
+		if (!loc) {
+			closeChrome();
+			return;
+		}
+		const block = loc.block;
+		if (block.type !== 'paragraph' && block.type !== 'heading') {
+			closeChrome();
+			return;
+		}
+
+		chrome.mode = 'selection';
+		chrome.panel = 'root';
+		chrome.blockId = sel.blockId;
+		chrome.plainStart = sel.plain.start;
+		chrome.plainEnd = sel.plain.end;
+		chrome.linkHover = null;
+
+		popover.open({
+			anchor: rect,
+			placement: 'top',
+			ariaLabel: 'Text formatting',
+			onClose: () => chrome.reset()
+		});
+	}
+
+	function openLinkHover(target: ReturnType<typeof resolveLinkHoverFromElement> & { element: HTMLElement }) {
+		if (!target || suppressLinkHover) return;
+		const sel = editor.documentSelection;
+		if (sel?.plain && sel.plain.start !== sel.plain.end) return;
+
+		chrome.mode = 'link-hover';
+		chrome.panel = 'link-edit';
+		chrome.blockId = target.blockId;
+		chrome.plainStart = target.plainStart;
+		chrome.plainEnd = target.plainEnd;
+		chrome.linkHover = {
+			blockId: target.blockId,
+			plainStart: target.plainStart,
+			plainEnd: target.plainEnd,
+			href: target.href,
+			element: target.element
+		};
+		chrome.linkDraftHref = target.href;
+
+		popover.open({
+			anchor: target.element,
+			placement: 'top',
+			ariaLabel: 'Link',
+			onClose: () => chrome.reset()
+		});
+	}
+
+	$effect(() => {
+		const sel = editor.documentSelection;
+		if (chrome.mode === 'link-hover') return;
+		if (!sel?.plain || sel.plain.start === sel.plain.end) {
+			if (chrome.mode === 'selection') closeChrome();
+			return;
+		}
+		queueMicrotask(() => {
+			if (chrome.mode !== 'link-hover') openSelectionToolbar();
+		});
+	});
+
+	function onPointerOver(e: PointerEvent) {
+		const t = e.target;
+		if (!(t instanceof HTMLElement)) return;
+		const linkMeta = resolveLinkHoverFromElement(t);
+		if (!linkMeta) return;
+		if (linkHideTimer) {
+			clearTimeout(linkHideTimer);
+			linkHideTimer = null;
+		}
+		const sel = editor.documentSelection;
+		if (sel?.plain && sel.plain.start !== sel.plain.end) return;
+		openLinkHover({ ...linkMeta, element: t.closest('[data-md-inline-link]') as HTMLElement });
+	}
+
+	function clearLinkHideTimer() {
+		if (linkHideTimer) {
+			clearTimeout(linkHideTimer);
+			linkHideTimer = null;
+		}
+	}
+
+	function pointInRect(x: number, y: number, rect: DOMRect | DOMRectReadOnly): boolean {
+		return x >= rect.left && x <= rect.right && y >= rect.top && y <= rect.bottom;
+	}
+
+	function onPointerMove(e: PointerEvent) {
+		if (chrome.mode !== 'link-hover') return;
+		const link = chrome.linkHover?.element;
+		const floating = document.querySelector('[role="dialog"][aria-label="Link"]');
+		const overLink = link ? pointInRect(e.clientX, e.clientY, link.getBoundingClientRect()) : false;
+		const overPopover =
+			floating instanceof HTMLElement
+				? pointInRect(e.clientX, e.clientY, floating.getBoundingClientRect())
+				: false;
+		if (overLink || overPopover) {
+			clearLinkHideTimer();
+			return;
+		}
+		if (linkHideTimer) return;
+		linkHideTimer = setTimeout(() => {
+			if (chrome.mode === 'link-hover') closeChrome();
+		}, 120);
+	}
+
+	function onScrollCapture() {
+		if (chrome.mode === 'selection') {
+			popover.bumpTick();
+			const rect = selectionBoundingRect();
+			if (!rect) closeChrome();
+			return;
+		}
+		if (chrome.mode === 'link-hover') closeChrome();
+	}
+
+	$effect(() => {
+		if (!root) return;
+		root.addEventListener('pointerover', onPointerOver, true);
+		window.addEventListener('pointermove', onPointerMove, true);
+		window.addEventListener('scroll', onScrollCapture, true);
+		return () => {
+			root.removeEventListener('pointerover', onPointerOver, true);
+			window.removeEventListener('pointermove', onPointerMove, true);
+			window.removeEventListener('scroll', onScrollCapture, true);
+			if (linkHideTimer) clearTimeout(linkHideTimer);
+		};
+	});
+
+	$effect(() => {
+		if (!popover.state && chrome.mode !== 'closed') {
+			chrome.reset();
+		}
+	});
+</script>

package/dist/editor/inlineChrome/InlineChromeCoordinator.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { MarkdownEditor } from '../MarkdownEditor.svelte';
+type $$ComponentProps = {
+    editor: MarkdownEditor;
+    root: HTMLElement;
+};
+declare const InlineChromeCoordinator: import("svelte").Component<$$ComponentProps, {}, "">;
+type InlineChromeCoordinator = ReturnType<typeof InlineChromeCoordinator>;
+export default InlineChromeCoordinator;

package/dist/editor/inlineChrome/InlineFormattingToolbar.svelte

@@ -0,0 +1,181 @@
+<script lang="ts">
+	import Icon from '@iconify/svelte';
+	import { Button, TextInput } from 'phoundry-ui';
+	import { getPopoverManager } from 'phoundry-ui';
+	import type { InlineWrapKind } from '../model/inlineEditCommands';
+	import { inlineToolbarIcons } from './inlineToolbarIcons';
+	import { inlineChromeState } from './inlineChromeState.svelte';
+	import { activeWrapKindsForRange } from './inlineWrapActive';
+	import {
+		applyLinkHrefFromChrome,
+		applyUnlinkFromChrome,
+		applyWrapFromChrome,
+		currentInlinesForChrome,
+		headingCommandsForChrome,
+		runTurnIntoCommand
+	} from './inlineChromeActions';
+
+	const chrome = inlineChromeState;
+	const popover = getPopoverManager();
+
+	const wrapKinds: { kind: InlineWrapKind; icon: string; label: string }[] = [
+		{ kind: 'strong', icon: inlineToolbarIcons.bold, label: 'Bold' },
+		{ kind: 'emphasis', icon: inlineToolbarIcons.italic, label: 'Italic' },
+		{ kind: 'code', icon: inlineToolbarIcons.code, label: 'Code' },
+		{ kind: 'strikethrough', icon: inlineToolbarIcons.strikethrough, label: 'Strikethrough' },
+		{ kind: 'highlight', icon: inlineToolbarIcons.highlight, label: 'Highlight' }
+	];
+
+	const activeKinds = $derived.by(() => {
+		if (chrome.mode !== 'selection' || !chrome.blockId) return new Set<InlineWrapKind>();
+		const nodes = currentInlinesForChrome();
+		return activeWrapKindsForRange(nodes, chrome.plainStart, chrome.plainEnd);
+	});
+
+	const headingCommands = $derived(headingCommandsForChrome());
+
+	function stopMouseDown(e: MouseEvent) {
+		if (chrome.panel !== 'link-edit') e.preventDefault();
+	}
+
+	function onWrap(kind: InlineWrapKind) {
+		if (kind === 'link') {
+			chrome.panel = 'link-edit';
+			chrome.linkDraftHref = activeKinds.has('link') ? '' : 'https://';
+			return;
+		}
+		applyWrapFromChrome(kind);
+	}
+
+	function commitLink() {
+		applyLinkHrefFromChrome(chrome.linkDraftHref);
+		if (chrome.mode === 'selection') {
+			chrome.panel = 'root';
+		} else {
+			popover.close();
+		}
+	}
+
+	function onHeadingPick(commandId: string) {
+		runTurnIntoCommand(commandId);
+		popover.close();
+	}
+
+	function openExternal() {
+		const href = chrome.linkDraftHref.trim();
+		if (href) window.open(href, '_blank', 'noopener,noreferrer');
+	}
+</script>
+
+{#if popover.state}
+	<div
+		role="toolbar"
+		tabindex="-1"
+		aria-label="Text formatting"
+		class="flex flex-col gap-1 rounded-lg border border-border-muted bg-surface-base p-1 shadow-lg"
+		onmousedown={stopMouseDown}
+	>
+		{#if chrome.mode === 'link-hover' || chrome.panel === 'link-edit'}
+			<div class="flex min-w-56 flex-col gap-1.5 p-1">
+				{#if chrome.mode === 'selection' && chrome.panel === 'link-edit'}
+					<button
+						type="button"
+						class="flex items-center gap-1 px-1 text-xs text-txt-secondary hover:text-txt-primary"
+						onclick={() => (chrome.panel = 'root')}
+					>
+						<Icon icon={inlineToolbarIcons.chevronLeft} width={14} height={14} />
+						Back
+					</button>
+				{/if}
+				<form
+					class="contents"
+					onsubmit={(e) => {
+						e.preventDefault();
+						commitLink();
+					}}
+				>
+					<TextInput
+						size="sm"
+						type="url"
+						placeholder="https://"
+						bind:value={chrome.linkDraftHref}
+					/>
+				</form>
+				<div class="flex gap-1">
+					<Button size="sm" onclick={commitLink}>Apply</Button>
+					<Button
+						size="sm"
+						variant="ghost"
+						icon={inlineToolbarIcons.externalLink}
+						iconOnly
+						title="Open link"
+						onclick={openExternal}
+					/>
+					<Button
+						size="sm"
+						variant="ghost"
+						icon={inlineToolbarIcons.unlink}
+						iconOnly
+						title="Remove link"
+						onclick={() => {
+							applyUnlinkFromChrome();
+							popover.close();
+						}}
+					/>
+				</div>
+			</div>
+		{:else if chrome.panel === 'heading'}
+			<div class="flex min-w-40 flex-col gap-0.5 p-1">
+				<button
+					type="button"
+					class="flex items-center gap-1 px-2 py-1 text-xs text-txt-secondary hover:text-txt-primary"
+					onclick={() => (chrome.panel = 'root')}
+				>
+					<Icon icon={inlineToolbarIcons.chevronLeft} width={14} height={14} />
+					Back
+				</button>
+				{#each headingCommands as cmd (cmd.id)}
+					<button
+						type="button"
+						class="rounded px-2 py-1.5 text-left text-xs text-txt-primary hover:bg-surface-raised"
+						onclick={() => onHeadingPick(cmd.id)}
+					>
+						{cmd.label}
+					</button>
+				{/each}
+			</div>
+		{:else}
+			<div class="flex items-center gap-0.5">
+				{#each wrapKinds as { kind, icon, label } (kind)}
+					<Button
+						size="sm"
+						variant="ghost"
+						{icon}
+						iconOnly
+						title={label}
+						active={activeKinds.has(kind)}
+						onclick={() => onWrap(kind)}
+					/>
+				{/each}
+				<Button
+					size="sm"
+					variant="ghost"
+					icon={inlineToolbarIcons.link}
+					iconOnly
+					title="Link"
+					active={activeKinds.has('link')}
+					onclick={() => onWrap('link')}
+				/>
+				<div class="mx-0.5 h-5 w-px bg-border-muted"></div>
+				<Button
+					size="sm"
+					variant="ghost"
+					icon={inlineToolbarIcons.heading}
+					iconOnly
+					title="Turn into"
+					onclick={() => (chrome.panel = 'heading')}
+				/>
+			</div>
+		{/if}
+	</div>
+{/if}

package/dist/editor/inlineChrome/InlineFormattingToolbar.svelte.d.ts

@@ -0,0 +1,3 @@
+declare const InlineFormattingToolbar: import("svelte").Component<Record<string, never>, {}, "">;
+type InlineFormattingToolbar = ReturnType<typeof InlineFormattingToolbar>;
+export default InlineFormattingToolbar;

package/dist/editor/inlineChrome/inlineChromeActions.d.ts

@@ -0,0 +1,17 @@
+import type { InlineWrapKind } from '../model/inlineEditCommands';
+import type { InlineNode } from '../model/types';
+import type { MarkdownEditor } from '../MarkdownEditor.svelte';
+import { type EditorCommandContext } from '../commandRegistry';
+export declare function commandContextForBlockId(editor: MarkdownEditor, blockId: string): EditorCommandContext | null;
+export declare function applyWrapFromChrome(kind: InlineWrapKind, linkHref?: string): void;
+export declare function applyUnlinkFromChrome(): void;
+export declare function runTurnIntoCommand(commandId: string): void;
+export declare function headingCommandsForChrome(): import("../commandRegistry").EditorCommand[];
+export declare function resolveLinkHoverFromElement(el: HTMLElement): {
+    blockId: string;
+    plainStart: number;
+    plainEnd: number;
+    href: string;
+} | null;
+export declare function applyLinkHrefFromChrome(href: string): void;
+export declare function currentInlinesForChrome(): InlineNode[];