@aglyn/aglyn-markdown-editor 1.0.0-beta.143

package/src/lib/markdown-visual-editor.component.js

@@ -0,0 +1,2019 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ 'use client';
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { isSupportedImageSrc, isSupportedLinkHref, parseMarkdownLite, resolveMediaSrc, serializeMarkdownLite } from "@aglyn/aglyn";
+import { Box, Button, Dialog, DialogActions, DialogContent, DialogTitle, Popover, Stack, TextField, ToggleButton, ToggleButtonGroup, Typography } from "@mui/material";
+import FormatAlignCenterIcon from "@mui/icons-material/FormatAlignCenter";
+import FormatAlignLeftIcon from "@mui/icons-material/FormatAlignLeft";
+import FormatAlignRightIcon from "@mui/icons-material/FormatAlignRight";
+import { forwardRef, memo, useCallback, useEffect, useImperativeHandle, useLayoutEffect, useMemo, useRef, useState } from "react";
+import { htmlToRows } from "./markdown-html-paste.js";
+import MarkdownLinkDialog, { MarkdownLinkTargetName } from "./markdown-link-dialog.component.js";
+const isTextRow = (row)=>row.kind !== 'image' && row.kind !== 'code' && row.kind !== 'table';
+let rowKeySeq = 0;
+const nextRowKey = ()=>`md-row-${++rowKeySeq}`;
+const emptyParagraph = ()=>({
+        key: nextRowKey(),
+        kind: 'paragraph',
+        inlines: []
+    });
+/** Flattens parsed blocks to editable rows (lists become item rows). */ export function markdownToRows(markdown) {
+    const rows = [];
+    for (const block of parseMarkdownLite(markdown)){
+        if (block.type === 'heading') {
+            rows.push({
+                key: nextRowKey(),
+                kind: block.level === 2 ? 'heading2' : 'heading3',
+                inlines: block.inlines
+            });
+        } else if (block.type === 'paragraph') {
+            rows.push({
+                key: nextRowKey(),
+                kind: 'paragraph',
+                inlines: block.inlines
+            });
+        } else if (block.type === 'quote') {
+            rows.push({
+                key: nextRowKey(),
+                kind: 'quote',
+                inlines: block.inlines
+            });
+        } else if (block.type === 'image') {
+            rows.push({
+                key: nextRowKey(),
+                kind: 'image',
+                src: block.src,
+                alt: block.alt
+            });
+        } else if (block.type === 'code') {
+            rows.push({
+                key: nextRowKey(),
+                kind: 'code',
+                lang: block.lang,
+                text: block.text
+            });
+        } else if (block.type === 'table') {
+            rows.push({
+                key: nextRowKey(),
+                kind: 'table',
+                align: block.align,
+                header: block.header,
+                rows: block.rows
+            });
+        } else if (block.type === 'orderedList') {
+            // The start rides on the first item row only (AGL-1320) — the run's
+            // opener is what `rowsToMarkdown` reads it back from.
+            block.items.forEach((item, index)=>{
+                rows.push(_extends({
+                    key: nextRowKey(),
+                    kind: 'orderedItem',
+                    inlines: item
+                }, index === 0 ? {
+                    start: block.start
+                } : {}));
+            });
+        } else {
+            for (const item of block.items){
+                rows.push({
+                    key: nextRowKey(),
+                    kind: 'listItem',
+                    inlines: item
+                });
+            }
+        }
+    }
+    if (rows.length === 0) rows.push(emptyParagraph());
+    return rows;
+}
+/** Regroups rows to blocks (adjacent list items rejoin) and serializes. */ export function rowsToMarkdown(rows) {
+    const blocks = [];
+    for (const row of rows){
+        if (row.kind === 'image') {
+            blocks.push({
+                type: 'image',
+                src: row.src,
+                alt: row.alt
+            });
+        } else if (row.kind === 'code') {
+            blocks.push({
+                type: 'code',
+                lang: row.lang,
+                text: row.text
+            });
+        } else if (row.kind === 'table') {
+            blocks.push({
+                type: 'table',
+                align: row.align,
+                header: row.header,
+                rows: row.rows
+            });
+        } else if (row.kind === 'listItem') {
+            const last = blocks[blocks.length - 1];
+            if ((last == null ? void 0 : last.type) === 'list') last.items.push(row.inlines);
+            else blocks.push({
+                type: 'list',
+                items: [
+                    row.inlines
+                ]
+            });
+        } else if (row.kind === 'orderedItem') {
+            var _row_start;
+            const last = blocks[blocks.length - 1];
+            if ((last == null ? void 0 : last.type) === 'orderedList') last.items.push(row.inlines);
+            else blocks.push({
+                type: 'orderedList',
+                start: (_row_start = row.start) != null ? _row_start : 1,
+                items: [
+                    row.inlines
+                ]
+            });
+        } else if (row.kind === 'paragraph') {
+            blocks.push({
+                type: 'paragraph',
+                inlines: row.inlines
+            });
+        } else if (row.kind === 'quote') {
+            blocks.push({
+                type: 'quote',
+                inlines: row.inlines
+            });
+        } else {
+            blocks.push({
+                type: 'heading',
+                level: row.kind === 'heading2' ? 2 : 3,
+                inlines: row.inlines
+            });
+        }
+    }
+    return serializeMarkdownLite(blocks);
+}
+const rowPlainText = (inlines)=>inlines.map((inline)=>inline.text).join('');
+/** Merges adjacent same-type runs (same href for links), drops empties. */ function normalizeInlines(inlines) {
+    const out = [];
+    for (const inline of inlines){
+        if (!inline.text) continue;
+        const last = out[out.length - 1];
+        if (last && last.type === inline.type && (last.type !== 'link' || last.href === inline.href)) {
+            last.text += inline.text;
+        } else {
+            out.push(_extends({}, inline));
+        }
+    }
+    return out;
+}
+/** Extracts [from, to) in plain-text offsets, keeping marks on the cuts. */ function sliceInlines(inlines, from, to) {
+    const out = [];
+    let position = 0;
+    for (const inline of inlines){
+        const end = position + inline.text.length;
+        const start = Math.max(from, position);
+        const stop = Math.min(to, end);
+        if (stop > start) {
+            out.push(_extends({}, inline, {
+                text: inline.text.slice(start - position, stop - position)
+            }));
+        }
+        position = end;
+    }
+    return normalizeInlines(out);
+}
+function replaceInlineRange(inlines, from, to, replacement) {
+    return normalizeInlines([
+        ...sliceInlines(inlines, 0, from),
+        ...replacement,
+        ...sliceInlines(inlines, to, Infinity)
+    ]);
+}
+/**
+ * Toggles bold/italic over [from, to). The dialect cannot nest marks, so
+ * applying one flattens the covered range to plain text carrying the mark;
+ * a range that is already entirely the mark unwraps back to text.
+ */ function toggleInlineMark(inlines, from, to, mark) {
+    const middle = sliceInlines(inlines, from, to);
+    const text = rowPlainText(middle);
+    if (!text) return {
+        inlines,
+        length: 0
+    };
+    const unwrap = middle.every((inline)=>inline.type === mark);
+    return {
+        inlines: replaceInlineRange(inlines, from, to, [
+            {
+                type: unwrap ? 'text' : mark,
+                text
+            }
+        ]),
+        length: text.length
+    };
+}
+/**
+ * Reads a row's live DOM back into canonical inlines. Only elements this
+ * editor renders exist in a row (plus text nodes the browser adds while
+ * typing); unknown wrappers are recursed through as plain text.
+ */ export function readInlinesFromElement(rowEl) {
+    const inlines = [];
+    const visit = (node)=>{
+        var _node_textContent;
+        if (node.nodeType === Node.TEXT_NODE) {
+            var _node_textContent1;
+            const text = (_node_textContent1 = node.textContent) != null ? _node_textContent1 : '';
+            if (text) inlines.push({
+                type: 'text',
+                text
+            });
+            return;
+        }
+        if (!(node instanceof HTMLElement) || node.tagName === 'BR') return;
+        const text = (_node_textContent = node.textContent) != null ? _node_textContent : '';
+        if (!text) return;
+        if (node.tagName === 'STRONG' || node.tagName === 'B') {
+            inlines.push({
+                type: 'bold',
+                text
+            });
+        } else if (node.tagName === 'EM' || node.tagName === 'I') {
+            inlines.push({
+                type: 'italic',
+                text
+            });
+        } else if (node.dataset['mdLink'] != null) {
+            var _node_dataset_mdHref;
+            inlines.push({
+                type: 'link',
+                text,
+                href: (_node_dataset_mdHref = node.dataset['mdHref']) != null ? _node_dataset_mdHref : ''
+            });
+        } else {
+            node.childNodes.forEach(visit);
+        }
+    };
+    rowEl.childNodes.forEach(visit);
+    return normalizeInlines(inlines);
+}
+/** Plain-text offset of a DOM position inside a row element. */ function textOffsetOf(rowEl, node, offset) {
+    const range = rowEl.ownerDocument.createRange();
+    range.selectNodeContents(rowEl);
+    try {
+        range.setEnd(node, offset);
+    } catch (unused) {
+        return 0;
+    }
+    return range.toString().length;
+}
+function selectionOffsetsWithin(rowEl) {
+    var _rowEl_ownerDocument_defaultView_getSelection, _rowEl_ownerDocument_defaultView;
+    const selection = (_rowEl_ownerDocument_defaultView = rowEl.ownerDocument.defaultView) == null ? void 0 : (_rowEl_ownerDocument_defaultView_getSelection = _rowEl_ownerDocument_defaultView.getSelection) == null ? void 0 : _rowEl_ownerDocument_defaultView_getSelection.call(_rowEl_ownerDocument_defaultView);
+    if (!selection || selection.rangeCount === 0) return null;
+    const range = selection.getRangeAt(0);
+    if (!rowEl.contains(range.startContainer) || !rowEl.contains(range.endContainer)) {
+        return null;
+    }
+    const start = textOffsetOf(rowEl, range.startContainer, range.startOffset);
+    const end = textOffsetOf(rowEl, range.endContainer, range.endOffset);
+    return start <= end ? {
+        start,
+        end
+    } : {
+        start: end,
+        end: start
+    };
+}
+function resolveTextPosition(rowEl, target) {
+    const walker = rowEl.ownerDocument.createTreeWalker(rowEl, NodeFilter.SHOW_TEXT);
+    let remaining = target;
+    let node = walker.nextNode();
+    let lastText = null;
+    while(node){
+        const text = node;
+        if (remaining <= text.length) return {
+            node: text,
+            offset: remaining
+        };
+        remaining -= text.length;
+        lastText = text;
+        node = walker.nextNode();
+    }
+    if (lastText) return {
+        node: lastText,
+        offset: lastText.length
+    };
+    return {
+        node: rowEl,
+        offset: 0
+    };
+}
+function setSelectionIn(rowEl, start, end) {
+    var _rowEl_ownerDocument_defaultView_getSelection, _rowEl_ownerDocument_defaultView;
+    const selection = (_rowEl_ownerDocument_defaultView = rowEl.ownerDocument.defaultView) == null ? void 0 : (_rowEl_ownerDocument_defaultView_getSelection = _rowEl_ownerDocument_defaultView.getSelection) == null ? void 0 : _rowEl_ownerDocument_defaultView_getSelection.call(_rowEl_ownerDocument_defaultView);
+    if (!selection) return;
+    const from = resolveTextPosition(rowEl, start);
+    const to = end === start ? from : resolveTextPosition(rowEl, end);
+    const range = rowEl.ownerDocument.createRange();
+    range.setStart(from.node, from.offset);
+    range.setEnd(to.node, to.offset);
+    selection.removeAllRanges();
+    selection.addRange(range);
+}
+function renderRowInlines(inlines) {
+    // An empty row keeps a <br> so the caret has a line box to land in.
+    if (inlines.length === 0) return /*#__PURE__*/ _jsx("br", {});
+    return inlines.map((inline, index)=>inline.type === 'bold' ? /*#__PURE__*/ _jsx("strong", {
+            children: inline.text
+        }, index) : inline.type === 'italic' ? /*#__PURE__*/ _jsx("em", {
+            children: inline.text
+        }, index) : inline.type === 'link' ? /*#__PURE__*/ _jsx("span", {
+            "data-md-link": "",
+            "data-md-href": inline.href,
+            children: inline.text
+        }, index) : /*#__PURE__*/ _jsx("span", {
+            children: inline.text
+        }, index));
+}
+/**
+ * One editable row. The rendered children are FROZEN per `version`: while
+ * the user types, React re-renders (parent state changes on every emitted
+ * keystroke) but receives the identical element references, so it bails
+ * out and never touches the browser-managed DOM. A version bump swaps the
+ * `key`, remounting the row cleanly from the model.
+ */ const TextRowView = /*#__PURE__*/ memo(function TextRowView(props) {
+    const { row, version, onInput, onKeyDown, onPaste, onClick, onSelectionPing } = props;
+    // The DOM is the source of truth between versions — deliberately NOT
+    // keyed on row.inlines, which trail the DOM during silent typing syncs.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    const children = useMemo(()=>renderRowInlines(row.inlines), [
+        version
+    ]);
+    return /*#__PURE__*/ _jsx(Box, {
+        contentEditable: true,
+        suppressContentEditableWarning: true,
+        spellCheck: true,
+        "data-row-key": row.key,
+        "data-row-kind": row.kind,
+        // The opener of a numbered run seeds the counter (AGL-1320). Reset
+        // runs before increment on the same element, so this row itself shows
+        // `start` and the rest of the run counts up from it.
+        style: row.kind === 'orderedItem' && row.start != null ? {
+            counterReset: `md-ordered ${row.start - 1}`
+        } : undefined,
+        onInput: onInput,
+        onKeyDown: onKeyDown,
+        onPaste: onPaste,
+        onClick: onClick,
+        onKeyUp: onSelectionPing,
+        onMouseUp: onSelectionPing,
+        onFocus: onSelectionPing,
+        children: children
+    }, `${row.key}:${version}`);
+});
+/** A cell edited to nothing parses back to nothing — keep it canonical. */ const cellFromElement = (el)=>readInlinesFromElement(el);
+const CODE_LANGUAGES = [
+    '',
+    'ts',
+    'tsx',
+    'js',
+    'json',
+    'bash',
+    'html',
+    'css',
+    'md'
+];
+/**
+ * A block row: an image, a code block or a table (AGL-983). The document
+ * caret never enters one — each brings its own editing surface instead, and
+ * the row travels through the model as a unit. Hover reveals its controls.
+ *
+ * Editing follows the same rule as text rows: while the user types, the DOM
+ * is the source of truth and the model syncs SILENTLY (no re-render, no lost
+ * caret). Only structural edits — adding a column, changing alignment —
+ * re-render, and they bump `version`, which re-keys this row.
+ */ const BlockRowView = /*#__PURE__*/ memo(function BlockRowView({ row, version, onEdit, onEditSilently, onRemove }) {
+    var _ref;
+    const table = row.kind === 'table' ? row : null;
+    const columns = (_ref = table == null ? void 0 : table.header.length) != null ? _ref : 0;
+    /**
+   * Cell contents are rendered ONCE, exactly like a text row's (this view is
+   * re-keyed on `version`, so a model change remounts it). Re-rendering them
+   * would have React reconcile DOM the browser owns while the caret is in
+   * it — typing into an empty cell replaces its <br>, and the next render
+   * threw NotFoundError trying to remove a node that was already gone.
+   */ const frozenHeader = useMemo(()=>{
+        var _ref;
+        return ((_ref = table == null ? void 0 : table.header) != null ? _ref : []).map((cell)=>renderRowInlines(cell));
+    }, // eslint-disable-next-line react-hooks/exhaustive-deps
+    []);
+    const frozenRows = useMemo(()=>{
+        var _ref;
+        return ((_ref = table == null ? void 0 : table.rows) != null ? _ref : []).map((cells)=>cells.map((cell)=>renderRowInlines(cell)));
+    }, // eslint-disable-next-line react-hooks/exhaustive-deps
+    []);
+    /** Writes one cell back from its live DOM. Header row is index -1. */ const syncCell = (rowIndex, cellIndex, el)=>{
+        const inlines = cellFromElement(el);
+        onEditSilently((current)=>{
+            if (current.kind !== 'table') return current;
+            if (rowIndex < 0) {
+                const header = [
+                    ...current.header
+                ];
+                header[cellIndex] = inlines;
+                return _extends({}, current, {
+                    header
+                });
+            }
+            const rows = current.rows.map((cells, index)=>index === rowIndex ? cells.map((cell, i)=>i === cellIndex ? inlines : cell) : cells);
+            return _extends({}, current, {
+                rows
+            });
+        });
+    };
+    const cellProps = (rowIndex, cellIndex)=>{
+        var _ref;
+        return {
+            contentEditable: true,
+            suppressContentEditableWarning: true,
+            onInput: (event)=>syncCell(rowIndex, cellIndex, event.currentTarget),
+            style: {
+                textAlign: (_ref = table == null ? void 0 : table.align[cellIndex]) != null ? _ref : 'left'
+            }
+        };
+    };
+    return /*#__PURE__*/ _jsxs(Box, {
+        contentEditable: false,
+        "data-row-key": row.key,
+        "data-row-kind": row.kind,
+        sx: {
+            my: 1,
+            position: 'relative',
+            '&:hover [data-md-block-controls]': {
+                opacity: 1
+            }
+        },
+        children: [
+            row.kind === 'image' ? // Resolved for DISPLAY only (AGL-1686); `row.src` keeps the stored
+            // form, so serializing back writes the reference rather than the URL
+            // it happens to resolve to right now. Without this the author would
+            // be editing next to a broken-image icon while the published page
+            // rendered correctly.
+            // eslint-disable-next-line @next/next/no-img-element
+            /*#__PURE__*/ _jsx("img", {
+                src: resolveMediaSrc(row.src),
+                alt: row.alt
+            }) : row.kind === 'code' ? /*#__PURE__*/ _jsxs(Box, {
+                sx: {
+                    borderRadius: 1,
+                    border: '1px solid',
+                    borderColor: 'divider',
+                    bgcolor: 'action.hover',
+                    overflow: 'hidden',
+                    '&:focus-within': {
+                        borderColor: 'primary.main'
+                    }
+                },
+                children: [
+                    /*#__PURE__*/ _jsx(Box, {
+                        component: "textarea",
+                        spellCheck: false,
+                        defaultValue: row.text,
+                        placeholder: "Your snippet…",
+                        rows: Math.max(2, row.text.split('\n').length),
+                        onChange: (event)=>{
+                            const text = event.target.value;
+                            // Grow with the snippet rather than scrolling a 2-row box.
+                            event.target.style.height = 'auto';
+                            event.target.style.height = `${event.target.scrollHeight}px`;
+                            onEditSilently((current)=>current.kind === 'code' ? _extends({}, current, {
+                                    text
+                                }) : current);
+                        },
+                        sx: {
+                            display: 'block',
+                            width: '100%',
+                            border: 0,
+                            outline: 'none',
+                            resize: 'vertical',
+                            p: 1.5,
+                            bgcolor: 'transparent',
+                            color: 'text.primary',
+                            fontFamily: 'monospace',
+                            fontSize: 13,
+                            lineHeight: 1.6
+                        }
+                    }),
+                    /*#__PURE__*/ _jsxs(Box, {
+                        sx: {
+                            display: 'flex',
+                            alignItems: 'center',
+                            gap: 1,
+                            px: 1,
+                            py: 0.5,
+                            borderTop: '1px solid',
+                            borderColor: 'divider'
+                        },
+                        children: [
+                            /*#__PURE__*/ _jsx(Typography, {
+                                variant: "caption",
+                                color: "text.secondary",
+                                children: 'Language'
+                            }),
+                            /*#__PURE__*/ _jsx(Box, {
+                                component: "select",
+                                defaultValue: row.lang,
+                                onChange: (event)=>{
+                                    const lang = event.target.value;
+                                    onEditSilently((current)=>current.kind === 'code' ? _extends({}, current, {
+                                            lang
+                                        }) : current);
+                                },
+                                sx: {
+                                    border: 0,
+                                    bgcolor: 'transparent',
+                                    color: 'text.secondary',
+                                    font: 'inherit',
+                                    fontSize: 12,
+                                    outline: 'none'
+                                },
+                                children: CODE_LANGUAGES.map((lang)=>/*#__PURE__*/ _jsx("option", {
+                                        value: lang,
+                                        children: lang || 'plain'
+                                    }, lang))
+                            })
+                        ]
+                    })
+                ]
+            }) : table ? /*#__PURE__*/ _jsx(Box, {
+                sx: {
+                    overflowX: 'auto'
+                },
+                children: /*#__PURE__*/ _jsxs(Box, {
+                    component: "table",
+                    sx: {
+                        borderCollapse: 'collapse',
+                        width: '100%',
+                        fontSize: 14,
+                        '& th, & td': {
+                            border: '1px solid',
+                            borderColor: 'divider',
+                            px: 1,
+                            py: 0.5,
+                            minWidth: 64
+                        },
+                        '& th': {
+                            bgcolor: 'action.hover'
+                        },
+                        '& [contenteditable]': {
+                            outline: 'none'
+                        },
+                        '& [contenteditable]:focus': {
+                            boxShadow: (theme)=>`inset 0 0 0 2px ${theme.palette.primary.main}`
+                        }
+                    },
+                    children: [
+                        /*#__PURE__*/ _jsxs("thead", {
+                            children: [
+                                /*#__PURE__*/ _jsxs("tr", {
+                                    children: [
+                                        table.header.map((_cell, index)=>/*#__PURE__*/ _jsx("th", _extends({}, cellProps(-1, index), {
+                                                children: frozenHeader[index]
+                                            }), index)),
+                                        /*#__PURE__*/ _jsxs(Box, {
+                                            component: "th",
+                                            "data-md-block-controls": "",
+                                            sx: {
+                                                border: '0 !important',
+                                                bgcolor: 'transparent !important',
+                                                opacity: 0,
+                                                transition: 'opacity 120ms',
+                                                whiteSpace: 'nowrap'
+                                            },
+                                            children: [
+                                                /*#__PURE__*/ _jsx(Button, {
+                                                    size: "small",
+                                                    onMouseDown: (event)=>event.preventDefault(),
+                                                    onClick: ()=>onEdit((current)=>current.kind === 'table' ? _extends({}, current, {
+                                                                align: [
+                                                                    ...current.align,
+                                                                    'left'
+                                                                ],
+                                                                header: [
+                                                                    ...current.header,
+                                                                    []
+                                                                ],
+                                                                rows: current.rows.map((cells)=>[
+                                                                        ...cells,
+                                                                        []
+                                                                    ])
+                                                            }) : current),
+                                                    children: '+ Column'
+                                                }),
+                                                columns > 1 ? /*#__PURE__*/ _jsx(Button, {
+                                                    size: "small",
+                                                    color: "error",
+                                                    onMouseDown: (event)=>event.preventDefault(),
+                                                    onClick: ()=>onEdit((current)=>current.kind === 'table' ? _extends({}, current, {
+                                                                align: current.align.slice(0, -1),
+                                                                header: current.header.slice(0, -1),
+                                                                rows: current.rows.map((cells)=>cells.slice(0, -1))
+                                                            }) : current),
+                                                    children: '− Column'
+                                                }) : null
+                                            ]
+                                        })
+                                    ]
+                                }),
+                                /*#__PURE__*/ _jsxs(Box, {
+                                    component: "tr",
+                                    "data-md-block-controls": "",
+                                    sx: {
+                                        opacity: 0,
+                                        transition: 'opacity 120ms'
+                                    },
+                                    children: [
+                                        table.align.map((align, index)=>/*#__PURE__*/ _jsx(Box, {
+                                                component: "td",
+                                                sx: {
+                                                    border: '0 !important',
+                                                    p: '0 !important',
+                                                    textAlign: 'center'
+                                                },
+                                                children: /*#__PURE__*/ _jsxs(ToggleButtonGroup, {
+                                                    exclusive: true,
+                                                    size: "small",
+                                                    value: align,
+                                                    onChange: (_event, next)=>{
+                                                        if (!next) return;
+                                                        onEdit((current)=>current.kind === 'table' ? _extends({}, current, {
+                                                                align: current.align.map((entry, i)=>i === index ? next : entry)
+                                                            }) : current);
+                                                    },
+                                                    sx: {
+                                                        '& .MuiToggleButton-root': {
+                                                            px: 0.75,
+                                                            py: 0,
+                                                            border: 0
+                                                        }
+                                                    },
+                                                    children: [
+                                                        /*#__PURE__*/ _jsx(ToggleButton, {
+                                                            value: "left",
+                                                            "aria-label": "Align left",
+                                                            children: /*#__PURE__*/ _jsx(FormatAlignLeftIcon, {
+                                                                fontSize: "inherit"
+                                                            })
+                                                        }),
+                                                        /*#__PURE__*/ _jsx(ToggleButton, {
+                                                            value: "center",
+                                                            "aria-label": "Align center",
+                                                            children: /*#__PURE__*/ _jsx(FormatAlignCenterIcon, {
+                                                                fontSize: "inherit"
+                                                            })
+                                                        }),
+                                                        /*#__PURE__*/ _jsx(ToggleButton, {
+                                                            value: "right",
+                                                            "aria-label": "Align right",
+                                                            children: /*#__PURE__*/ _jsx(FormatAlignRightIcon, {
+                                                                fontSize: "inherit"
+                                                            })
+                                                        })
+                                                    ]
+                                                })
+                                            }, index)),
+                                        /*#__PURE__*/ _jsx(Box, {
+                                            component: "td",
+                                            sx: {
+                                                border: '0 !important'
+                                            }
+                                        })
+                                    ]
+                                })
+                            ]
+                        }),
+                        /*#__PURE__*/ _jsxs("tbody", {
+                            children: [
+                                table.rows.map((cells, rowIndex)=>/*#__PURE__*/ _jsxs("tr", {
+                                        children: [
+                                            cells.map((_cell, index)=>{
+                                                var _frozenRows_rowIndex;
+                                                return /*#__PURE__*/ _jsx("td", _extends({}, cellProps(rowIndex, index), {
+                                                    children: (_frozenRows_rowIndex = frozenRows[rowIndex]) == null ? void 0 : _frozenRows_rowIndex[index]
+                                                }), index);
+                                            }),
+                                            /*#__PURE__*/ _jsx(Box, {
+                                                component: "td",
+                                                "data-md-block-controls": "",
+                                                sx: {
+                                                    border: '0 !important',
+                                                    bgcolor: 'transparent !important',
+                                                    opacity: 0,
+                                                    transition: 'opacity 120ms'
+                                                },
+                                                children: /*#__PURE__*/ _jsx(Button, {
+                                                    size: "small",
+                                                    color: "error",
+                                                    onMouseDown: (event)=>event.preventDefault(),
+                                                    onClick: ()=>onEdit((current)=>current.kind === 'table' ? _extends({}, current, {
+                                                                rows: current.rows.filter((_cells, index)=>index !== rowIndex)
+                                                            }) : current),
+                                                    children: 'Delete row'
+                                                })
+                                            })
+                                        ]
+                                    }, rowIndex)),
+                                /*#__PURE__*/ _jsx("tr", {
+                                    children: /*#__PURE__*/ _jsx(Box, {
+                                        component: "td",
+                                        colSpan: columns + 1,
+                                        "data-md-block-controls": "",
+                                        sx: {
+                                            border: '0 !important',
+                                            opacity: 0,
+                                            transition: 'opacity 120ms'
+                                        },
+                                        children: /*#__PURE__*/ _jsx(Button, {
+                                            size: "small",
+                                            onMouseDown: (event)=>event.preventDefault(),
+                                            onClick: ()=>onEdit((current)=>current.kind === 'table' ? _extends({}, current, {
+                                                        rows: [
+                                                            ...current.rows,
+                                                            current.header.map(()=>[])
+                                                        ]
+                                                    }) : current),
+                                            children: '+ Row'
+                                        })
+                                    })
+                                })
+                            ]
+                        })
+                    ]
+                })
+            }) : null,
+            /*#__PURE__*/ _jsx(Button, {
+                size: "small",
+                color: "error",
+                variant: "contained",
+                "data-md-block-controls": "",
+                onMouseDown: (event)=>event.preventDefault(),
+                onClick: onRemove,
+                sx: {
+                    position: 'absolute',
+                    top: 8,
+                    right: 8,
+                    opacity: 0,
+                    transition: 'opacity 120ms'
+                },
+                children: 'Remove'
+            })
+        ]
+    });
+});
+const cloneRows = (rows)=>rows.map((row)=>isTextRow(row) ? _extends({}, row, {
+            inlines: row.inlines.map((inline)=>_extends({}, inline))
+        }) : // faithful history snapshot.
+        _extends({}, row));
+const HISTORY_LIMIT = 100;
+/**
+ * What the editor accepts is exactly what the PARSER keeps (AGL-1686).
+ *
+ * These were hand-rolled copies of the parser's rules, and the copy is what
+ * broke: AGL-1645 widened the image rule here to accept the site-relative
+ * `/api/media/cdn/{scope}/{id}` the media library hands back, while
+ * `markdown-lite`'s image rule stayed absolute-`http(s)`-only. The insert
+ * worked, serialized, saved — and the parser then dropped the block on the way
+ * back out, so the image was gone from the document, the preview and the
+ * published page with nothing logged anywhere.
+ *
+ * Delegating means the two can no longer disagree. Both still refuse
+ * protocol-relative `//host`, which would silently leave the site; images
+ * additionally accept a well-formed `media:` reference (AGL-1215), which is
+ * now what the media picker inserts.
+ */ const isValidLinkUrl = (url)=>isSupportedLinkHref(url);
+const isValidImageUrl = (url)=>isSupportedImageSrc(url);
+const MarkdownVisualEditor = /*#__PURE__*/ forwardRef(function MarkdownVisualEditor({ value, onChange, onPickImageFromMedia, onContextChange, minHeight = 280, maxHeight = 480 }, ref) {
+    var _rowsRef_current, _ref, _ref1;
+    const [version, setVersion] = useState(0);
+    const rowsRef = useRef(null);
+    if (rowsRef.current == null) rowsRef.current = markdownToRows(value);
+    const rootRef = useRef(null);
+    const lastEmittedRef = useRef(value);
+    const pendingSelectionRef = useRef(null);
+    const lastSelectionRef = useRef(null);
+    const historyRef = useRef({
+        past: [],
+        future: []
+    });
+    const typingBatchRef = useRef(false);
+    const typingTimerRef = useRef(null);
+    const dialogTargetRef = useRef(null);
+    const [urlDialog, setUrlDialog] = useState(null);
+    const [linkDialog, setLinkDialog] = useState(null);
+    const [linkPopover, setLinkPopover] = useState(null);
+    const [placeholderVisible, setPlaceholderVisible] = useState(()=>{
+        var _rowsRef_current;
+        return rowsToMarkdown((_rowsRef_current = rowsRef.current) != null ? _rowsRef_current : []).length === 0;
+    });
+    const rows = (_rowsRef_current = rowsRef.current) != null ? _rowsRef_current : [];
+    const emitChange = useCallback(()=>{
+        var _rowsRef_current;
+        const markdown = rowsToMarkdown((_rowsRef_current = rowsRef.current) != null ? _rowsRef_current : []);
+        lastEmittedRef.current = markdown;
+        setPlaceholderVisible(markdown.length === 0);
+        onChange(markdown);
+    }, [
+        onChange
+    ]);
+    // External updates (tab remount, AI assist rewriting the body): re-parse
+    // unless the incoming value is the one this editor just emitted.
+    useEffect(()=>{
+        if (value === lastEmittedRef.current) return;
+        rowsRef.current = markdownToRows(value);
+        lastEmittedRef.current = value;
+        historyRef.current = {
+            past: [],
+            future: []
+        };
+        pendingSelectionRef.current = null;
+        lastSelectionRef.current = null;
+        typingBatchRef.current = false;
+        setPlaceholderVisible(rowsToMarkdown(rowsRef.current).length === 0);
+        setVersion((current)=>current + 1);
+    }, [
+        value
+    ]);
+    const pushHistory = useCallback(()=>{
+        var _rowsRef_current;
+        const { past } = historyRef.current;
+        past.push({
+            rows: cloneRows((_rowsRef_current = rowsRef.current) != null ? _rowsRef_current : []),
+            selection: lastSelectionRef.current
+        });
+        if (past.length > HISTORY_LIMIT) past.shift();
+        historyRef.current.future = [];
+    }, []);
+    /** Re-renders every row from the model and restores the selection. */ const commit = useCallback((selection)=>{
+        pendingSelectionRef.current = selection;
+        if (selection) lastSelectionRef.current = selection;
+        typingBatchRef.current = false;
+        setVersion((current)=>current + 1);
+        emitChange();
+    }, [
+        emitChange
+    ]);
+    useLayoutEffect(()=>{
+        var _rootRef_current;
+        const pending = pendingSelectionRef.current;
+        if (!pending) return;
+        pendingSelectionRef.current = null;
+        const rowEl = (_rootRef_current = rootRef.current) == null ? void 0 : _rootRef_current.querySelector(`[data-row-key="${pending.key}"]`);
+        // Block rows (image / code / table) have no caret to restore. The
+        // attribute, not `isContentEditable` — jsdom does not compute the latter.
+        if (!rowEl || rowEl.getAttribute('contenteditable') !== 'true') return;
+        rowEl.focus();
+        setSelectionIn(rowEl, pending.start, pending.end);
+    }, [
+        version
+    ]);
+    const findRowIndex = useCallback((key)=>{
+        var _rowsRef_current;
+        return ((_rowsRef_current = rowsRef.current) != null ? _rowsRef_current : []).findIndex((row)=>row.key === key);
+    }, []);
+    /** Records the current DOM selection in model coordinates. */ const captureSelection = useCallback(()=>{
+        var _ref;
+        var _root_ownerDocument_defaultView_getSelection, _root_ownerDocument_defaultView;
+        const root = rootRef.current;
+        const selection = (_ref = root == null ? void 0 : (_root_ownerDocument_defaultView = root.ownerDocument.defaultView) == null ? void 0 : (_root_ownerDocument_defaultView_getSelection = _root_ownerDocument_defaultView.getSelection) == null ? void 0 : _root_ownerDocument_defaultView_getSelection.call(_root_ownerDocument_defaultView)) != null ? _ref : null;
+        if (!root || !selection || selection.rangeCount === 0) {
+            return lastSelectionRef.current;
+        }
+        const range = selection.getRangeAt(0);
+        const rowOf = (node)=>{
+            var _node_parentElement, _ref;
+            const el = node instanceof HTMLElement ? node : (_node_parentElement = node.parentElement) != null ? _node_parentElement : null;
+            const rowEl = (_ref = el == null ? void 0 : el.closest('[data-row-key]')) != null ? _ref : null;
+            return rowEl && root.contains(rowEl) ? rowEl : null;
+        };
+        const startRow = rowOf(range.startContainer);
+        const endRow = rowOf(range.endContainer);
+        // Cross-row selections are out of scope for phase 1 — keep last known.
+        if (!startRow || startRow !== endRow) return lastSelectionRef.current;
+        const key = startRow.dataset['rowKey'];
+        if (!key) return lastSelectionRef.current;
+        const offsets = selectionOffsetsWithin(startRow);
+        if (!offsets) return lastSelectionRef.current;
+        const snapshot = _extends({
+            key
+        }, offsets);
+        lastSelectionRef.current = snapshot;
+        return snapshot;
+    }, []);
+    /**
+   * Publishes the caret's formatting context (AGL-984). A collapsed caret
+   * reports the mark of the character BEHIND it — the same character the
+   * next keystroke would extend. Deduped, so a toolbar re-renders only when
+   * something it draws actually changed.
+   */ const contextKeyRef = useRef('');
+    const onContextChangeRef = useRef(onContextChange);
+    onContextChangeRef.current = onContextChange;
+    const reportContext = useCallback(()=>{
+        var _rowsRef_current;
+        const notify = onContextChangeRef.current;
+        if (!notify) return;
+        const selection = lastSelectionRef.current;
+        const rows = (_rowsRef_current = rowsRef.current) != null ? _rowsRef_current : [];
+        const row = selection ? rows.find((entry)=>entry.key === selection.key) : undefined;
+        let context = {
+            bold: false,
+            italic: false,
+            kind: null
+        };
+        if (selection && row && isTextRow(row)) {
+            const from = selection.start === selection.end ? Math.max(0, selection.start - 1) : selection.start;
+            const covered = sliceInlines(row.inlines, from, selection.end);
+            context = {
+                bold: covered.length > 0 && covered.every((inline)=>inline.type === 'bold'),
+                italic: covered.length > 0 && covered.every((inline)=>inline.type === 'italic'),
+                kind: row.kind
+            };
+        }
+        const key = `${context.bold}:${context.italic}:${context.kind}`;
+        if (key === contextKeyRef.current) return;
+        contextKeyRef.current = key;
+        notify(context);
+    }, []);
+    const handleSelectionPing = useCallback(()=>{
+        captureSelection();
+        reportContext();
+    }, [
+        captureSelection,
+        reportContext
+    ]);
+    // A structural edit moves the caret without a ping of its own.
+    useEffect(()=>{
+        reportContext();
+    }, [
+        version,
+        reportContext
+    ]);
+    const undo = useCallback(()=>{
+        var _rowsRef_current;
+        const { past, future } = historyRef.current;
+        const entry = past.pop();
+        if (!entry) return;
+        future.push({
+            rows: cloneRows((_rowsRef_current = rowsRef.current) != null ? _rowsRef_current : []),
+            selection: lastSelectionRef.current
+        });
+        rowsRef.current = cloneRows(entry.rows);
+        typingBatchRef.current = false;
+        pendingSelectionRef.current = entry.selection;
+        setVersion((current)=>current + 1);
+        emitChange();
+    }, [
+        emitChange
+    ]);
+    const redo = useCallback(()=>{
+        var _rowsRef_current;
+        const { past, future } = historyRef.current;
+        const entry = future.pop();
+        if (!entry) return;
+        past.push({
+            rows: cloneRows((_rowsRef_current = rowsRef.current) != null ? _rowsRef_current : []),
+            selection: lastSelectionRef.current
+        });
+        rowsRef.current = cloneRows(entry.rows);
+        typingBatchRef.current = false;
+        pendingSelectionRef.current = entry.selection;
+        setVersion((current)=>current + 1);
+        emitChange();
+    }, [
+        emitChange
+    ]);
+    /** Resolves where a toolbar command applies: selection or document end. */ const resolveTarget = useCallback(()=>{
+        var _rowsRef_current;
+        const current = (_rowsRef_current = rowsRef.current) != null ? _rowsRef_current : [];
+        const selection = captureSelection();
+        if (selection) {
+            const index = current.findIndex((row)=>row.key === selection.key);
+            const row = current[index];
+            if (index >= 0 && row && isTextRow(row)) {
+                return {
+                    index,
+                    start: selection.start,
+                    end: selection.end
+                };
+            }
+        }
+        for(let index = current.length - 1; index >= 0; index--){
+            const row = current[index];
+            if (row && isTextRow(row)) {
+                const length = rowPlainText(row.inlines).length;
+                return {
+                    index,
+                    start: length,
+                    end: length
+                };
+            }
+        }
+        return null;
+    }, [
+        captureSelection
+    ]);
+    /** Splices a block row in after `afterIndex` (end of document if null). */ const insertBlockRow = useCallback((block, afterIndex)=>{
+        var _rowsRef_current;
+        const current = (_rowsRef_current = rowsRef.current) != null ? _rowsRef_current : [];
+        pushHistory();
+        const index = afterIndex == null ? current.length : afterIndex + 1;
+        current.splice(index, 0, _extends({
+            key: nextRowKey()
+        }, block));
+        // Keep a caret landing spot after a trailing block.
+        if (index === current.length - 1) current.push(emptyParagraph());
+        const next = current[index + 1];
+        commit(next && isTextRow(next) ? {
+            key: next.key,
+            start: 0,
+            end: 0
+        } : null);
+    }, [
+        commit,
+        pushHistory
+    ]);
+    const insertImageRow = useCallback((alt, url, afterIndex)=>{
+        if (!isValidImageUrl(url)) return;
+        insertBlockRow({
+            kind: 'image',
+            src: url,
+            alt
+        }, afterIndex);
+    }, [
+        insertBlockRow
+    ]);
+    /** Edits one block row in place; `silent` skips the re-render (AGL-983). */ const editBlockRow = useCallback((key, mutate, silent)=>{
+        var _rowsRef_current;
+        const current = (_rowsRef_current = rowsRef.current) != null ? _rowsRef_current : [];
+        const index = findRowIndex(key);
+        const row = current[index];
+        if (!row || isTextRow(row)) return;
+        // Typing in a cell or a snippet batches its history the same way
+        // typing in a paragraph does: one undo step per burst, not per key.
+        if (silent) {
+            if (!typingBatchRef.current) {
+                pushHistory();
+                typingBatchRef.current = true;
+            }
+            if (typingTimerRef.current) clearTimeout(typingTimerRef.current);
+            typingTimerRef.current = setTimeout(()=>{
+                typingBatchRef.current = false;
+            }, 800);
+        } else {
+            pushHistory();
+        }
+        current[index] = mutate(row);
+        if (silent) emitChange();
+        else commit(null);
+    }, [
+        commit,
+        emitChange,
+        findRowIndex,
+        pushHistory
+    ]);
+    const execCommand = useCallback((command)=>{
+        var _rowsRef_current;
+        const current = (_rowsRef_current = rowsRef.current) != null ? _rowsRef_current : [];
+        const target = resolveTarget();
+        if (command === 'image') {
+            // URL prompt dialog; when the host page wires
+            // `onPickImageFromMedia` it also offers the media picker (AGL-596).
+            dialogTargetRef.current = target;
+            setUrlDialog({
+                kind: 'image',
+                url: '',
+                text: ''
+            });
+            return;
+        }
+        // Block inserts (AGL-983) land after the caret row, like an image.
+        if (command === 'code') {
+            var _ref;
+            insertBlockRow({
+                kind: 'code',
+                lang: '',
+                text: ''
+            }, (_ref = target == null ? void 0 : target.index) != null ? _ref : null);
+            return;
+        }
+        if (command === 'table') {
+            var _ref1;
+            const empty = ()=>[
+                    [],
+                    []
+                ];
+            insertBlockRow({
+                kind: 'table',
+                align: [
+                    'left',
+                    'left'
+                ],
+                header: empty(),
+                rows: [
+                    empty(),
+                    empty()
+                ]
+            }, (_ref1 = target == null ? void 0 : target.index) != null ? _ref1 : null);
+            return;
+        }
+        if (!target) return;
+        const row = current[target.index];
+        // Block-kind toggles: pressing the row's own kind returns it to prose.
+        const toggleKind = (kind)=>{
+            pushHistory();
+            current[target.index] = _extends({}, row, {
+                kind: row.kind === kind ? 'paragraph' : kind
+            });
+            commit({
+                key: row.key,
+                start: target.start,
+                end: target.end
+            });
+        };
+        if (command === 'heading') return toggleKind('heading2');
+        if (command === 'heading3') return toggleKind('heading3');
+        if (command === 'list') return toggleKind('listItem');
+        if (command === 'orderedList') return toggleKind('orderedItem');
+        if (command === 'quote') return toggleKind('quote');
+        if (command === 'link') {
+            dialogTargetRef.current = target;
+            setLinkDialog({
+                text: rowPlainText(sliceInlines(row.inlines, target.start, target.end))
+            });
+            return;
+        }
+        pushHistory();
+        if (target.start === target.end) {
+            const placeholder = command === 'bold' ? 'bold text' : 'italic text';
+            current[target.index] = _extends({}, row, {
+                inlines: replaceInlineRange(row.inlines, target.start, target.end, [
+                    {
+                        type: command,
+                        text: placeholder
+                    }
+                ])
+            });
+            commit({
+                key: row.key,
+                start: target.start,
+                end: target.start + placeholder.length
+            });
+            return;
+        }
+        const toggled = toggleInlineMark(row.inlines, target.start, target.end, command);
+        current[target.index] = _extends({}, row, {
+            inlines: toggled.inlines
+        });
+        commit({
+            key: row.key,
+            start: target.start,
+            end: target.start + toggled.length
+        });
+    }, [
+        commit,
+        insertBlockRow,
+        pushHistory,
+        resolveTarget
+    ]);
+    useImperativeHandle(ref, ()=>({
+            exec: execCommand,
+            insertImage: (alt, url)=>{
+                const selection = lastSelectionRef.current;
+                const index = selection ? findRowIndex(selection.key) : -1;
+                insertImageRow(alt, url, index >= 0 ? index : null);
+            }
+        }), [
+        execCommand,
+        findRowIndex,
+        insertImageRow
+    ]);
+    const handleRowInput = useCallback((key)=>(event)=>{
+            var _rowsRef_current;
+            const current = (_rowsRef_current = rowsRef.current) != null ? _rowsRef_current : [];
+            const index = findRowIndex(key);
+            const row = current[index];
+            if (!row || !isTextRow(row)) return;
+            const rowEl = event.currentTarget;
+            // Snapshot the pre-typing model once per typing burst so undo jumps
+            // back over the whole burst, not one character at a time.
+            if (!typingBatchRef.current) {
+                pushHistory();
+                typingBatchRef.current = true;
+            }
+            if (typingTimerRef.current) clearTimeout(typingTimerRef.current);
+            typingTimerRef.current = setTimeout(()=>{
+                typingBatchRef.current = false;
+            }, 800);
+            const inlines = readInlinesFromElement(rowEl);
+            const text = rowPlainText(inlines);
+            // Markdown shortcuts (AGL-582): "## " / "### " / "- " at the start
+            // of a paragraph convert it to a heading or list item. "# " joins them
+            // (AGL-1082) so typing a heading agrees with pasting one — the parser
+            // clamps a single `#` to the top rendered level too. "1. " / "1) "
+            // opens a numbered list at the number that was typed (AGL-1320).
+            if (row.kind === 'paragraph') {
+                const numbered = /^(\d{1,9})[.)] /.exec(text);
+                const shortcut = text.startsWith('### ') ? {
+                    kind: 'heading3',
+                    trim: 4
+                } : text.startsWith('## ') ? {
+                    kind: 'heading2',
+                    trim: 3
+                } : text.startsWith('# ') ? {
+                    kind: 'heading2',
+                    trim: 2
+                } : text.startsWith('- ') ? {
+                    kind: 'listItem',
+                    trim: 2
+                } : text.startsWith('> ') ? {
+                    kind: 'quote',
+                    trim: 2
+                } : numbered ? {
+                    kind: 'orderedItem',
+                    trim: numbered[0].length,
+                    start: Number(numbered[1])
+                } : null;
+                if (shortcut) {
+                    var _ref;
+                    var _selectionOffsetsWithin;
+                    const caret = (_ref = (_selectionOffsetsWithin = selectionOffsetsWithin(rowEl)) == null ? void 0 : _selectionOffsetsWithin.start) != null ? _ref : text.length;
+                    const offset = Math.max(0, caret - shortcut.trim);
+                    current[index] = _extends({
+                        key: row.key,
+                        kind: shortcut.kind,
+                        inlines: sliceInlines(inlines, shortcut.trim, Infinity)
+                    }, 'start' in shortcut ? {
+                        start: shortcut.start
+                    } : {});
+                    commit({
+                        key: row.key,
+                        start: offset,
+                        end: offset
+                    });
+                    return;
+                }
+            }
+            // Plain typing: sync the model silently — no re-render, the DOM is
+            // already correct and the caret must not move.
+            current[index] = _extends({}, row, {
+                inlines
+            });
+            emitChange();
+        }, [
+        commit,
+        emitChange,
+        findRowIndex,
+        pushHistory
+    ]);
+    const focusAdjacentRow = useCallback((fromIndex, direction, preferredOffset)=>{
+        var _rowsRef_current;
+        const current = (_rowsRef_current = rowsRef.current) != null ? _rowsRef_current : [];
+        for(let index = fromIndex + direction; index >= 0 && index < current.length; index += direction){
+            var _rootRef_current;
+            const row = current[index];
+            if (!row || !isTextRow(row)) continue;
+            const rowEl = (_rootRef_current = rootRef.current) == null ? void 0 : _rootRef_current.querySelector(`[data-row-key="${row.key}"]`);
+            if (!rowEl) return;
+            const length = rowPlainText(row.inlines).length;
+            const offset = Math.min(Math.max(preferredOffset, 0), length);
+            rowEl.focus();
+            setSelectionIn(rowEl, offset, offset);
+            captureSelection();
+            return;
+        }
+    }, [
+        captureSelection
+    ]);
+    const handleRowKeyDown = useCallback((key)=>(event)=>{
+            var _rowsRef_current;
+            if (event.nativeEvent.isComposing) return;
+            const current = (_rowsRef_current = rowsRef.current) != null ? _rowsRef_current : [];
+            const index = findRowIndex(key);
+            const row = current[index];
+            if (!row || !isTextRow(row)) return;
+            const rowEl = event.currentTarget;
+            if (event.key === 'Enter') {
+                var _selectionOffsetsWithin;
+                event.preventDefault();
+                const inlines = readInlinesFromElement(rowEl);
+                const length = rowPlainText(inlines).length;
+                const offsets = (_selectionOffsetsWithin = selectionOffsetsWithin(rowEl)) != null ? _selectionOffsetsWithin : {
+                    start: length,
+                    end: length
+                };
+                current[index] = _extends({}, row, {
+                    inlines
+                });
+                pushHistory();
+                // Enter on an empty list item exits the list into a paragraph.
+                if ((row.kind === 'listItem' || row.kind === 'orderedItem') && length === 0) {
+                    current[index] = {
+                        key: row.key,
+                        kind: 'paragraph',
+                        inlines: []
+                    };
+                    commit({
+                        key: row.key,
+                        start: 0,
+                        end: 0
+                    });
+                    return;
+                }
+                const before = sliceInlines(inlines, 0, offsets.start);
+                const after = sliceInlines(inlines, offsets.end, Infinity);
+                // Splitting a heading leaves prose behind; lists continue as items.
+                // The continuation deliberately carries NO `start` (AGL-1320) — only
+                // the row that opens a run numbers it.
+                const nextKind = row.kind === 'listItem' || row.kind === 'orderedItem' ? row.kind : 'paragraph';
+                const newRow = {
+                    key: nextRowKey(),
+                    kind: nextKind,
+                    inlines: after
+                };
+                current[index] = _extends({}, row, {
+                    inlines: before
+                });
+                current.splice(index + 1, 0, newRow);
+                commit({
+                    key: newRow.key,
+                    start: 0,
+                    end: 0
+                });
+                return;
+            }
+            if (event.key === 'Backspace') {
+                const offsets = selectionOffsetsWithin(rowEl);
+                if (!offsets || offsets.start !== 0 || offsets.end !== 0) return;
+                event.preventDefault();
+                const inlines = readInlinesFromElement(rowEl);
+                current[index] = _extends({}, row, {
+                    inlines
+                });
+                // Backspace at the start of a heading/list item demotes it first.
+                if (row.kind !== 'paragraph') {
+                    pushHistory();
+                    current[index] = {
+                        key: row.key,
+                        kind: 'paragraph',
+                        inlines
+                    };
+                    commit({
+                        key: row.key,
+                        start: 0,
+                        end: 0
+                    });
+                    return;
+                }
+                if (index === 0) return;
+                const previous = current[index - 1];
+                if (!previous) return;
+                pushHistory();
+                if (!isTextRow(previous)) {
+                    current.splice(index - 1, 1);
+                    commit({
+                        key: row.key,
+                        start: 0,
+                        end: 0
+                    });
+                    return;
+                }
+                const junction = rowPlainText(previous.inlines).length;
+                current[index - 1] = _extends({}, previous, {
+                    inlines: normalizeInlines([
+                        ...previous.inlines,
+                        ...inlines
+                    ])
+                });
+                current.splice(index, 1);
+                commit({
+                    key: previous.key,
+                    start: junction,
+                    end: junction
+                });
+                return;
+            }
+            // Caret hops across row boundaries (separate contentEditables).
+            if (event.shiftKey || event.metaKey || event.ctrlKey || event.altKey) {
+                return;
+            }
+            if (event.key === 'ArrowLeft' || event.key === 'ArrowRight') {
+                const offsets = selectionOffsetsWithin(rowEl);
+                if (!offsets || offsets.start !== offsets.end) return;
+                const length = rowPlainText(readInlinesFromElement(rowEl)).length;
+                if (event.key === 'ArrowLeft' && offsets.start === 0) {
+                    event.preventDefault();
+                    focusAdjacentRow(index, -1, Infinity);
+                } else if (event.key === 'ArrowRight' && offsets.start >= length) {
+                    event.preventDefault();
+                    focusAdjacentRow(index, 1, 0);
+                }
+                return;
+            }
+            if (event.key === 'ArrowUp' || event.key === 'ArrowDown') {
+                const before = selectionOffsetsWithin(rowEl);
+                if (!before) return;
+                const direction = event.key === 'ArrowDown' ? 1 : -1;
+                // If the browser can't move within the row (first/last line), the
+                // selection stays put — hop to the adjacent row instead.
+                setTimeout(()=>{
+                    const after = selectionOffsetsWithin(rowEl);
+                    if (!after) return;
+                    if (after.start !== before.start || after.end !== before.end) return;
+                    focusAdjacentRow(index, direction, before.start);
+                }, 0);
+            }
+        }, [
+        commit,
+        findRowIndex,
+        focusAdjacentRow,
+        pushHistory
+    ]);
+    const handleRowPaste = useCallback((key)=>(event)=>{
+            var _rowsRef_current, _selectionOffsetsWithin, _ref, _ref1;
+            var _event_clipboardData, _event_clipboardData1;
+            event.preventDefault();
+            const current = (_rowsRef_current = rowsRef.current) != null ? _rowsRef_current : [];
+            const index = findRowIndex(key);
+            const row = current[index];
+            if (!row || !isTextRow(row)) return;
+            const rowEl = event.currentTarget;
+            const inlines = readInlinesFromElement(rowEl);
+            const length = rowPlainText(inlines).length;
+            const offsets = (_selectionOffsetsWithin = selectionOffsetsWithin(rowEl)) != null ? _selectionOffsetsWithin : {
+                start: length,
+                end: length
+            };
+            // Rich clipboard first (AGL-596): text/html converts to rows so
+            // bold/italic/links, headings, lists and images survive the paste.
+            const html = (_ref = (_event_clipboardData = event.clipboardData) == null ? void 0 : _event_clipboardData.getData('text/html')) != null ? _ref : '';
+            if (html) {
+                // Re-key onto this editor's sequence — converted keys are
+                // module-local placeholders and must not collide across pastes.
+                const converted = htmlToRows(html).map((pasted)=>_extends({}, pasted, {
+                        key: nextRowKey()
+                    }));
+                const only = converted.length === 1 ? converted[0] : undefined;
+                if (only && isTextRow(only)) {
+                    // One text row: merge its inlines into this row at the caret,
+                    // exactly like a plain-text paste but keeping the marks.
+                    current[index] = _extends({}, row, {
+                        inlines
+                    });
+                    pushHistory();
+                    current[index] = _extends({}, row, {
+                        inlines: replaceInlineRange(inlines, offsets.start, offsets.end, only.inlines)
+                    });
+                    const caret = offsets.start + rowPlainText(only.inlines).length;
+                    commit({
+                        key: row.key,
+                        start: caret,
+                        end: caret
+                    });
+                    return;
+                }
+                if (converted.length > 0) {
+                    // Multi-row (or image) paste: splice whole rows in after this
+                    // one — no splitting of the current row.
+                    current[index] = _extends({}, row, {
+                        inlines
+                    });
+                    pushHistory();
+                    const tail = converted[converted.length - 1];
+                    if (tail && !isTextRow(tail)) converted.push(emptyParagraph());
+                    current.splice(index + 1, 0, ...converted);
+                    const focus = converted[converted.length - 1];
+                    if (focus && isTextRow(focus)) {
+                        const end = rowPlainText(focus.inlines).length;
+                        commit({
+                            key: focus.key,
+                            start: end,
+                            end
+                        });
+                    } else {
+                        commit(null);
+                    }
+                    return;
+                }
+            // Nothing usable in the HTML — fall through to text/plain.
+            }
+            const text = (_ref1 = (_event_clipboardData1 = event.clipboardData) == null ? void 0 : _event_clipboardData1.getData('text/plain')) != null ? _ref1 : '';
+            if (!text) return;
+            const flattened = text.replace(/\s*\n+\s*/g, ' ');
+            current[index] = _extends({}, row, {
+                inlines
+            });
+            pushHistory();
+            current[index] = _extends({}, row, {
+                inlines: replaceInlineRange(inlines, offsets.start, offsets.end, [
+                    {
+                        type: 'text',
+                        text: flattened
+                    }
+                ])
+            });
+            const caret = offsets.start + flattened.length;
+            commit({
+                key: row.key,
+                start: caret,
+                end: caret
+            });
+        }, [
+        commit,
+        findRowIndex,
+        pushHistory
+    ]);
+    const handleRowClick = useCallback((key)=>(event)=>{
+            const target = event.target.closest == null ? void 0 : event.target.closest.call(event.target, '[data-md-link]');
+            if (target && event.currentTarget.contains(target)) {
+                var _target_getAttribute;
+                const links = Array.from(event.currentTarget.querySelectorAll('[data-md-link]'));
+                setLinkPopover({
+                    anchor: target,
+                    rowKey: key,
+                    linkIndex: links.indexOf(target),
+                    href: (_target_getAttribute = target.getAttribute('data-md-href')) != null ? _target_getAttribute : ''
+                });
+            }
+            captureSelection();
+        }, [
+        captureSelection
+    ]);
+    /** Nth link inline of a row (document order matches inline order). */ const findLinkInline = useCallback((rowKey, linkIndex)=>{
+        var _rowsRef_current;
+        const index = findRowIndex(rowKey);
+        const row = ((_rowsRef_current = rowsRef.current) != null ? _rowsRef_current : [])[index];
+        if (!row || !isTextRow(row)) return null;
+        let seen = -1;
+        for(let i = 0; i < row.inlines.length; i++){
+            const inline = row.inlines[i];
+            if ((inline == null ? void 0 : inline.type) === 'link' && ++seen === linkIndex) {
+                return {
+                    rowIndex: index,
+                    row,
+                    inlineIndex: i,
+                    inline
+                };
+            }
+        }
+        return null;
+    }, [
+        findRowIndex
+    ]);
+    const handleLinkRemove = useCallback(()=>{
+        var _rowsRef_current;
+        if (!linkPopover) return;
+        const found = findLinkInline(linkPopover.rowKey, linkPopover.linkIndex);
+        setLinkPopover(null);
+        if (!found) return;
+        pushHistory();
+        const inlines = [
+            ...found.row.inlines
+        ];
+        inlines[found.inlineIndex] = {
+            type: 'text',
+            text: found.inline.text
+        };
+        const current = (_rowsRef_current = rowsRef.current) != null ? _rowsRef_current : [];
+        current[found.rowIndex] = _extends({}, found.row, {
+            inlines: normalizeInlines(inlines)
+        });
+        commit(null);
+    }, [
+        commit,
+        findLinkInline,
+        linkPopover,
+        pushHistory
+    ]);
+    const handleLinkEdit = useCallback(()=>{
+        if (!linkPopover) return;
+        setLinkDialog({
+            href: linkPopover.href,
+            text: '',
+            editRowKey: linkPopover.rowKey,
+            editLinkIndex: linkPopover.linkIndex
+        });
+        setLinkPopover(null);
+    }, [
+        linkPopover
+    ]);
+    const handleUrlDialogConfirm = useCallback(()=>{
+        if (!urlDialog) return;
+        const url = urlDialog.url.trim();
+        if (!isValidImageUrl(url)) return;
+        const target = dialogTargetRef.current;
+        setUrlDialog(null);
+        insertImageRow(urlDialog.text.trim(), url, target ? target.index : null);
+    }, [
+        insertImageRow,
+        urlDialog
+    ]);
+    /**
+   * The link dialog's answer: a URL as typed, or a reference the dialog's
+   * lookup produced (AGL-3119). Both are `href` on the same inline — the
+   * dialect keeps either, and the renderer resolves the reference.
+   */ const handleLinkConfirm = useCallback((link)=>{
+        var _rowsRef_current;
+        if (!linkDialog) return;
+        const href = link.href.trim();
+        if (!isValidLinkUrl(href)) return;
+        const current = (_rowsRef_current = rowsRef.current) != null ? _rowsRef_current : [];
+        if (linkDialog.editRowKey != null && linkDialog.editLinkIndex != null) {
+            const found = findLinkInline(linkDialog.editRowKey, linkDialog.editLinkIndex);
+            setLinkDialog(null);
+            if (!found) return;
+            pushHistory();
+            const inlines = [
+                ...found.row.inlines
+            ];
+            inlines[found.inlineIndex] = {
+                type: 'link',
+                text: found.inline.text,
+                href
+            };
+            current[found.rowIndex] = _extends({}, found.row, {
+                inlines
+            });
+            commit(null);
+            return;
+        }
+        const target = dialogTargetRef.current;
+        setLinkDialog(null);
+        if (!target) return;
+        const row = current[target.index];
+        if (!row || !isTextRow(row)) return;
+        pushHistory();
+        const text = link.text.trim() || href;
+        current[target.index] = _extends({}, row, {
+            inlines: replaceInlineRange(row.inlines, target.start, target.end, [
+                {
+                    type: 'link',
+                    text,
+                    href
+                }
+            ])
+        });
+        commit({
+            key: row.key,
+            start: target.start,
+            end: target.start + text.length
+        });
+    }, [
+        commit,
+        findLinkInline,
+        linkDialog,
+        pushHistory
+    ]);
+    const handleBlockRemove = useCallback((key)=>()=>{
+            var _rowsRef_current;
+            const current = (_rowsRef_current = rowsRef.current) != null ? _rowsRef_current : [];
+            const index = findRowIndex(key);
+            if (index < 0) return;
+            pushHistory();
+            current.splice(index, 1);
+            if (current.length === 0) current.push(emptyParagraph());
+            commit(null);
+        }, [
+        commit,
+        findRowIndex,
+        pushHistory
+    ]);
+    const handleRootKeyDown = useCallback((event)=>{
+        if (event.defaultPrevented) return;
+        const key = event.key.toLowerCase();
+        if ((event.metaKey || event.ctrlKey) && !event.altKey) {
+            if (key === 'z') {
+                // Model-driven rendering breaks native contentEditable undo, so
+                // the editor keeps its own snapshot stack (AGL-582).
+                event.preventDefault();
+                if (event.shiftKey) redo();
+                else undo();
+                return;
+            }
+            if (key === 'y' && event.ctrlKey && !event.shiftKey) {
+                event.preventDefault();
+                redo();
+                return;
+            }
+            if (event.shiftKey) return;
+            if (key === 'b') {
+                event.preventDefault();
+                execCommand('bold');
+                return;
+            }
+            if (key === 'i') {
+                event.preventDefault();
+                execCommand('italic');
+            }
+        }
+    }, [
+        execCommand,
+        redo,
+        undo
+    ]);
+    /** Clicking the padding below the last row puts the caret at the end. */ const handleRootMouseDown = useCallback((event)=>{
+        var _rowsRef_current;
+        if (event.target !== rootRef.current) return;
+        event.preventDefault();
+        const current = (_rowsRef_current = rowsRef.current) != null ? _rowsRef_current : [];
+        for(let index = current.length - 1; index >= 0; index--){
+            var _rootRef_current;
+            const row = current[index];
+            if (!row || !isTextRow(row)) continue;
+            const rowEl = (_rootRef_current = rootRef.current) == null ? void 0 : _rootRef_current.querySelector(`[data-row-key="${row.key}"]`);
+            if (!rowEl) return;
+            const length = rowPlainText(row.inlines).length;
+            rowEl.focus();
+            setSelectionIn(rowEl, length, length);
+            captureSelection();
+            return;
+        }
+    }, [
+        captureSelection
+    ]);
+    const urlDialogValid = urlDialog != null && isValidImageUrl(urlDialog.url.trim());
+    return /*#__PURE__*/ _jsxs(_Fragment, {
+        children: [
+            /*#__PURE__*/ _jsxs(Box, {
+                ref: rootRef,
+                "data-testid": "markdown-visual-editor",
+                onKeyDown: handleRootKeyDown,
+                onMouseDown: handleRootMouseDown,
+                // Clicking into a table cell or a snippet is a selection change the
+                // text rows never see; the toolbar still has to hear about it.
+                onMouseUp: handleSelectionPing,
+                onKeyUp: handleSelectionPing,
+                sx: {
+                    position: 'relative',
+                    border: '1px solid',
+                    borderColor: 'divider',
+                    borderRadius: 1,
+                    px: 2,
+                    py: 1.5,
+                    minHeight,
+                    maxHeight,
+                    overflow: 'auto',
+                    cursor: 'text',
+                    // Seeds the numbered-row counter (AGL-1320) so a document that
+                    // OPENS with `1. ` has one to increment.
+                    counterReset: 'md-ordered 0',
+                    '&:focus-within': {
+                        borderColor: 'primary.main'
+                    },
+                    // Typography mirrors the tenant's Entry Body rendering (AGL-551)
+                    // so the editing surface reads like the published article.
+                    '& [data-row-kind]': {
+                        outline: 'none',
+                        whiteSpace: 'pre-wrap',
+                        wordBreak: 'break-word'
+                    },
+                    '& [data-row-kind="paragraph"]': {
+                        typography: 'body1',
+                        lineHeight: 1.7,
+                        my: 0.75
+                    },
+                    '& [data-row-kind="heading2"]': {
+                        typography: 'h5',
+                        mt: 2,
+                        mb: 1
+                    },
+                    '& [data-row-kind="heading3"]': {
+                        typography: 'h6',
+                        mt: 1.5,
+                        mb: 0.75
+                    },
+                    '& [data-row-kind="listItem"]': {
+                        typography: 'body1',
+                        lineHeight: 1.7,
+                        display: 'list-item',
+                        listStyleType: 'disc',
+                        ml: 3,
+                        my: 0.25
+                    },
+                    // Numbered rows (AGL-1320). Rows are siblings, not children of an
+                    // `<ol>`, so the markers come from an explicit counter rather than
+                    // `list-style-type: decimal` — the implicit list-item counter is
+                    // shared with the bullet rows above and would keep counting through
+                    // them. Every non-ordered row RESETS it, which is what ends a run:
+                    // a counter-reset scopes to the element and its following siblings.
+                    // The run's opener additionally seeds it from `start` inline.
+                    '& [data-row-kind]:not([data-row-kind="orderedItem"])': {
+                        counterReset: 'md-ordered 0'
+                    },
+                    '& [data-row-kind="orderedItem"]': {
+                        typography: 'body1',
+                        lineHeight: 1.7,
+                        counterIncrement: 'md-ordered',
+                        position: 'relative',
+                        ml: 3,
+                        my: 0.25,
+                        '&::before': {
+                            content: 'counter(md-ordered) ". "',
+                            position: 'absolute',
+                            right: '100%',
+                            pr: 0.5,
+                            color: 'text.secondary'
+                        }
+                    },
+                    // The tenant's pull-quote treatment (AGL-1315), at editor scale.
+                    '& [data-row-kind="quote"]': {
+                        typography: 'body1',
+                        lineHeight: 1.6,
+                        fontStyle: 'italic',
+                        borderLeft: '3px solid',
+                        borderColor: 'primary.main',
+                        pl: 2,
+                        my: 1
+                    },
+                    '& [data-md-link]': {
+                        color: 'primary.main',
+                        textDecoration: 'underline',
+                        cursor: 'pointer'
+                    },
+                    '& img': {
+                        maxWidth: '100%',
+                        borderRadius: 1
+                    }
+                },
+                children: [
+                    placeholderVisible ? /*#__PURE__*/ _jsx(Typography, {
+                        variant: "body1",
+                        color: "text.disabled",
+                        sx: {
+                            position: 'absolute',
+                            top: 12,
+                            left: 16,
+                            pointerEvents: 'none'
+                        },
+                        children: 'Start writing…'
+                    }) : null,
+                    rows.map((row)=>!isTextRow(row) ? /*#__PURE__*/ _jsx(BlockRowView, {
+                            row: row,
+                            version: version,
+                            onEdit: (mutate)=>editBlockRow(row.key, mutate, false),
+                            onEditSilently: (mutate)=>editBlockRow(row.key, mutate, true),
+                            onRemove: handleBlockRemove(row.key)
+                        }, `${row.key}:${version}`) : /*#__PURE__*/ _jsx(TextRowView, {
+                            row: row,
+                            version: version,
+                            onInput: handleRowInput(row.key),
+                            onKeyDown: handleRowKeyDown(row.key),
+                            onPaste: handleRowPaste(row.key),
+                            onClick: handleRowClick(row.key),
+                            onSelectionPing: handleSelectionPing
+                        }, row.key))
+                ]
+            }),
+            /*#__PURE__*/ _jsx(Popover, {
+                open: Boolean(linkPopover),
+                anchorEl: (_ref = linkPopover == null ? void 0 : linkPopover.anchor) != null ? _ref : null,
+                onClose: ()=>setLinkPopover(null),
+                anchorOrigin: {
+                    vertical: 'bottom',
+                    horizontal: 'left'
+                },
+                children: /*#__PURE__*/ _jsxs(Stack, {
+                    direction: "row",
+                    spacing: 1,
+                    sx: {
+                        px: 1.5,
+                        py: 1,
+                        alignItems: 'center',
+                        maxWidth: 420
+                    },
+                    children: [
+                        /*#__PURE__*/ _jsx(Typography, {
+                            variant: "caption",
+                            color: "text.secondary",
+                            noWrap: true,
+                            sx: {
+                                maxWidth: 240
+                            },
+                            children: linkPopover ? /*#__PURE__*/ _jsx(MarkdownLinkTargetName, {
+                                href: linkPopover.href
+                            }) : null
+                        }),
+                        /*#__PURE__*/ _jsx(Button, {
+                            size: "small",
+                            onClick: handleLinkEdit,
+                            children: 'Edit'
+                        }),
+                        /*#__PURE__*/ _jsx(Button, {
+                            size: "small",
+                            color: "error",
+                            onClick: handleLinkRemove,
+                            children: 'Remove'
+                        })
+                    ]
+                })
+            }),
+            /*#__PURE__*/ _jsxs(Dialog, {
+                open: Boolean(urlDialog),
+                onClose: ()=>setUrlDialog(null),
+                maxWidth: "xs",
+                fullWidth: true,
+                children: [
+                    /*#__PURE__*/ _jsx(DialogTitle, {
+                        children: 'Insert image'
+                    }),
+                    /*#__PURE__*/ _jsxs(DialogContent, {
+                        sx: {
+                            display: 'flex',
+                            flexDirection: 'column',
+                            gap: 2,
+                            pt: 1
+                        },
+                        children: [
+                            /*#__PURE__*/ _jsx(TextField, {
+                                label: "URL",
+                                value: (_ref1 = urlDialog == null ? void 0 : urlDialog.url) != null ? _ref1 : '',
+                                onChange: (event)=>setUrlDialog((prev)=>prev ? _extends({}, prev, {
+                                            url: event.target.value
+                                        }) : prev),
+                                onKeyDown: (event)=>{
+                                    if (event.key === 'Enter' && urlDialogValid) {
+                                        event.preventDefault();
+                                        handleUrlDialogConfirm();
+                                    }
+                                },
+                                size: "small",
+                                autoFocus: true,
+                                sx: {
+                                    mt: 1
+                                },
+                                helperText: "https:// or a site path like /images/hero.png"
+                            }),
+                            urlDialog ? /*#__PURE__*/ _jsx(TextField, {
+                                label: "Alt text",
+                                value: urlDialog.text,
+                                onChange: (event)=>setUrlDialog((prev)=>prev ? _extends({}, prev, {
+                                            text: event.target.value
+                                        }) : prev),
+                                size: "small"
+                            }) : null
+                        ]
+                    }),
+                    /*#__PURE__*/ _jsxs(DialogActions, {
+                        children: [
+                            urlDialog && onPickImageFromMedia ? /*#__PURE__*/ _jsx(Button, {
+                                color: "primary",
+                                sx: {
+                                    mr: 'auto'
+                                },
+                                onClick: ()=>{
+                                    // Read the alt BEFORE clearing the dialog (AGL-1645) — the
+                                    // author has already typed it, and the picked image has no
+                                    // other way to acquire one.
+                                    const alt = urlDialog.text.trim();
+                                    setUrlDialog(null);
+                                    onPickImageFromMedia(alt);
+                                },
+                                children: 'Choose from media'
+                            }) : null,
+                            /*#__PURE__*/ _jsx(Button, {
+                                onClick: ()=>setUrlDialog(null),
+                                children: 'Cancel'
+                            }),
+                            /*#__PURE__*/ _jsx(Button, {
+                                variant: "contained",
+                                color: "primary",
+                                disabled: !urlDialogValid,
+                                onClick: handleUrlDialogConfirm,
+                                children: 'Insert'
+                            })
+                        ]
+                    })
+                ]
+            }),
+            /*#__PURE__*/ _jsx(MarkdownLinkDialog, {
+                open: Boolean(linkDialog),
+                href: linkDialog == null ? void 0 : linkDialog.href,
+                text: linkDialog == null ? void 0 : linkDialog.text,
+                withText: (linkDialog == null ? void 0 : linkDialog.editRowKey) == null,
+                onClose: ()=>setLinkDialog(null),
+                onConfirm: handleLinkConfirm
+            })
+        ]
+    });
+});
+MarkdownVisualEditor.displayName = 'MarkdownVisualEditor';
+export default MarkdownVisualEditor;
+
+//# sourceMappingURL=markdown-visual-editor.component.js.map