@a3s-lab/office 0.1.0

package/dist/0~markdown-editor.js

@@ -0,0 +1,2260 @@
+import { __webpack_require__ } from "./0~rslib-runtime.js";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { EditorContent, useEditor } from "@tiptap/react";
+import { useCallback, useDeferredValue, useEffect, useId, useLayoutEffect, useMemo, useRef, useState } from "react";
+import { Extension } from "@tiptap/core";
+import { TaskItem, TaskList } from "@tiptap/extension-list";
+import extension_image from "@tiptap/extension-image";
+import extension_placeholder from "@tiptap/extension-placeholder";
+import { TableKit } from "@tiptap/extension-table";
+import { Markdown } from "@tiptap/markdown";
+import starter_kit from "@tiptap/starter-kit";
+import { Bold, Code2, Columns2, Image, Italic, Link2, List, ListChecks, ListOrdered, Minus, PencilLine, Quote, Redo2, Strikethrough, Table2, Undo2, Unlink } from "lucide-react";
+import { mergeOfficeTiptapExtensions, documentPlainTextAsHtml, customSelectionMenuItems } from "./0~5050.js";
+import { OfficeSelect, isWorkspaceContextMenuKeyboardEvent, WorkOfficeZoomControls, WorkOfficeStatusBar, Dialog, WorkOfficeRibbon, workspaceContextMenuPosition, WorkspaceContextMenu, WorkOfficeRibbonGroup, WorkOfficeRibbonButton, WorkOfficePreviewBar } from "./0~4595.js";
+import { button_Button, stepOfficeZoom, useOfficeEditorWheelZoom, office_text_field_OfficeTextField } from "./0~9512.js";
+import { normalizeDocumentHref, DOCUMENT_LINK_VALIDATION_MESSAGE } from "./0~work-document-links.js";
+import { WorkEditorLoadingState } from "./432.js";
+var markdown_editor_namespaceObject = {};
+__webpack_require__.r(markdown_editor_namespaceObject);
+__webpack_require__.d(markdown_editor_namespaceObject, {
+    MarkdownEditor: ()=>MarkdownEditor,
+    markdownTaskCheckboxLabel: ()=>markdownTaskCheckboxLabel
+});
+const TEXT_CONTROL_MIRROR_PROPERTIES = [
+    'box-sizing',
+    'width',
+    'height',
+    'padding-top',
+    'padding-right',
+    'padding-bottom',
+    'padding-left',
+    'border-top-width',
+    'border-right-width',
+    'border-bottom-width',
+    'border-left-width',
+    'border-top-style',
+    'border-right-style',
+    'border-bottom-style',
+    'border-left-style',
+    'font-family',
+    'font-size',
+    'font-style',
+    'font-weight',
+    'font-variant',
+    'font-stretch',
+    'line-height',
+    'letter-spacing',
+    'text-align',
+    'text-indent',
+    'text-transform',
+    'word-spacing',
+    'tab-size',
+    'direction',
+    'writing-mode',
+    'white-space',
+    'overflow-wrap',
+    'word-break',
+    'scrollbar-gutter'
+];
+function workspaceTextControlSelectionBounds(control) {
+    const { selectionEnd, selectionStart } = control;
+    if (selectionEnd <= selectionStart) return null;
+    const ownerDocument = control.ownerDocument;
+    const view = ownerDocument.defaultView;
+    if (!view || !ownerDocument.body) return null;
+    const controlBounds = control.getBoundingClientRect();
+    if (controlBounds.width <= 0 || controlBounds.height <= 0) return null;
+    const computedStyle = view.getComputedStyle(control);
+    const mirror = ownerDocument.createElement('div');
+    mirror.setAttribute('aria-hidden', 'true');
+    mirror.style.position = 'fixed';
+    mirror.style.left = `${controlBounds.left}px`;
+    mirror.style.top = `${controlBounds.top}px`;
+    mirror.style.margin = '0';
+    mirror.style.overflow = 'hidden';
+    mirror.style.pointerEvents = 'none';
+    mirror.style.visibility = 'hidden';
+    for (const property of TEXT_CONTROL_MIRROR_PROPERTIES)mirror.style.setProperty(property, computedStyle.getPropertyValue(property));
+    const text = ownerDocument.createTextNode(`${control.value}\u200b`);
+    mirror.append(text);
+    ownerDocument.body.append(mirror);
+    mirror.scrollLeft = control.scrollLeft;
+    mirror.scrollTop = control.scrollTop;
+    const range = ownerDocument.createRange();
+    range.setStart(text, selectionStart);
+    range.setEnd(text, selectionEnd);
+    const selectionBounds = range.getBoundingClientRect();
+    mirror.remove();
+    return visibleSelectionBounds(selectionBounds, controlBounds);
+}
+function visibleSelectionBounds(selection, control) {
+    const left = Math.max(selection.left, control.left);
+    const top = Math.max(selection.top, control.top);
+    const right = Math.min(selection.right, control.right);
+    const bottom = Math.min(selection.bottom, control.bottom);
+    if (right <= left || bottom <= top) return null;
+    return {
+        left,
+        top,
+        width: right - left,
+        height: bottom - top
+    };
+}
+const WorkMarkdown = Extension.create({
+    name: 'workMarkdown',
+    addCommands () {
+        return {
+            setWorkMarkdown: (markdown, options = {})=>({ chain })=>chain().setMeta('addToHistory', false).setContent(markdown, {
+                        contentType: 'markdown',
+                        emitUpdate: options.emitUpdate ?? true
+                    }).run()
+        };
+    }
+});
+function createWorkMarkdownExtensions() {
+    return [
+        starter_kit.configure({
+            link: {
+                autolink: true,
+                defaultProtocol: 'https',
+                openOnClick: false
+            },
+            underline: false
+        }),
+        TaskList,
+        TaskItem.configure({
+            nested: true,
+            HTMLAttributes: {
+                'data-type': 'taskItem'
+            },
+            a11y: {
+                checkboxLabel: markdownTaskCheckboxLabel
+            }
+        }),
+        extension_image.configure({
+            allowBase64: false,
+            inline: true
+        }),
+        TableKit.configure({
+            table: {
+                allowTableNodeSelection: true,
+                resizable: false
+            }
+        }),
+        extension_placeholder.configure({
+            placeholder: '开始写 Markdown…'
+        }),
+        Markdown.configure({
+            indentation: {
+                style: 'space',
+                size: 2
+            },
+            markedOptions: {
+                gfm: true,
+                breaks: false,
+                pedantic: false
+            }
+        }),
+        WorkMarkdown
+    ];
+}
+function markdownTaskCheckboxLabel(node) {
+    const label = node.textContent.trim() || '任务';
+    return `${node.attrs.checked ? '已完成' : '未完成'}：${label}`;
+}
+const INLINE_WRAPPERS = {
+    bold: '**',
+    code: '`',
+    italic: '*',
+    strike: '~~'
+};
+const MARKDOWN_TABLE = "| Column 1 | Column 2 | Column 3 |\n| --- | --- | --- |\n|  |  |  |\n|  |  |  |";
+function isMarkdownSourceCommandActive(markdown, requestedSelection, command) {
+    const selection = normalizeMarkdownSourceSelection(requestedSelection, markdown.length);
+    if (isInlineMarkdownSourceCommand(command)) return sourceSelectionHasInlineWrapper(markdown, selection, INLINE_WRAPPERS[command], command);
+    if ('code-block' === command) {
+        const selected = markdown.slice(selection.start, selection.end);
+        return selected.startsWith('```\n') && selected.endsWith('\n```') || markdown.slice(0, selection.start).endsWith('```\n') && markdown.slice(selection.end).startsWith('\n```');
+    }
+    if ('horizontal-rule' === command || 'table' === command) return false;
+    const range = selectedLineRange(markdown, selection);
+    const lines = markdown.slice(range.start, range.end).split('\n').filter((line)=>line.length > 0);
+    if (!lines.length) return false;
+    if (command.startsWith('heading-')) {
+        const level = Number(command.at(-1));
+        const pattern = new RegExp(`^#{${level}}\\s+`);
+        return lines.every((line)=>pattern.test(line));
+    }
+    if ('paragraph' === command) return lines.every((line)=>!/^#{1,6}\s+/.test(line));
+    if ('blockquote' === command) return lines.every((line)=>/^>\s+/.test(line));
+    if ('bullet-list' === command) return lines.every((line)=>/^[-+*]\s+(?!\[[ xX]\]\s+)/.test(line));
+    if ('ordered-list' === command) return lines.every((line)=>/^\d+[.)]\s+/.test(line));
+    return lines.every((line)=>/^[-+*]\s+\[[ xX]\]\s+/.test(line));
+}
+function applyMarkdownSourceCommand(markdown, requestedSelection, command) {
+    const selection = normalizeMarkdownSourceSelection(requestedSelection, markdown.length);
+    if (isInlineMarkdownSourceCommand(command)) return toggleInlineWrapper(markdown, selection, INLINE_WRAPPERS[command], command);
+    if ('horizontal-rule' === command) return insertMarkdownBlock(markdown, selection, '---', void 0, true);
+    if ('table' === command) return insertMarkdownBlock(markdown, selection, MARKDOWN_TABLE, {
+        start: 2,
+        end: 10
+    });
+    if ('code-block' === command) return toggleCodeBlock(markdown, selection);
+    return transformSelectedLines(markdown, selection, command);
+}
+function isInlineMarkdownSourceCommand(command) {
+    return Object.hasOwn(INLINE_WRAPPERS, command);
+}
+function replaceMarkdownSourceSelection(markdown, requestedSelection, replacement, selectedRange = {
+    start: 0,
+    end: replacement.length
+}) {
+    const selection = normalizeMarkdownSourceSelection(requestedSelection, markdown.length);
+    const nextMarkdown = `${markdown.slice(0, selection.start)}${replacement}${markdown.slice(selection.end)}`;
+    return {
+        markdown: nextMarkdown,
+        selection: {
+            start: selection.start + selectedRange.start,
+            end: selection.start + selectedRange.end,
+            direction: 'none'
+        }
+    };
+}
+function createMarkdownLinkSourceInsert(label, source) {
+    return createMarkdownSourceInsert('', label, source, 1);
+}
+function createMarkdownImageSourceInsert(altText, source) {
+    return createMarkdownSourceInsert('!', altText, source, 2);
+}
+function findMarkdownSourceLink(markdown, requestedSelection) {
+    const selection = normalizeMarkdownSourceSelection(requestedSelection, markdown.length);
+    let cursor = 0;
+    while(cursor < markdown.length){
+        const openBracket = markdown.indexOf('[', cursor);
+        if (openBracket < 0) break;
+        cursor = openBracket + 1;
+        if (markdownDelimiterIsEscaped(markdown, openBracket) || markdownSourceBracketStartsImage(markdown, openBracket)) continue;
+        const closeBracket = markdownSourceClosingBracket(markdown, openBracket);
+        if (closeBracket < 0 || '(' !== markdown[closeBracket + 1]) continue;
+        const destination = markdownSourceLinkDestination(markdown, closeBracket + 1);
+        if (!destination) continue;
+        cursor = destination.range.end;
+        const range = {
+            start: openBracket,
+            end: destination.range.end
+        };
+        if (!markdownSourceSelectionTargetsRange(selection, range)) continue;
+        const rawLabel = markdown.slice(openBracket + 1, closeBracket);
+        return {
+            label: unescapeMarkdownLinkLabel(rawLabel),
+            rawLabel,
+            range,
+            source: unescapeMarkdownLinkDestination(destination.rawSource)
+        };
+    }
+    return null;
+}
+function createMarkdownSourceLinkRemoval(link) {
+    return {
+        replacement: link.rawLabel,
+        selectedRange: {
+            start: 0,
+            end: link.rawLabel.length
+        }
+    };
+}
+function createMarkdownSourceInsert(prefix, text, source, selectionStart) {
+    const escapedText = text.replaceAll('\\', '\\\\').replaceAll('[', '\\[').replaceAll(']', '\\]');
+    const destination = /\s/u.test(source) ? `<${source}>` : source.replace(/([\\()])/gu, '\\$1');
+    return {
+        replacement: `${prefix}[${escapedText}](${destination})`,
+        selectedRange: {
+            start: selectionStart,
+            end: selectionStart + escapedText.length
+        }
+    };
+}
+function markdownSourceBracketStartsImage(markdown, openBracket) {
+    const marker = openBracket - 1;
+    return marker >= 0 && '!' === markdown[marker] && !markdownDelimiterIsEscaped(markdown, marker);
+}
+function markdownSourceClosingBracket(markdown, openBracket) {
+    let depth = 1;
+    for(let cursor = openBracket + 1; cursor < markdown.length; cursor += 1)if (!markdownDelimiterIsEscaped(markdown, cursor)) {
+        if ('[' === markdown[cursor]) depth += 1;
+        else if (']' === markdown[cursor]) {
+            depth -= 1;
+            if (0 === depth) return cursor;
+        }
+    }
+    return -1;
+}
+function markdownSourceLinkDestination(markdown, openParenthesis) {
+    let cursor = openParenthesis + 1;
+    while(' ' === markdown[cursor] || '\t' === markdown[cursor])cursor += 1;
+    if (cursor >= markdown.length || '\n' === markdown[cursor]) return null;
+    let rawSource = '';
+    if ('<' === markdown[cursor]) {
+        const sourceStart = cursor + 1;
+        cursor = sourceStart;
+        while(cursor < markdown.length && ('>' !== markdown[cursor] || markdownDelimiterIsEscaped(markdown, cursor))){
+            if ('\n' === markdown[cursor]) return null;
+            cursor += 1;
+        }
+        if ('>' !== markdown[cursor]) return null;
+        rawSource = markdown.slice(sourceStart, cursor);
+        cursor += 1;
+    } else {
+        const sourceStart = cursor;
+        let depth = 0;
+        while(cursor < markdown.length){
+            const character = markdown[cursor];
+            if ('\n' === character) return null;
+            if (markdownDelimiterIsEscaped(markdown, cursor)) {
+                cursor += 1;
+                continue;
+            }
+            if ('(' === character) depth += 1;
+            else if (')' === character) {
+                if (0 === depth) break;
+                depth -= 1;
+            } else if ((' ' === character || '\t' === character) && 0 === depth) break;
+            cursor += 1;
+        }
+        rawSource = markdown.slice(sourceStart, cursor);
+    }
+    if (!rawSource) return null;
+    while(' ' === markdown[cursor] || '\t' === markdown[cursor])cursor += 1;
+    if (')' !== markdown[cursor]) {
+        cursor = markdownSourceLinkTitleEnd(markdown, cursor);
+        if (cursor < 0) return null;
+        while(' ' === markdown[cursor] || '\t' === markdown[cursor])cursor += 1;
+    }
+    if (')' !== markdown[cursor]) return null;
+    return {
+        range: {
+            start: openParenthesis,
+            end: cursor + 1
+        },
+        rawSource
+    };
+}
+function markdownSourceLinkTitleEnd(markdown, start) {
+    const opener = markdown[start];
+    const closer = '(' === opener ? ')' : opener;
+    if (!closer || ![
+        '"',
+        "'",
+        '('
+    ].includes(opener ?? '')) return -1;
+    for(let cursor = start + 1; cursor < markdown.length; cursor += 1){
+        if ('\n' === markdown[cursor]) break;
+        if (markdown[cursor] === closer && !markdownDelimiterIsEscaped(markdown, cursor)) return cursor + 1;
+    }
+    return -1;
+}
+function markdownSourceSelectionTargetsRange(selection, range) {
+    if (selection.start === selection.end) return selection.start >= range.start && selection.start < range.end;
+    return selection.start >= range.start && selection.end <= range.end;
+}
+function unescapeMarkdownLinkLabel(label) {
+    return label.replace(/\\([\\[\]])/gu, '$1');
+}
+function unescapeMarkdownLinkDestination(source) {
+    return source.replace(/\\([\\()<>])/gu, '$1');
+}
+function toggleInlineWrapper(markdown, selection, wrapper, command) {
+    const selected = markdown.slice(selection.start, selection.end);
+    const selectedHasWrapper = selected.length >= 2 * wrapper.length && selected.startsWith(wrapper) && selected.endsWith(wrapper);
+    if (selectedHasWrapper) {
+        const replacement = selected.slice(wrapper.length, -wrapper.length);
+        return replaceMarkdownSourceSelection(markdown, selection, replacement);
+    }
+    const enclosingWrapper = inlineWrapperAroundSelection(markdown, selection, wrapper, command);
+    if (enclosingWrapper) return {
+        markdown: `${markdown.slice(0, enclosingWrapper.open)}${markdown.slice(enclosingWrapper.open + wrapper.length, enclosingWrapper.close)}${markdown.slice(enclosingWrapper.close + wrapper.length)}`,
+        selection: {
+            start: selection.start - wrapper.length,
+            end: selection.end - wrapper.length,
+            direction: selection.direction
+        }
+    };
+    const before = markdown.slice(0, selection.start);
+    const after = markdown.slice(selection.end);
+    const wrapperOutsideSelection = before.endsWith(wrapper) && after.startsWith(wrapper) && !('italic' === command && before.endsWith('**') && after.startsWith('**'));
+    if (wrapperOutsideSelection) return {
+        markdown: `${before.slice(0, -wrapper.length)}${selected}${after.slice(wrapper.length)}`,
+        selection: {
+            start: selection.start - wrapper.length,
+            end: selection.end - wrapper.length,
+            direction: selection.direction
+        }
+    };
+    const replacement = `${wrapper}${selected}${wrapper}`;
+    return replaceMarkdownSourceSelection(markdown, selection, replacement, {
+        start: wrapper.length,
+        end: wrapper.length + selected.length
+    });
+}
+function sourceSelectionHasInlineWrapper(markdown, selection, wrapper, command) {
+    const selected = markdown.slice(selection.start, selection.end);
+    const selectedHasWrapper = selected.length >= 2 * wrapper.length && selected.startsWith(wrapper) && selected.endsWith(wrapper) && !('italic' === command && selected.startsWith('**') && selected.endsWith('**'));
+    if (selectedHasWrapper) return true;
+    if (inlineWrapperAroundSelection(markdown, selection, wrapper, command)) return true;
+    const before = markdown.slice(0, selection.start);
+    const after = markdown.slice(selection.end);
+    return before.endsWith(wrapper) && after.startsWith(wrapper) && !('italic' === command && before.endsWith('**') && after.startsWith('**'));
+}
+function inlineWrapperAroundSelection(markdown, selection, wrapper, command) {
+    const lineStart = markdown.lastIndexOf('\n', Math.max(0, selection.start - 1)) + 1;
+    const followingNewline = markdown.indexOf('\n', selection.end);
+    const lineEnd = followingNewline < 0 ? markdown.length : followingNewline;
+    const delimiters = [];
+    for(let index = lineStart; index <= lineEnd - wrapper.length;)if (!markdown.startsWith(wrapper, index) || markdownDelimiterIsEscaped(markdown, index) || 'italic' === command && ('*' === markdown[index - 1] || '*' === markdown[index + wrapper.length])) index += 1;
+    else {
+        delimiters.push(index);
+        index += wrapper.length;
+    }
+    for(let index = 0; index + 1 < delimiters.length; index += 2){
+        const open = delimiters[index];
+        const close = delimiters[index + 1];
+        if (void 0 !== open && void 0 !== close && selection.start >= open + wrapper.length && selection.end <= close) return {
+            open,
+            close
+        };
+    }
+    return null;
+}
+function markdownDelimiterIsEscaped(markdown, index) {
+    let backslashes = 0;
+    for(let cursor = index - 1; cursor >= 0 && '\\' === markdown[cursor]; cursor -= 1)backslashes += 1;
+    return backslashes % 2 === 1;
+}
+function transformSelectedLines(markdown, selection, command) {
+    const range = selectedLineRange(markdown, selection);
+    const lines = markdown.slice(range.start, range.end).split('\n');
+    const nonEmptyLines = lines.filter((line)=>line.length > 0);
+    const everyNonEmptyLine = (pattern)=>nonEmptyLines.length > 0 && nonEmptyLines.every((line)=>pattern.test(line));
+    let transformed;
+    if (command.startsWith('heading-')) {
+        const level = Number(command.at(-1));
+        const prefix = `${'#'.repeat(level)} `;
+        transformed = lines.map((line)=>line ? `${prefix}${stripBlockPrefix(line)}` : prefix);
+    } else if ('paragraph' === command) transformed = lines.map((line)=>line.replace(/^#{1,6}\s+/, ''));
+    else if ('blockquote' === command) {
+        const remove = everyNonEmptyLine(/^>\s+/);
+        transformed = lines.map((line)=>remove ? line.replace(/^>\s+/, '') : line ? `> ${line}` : '> ');
+    } else {
+        const pattern = 'bullet-list' === command ? /^[-+*]\s+(?!\[[ xX]\]\s+)/ : 'ordered-list' === command ? /^\d+[.)]\s+/ : /^[-+*]\s+\[[ xX]\]\s+/;
+        const remove = everyNonEmptyLine(pattern);
+        transformed = lines.map((line, index)=>{
+            const text = stripListPrefix(line);
+            if (remove) return text;
+            if ('ordered-list' === command) return `${index + 1}. ${text}`;
+            if ('task-list' === command) return `- [ ] ${text}`;
+            return `- ${text}`;
+        });
+    }
+    const replacement = transformed.join('\n');
+    return {
+        markdown: `${markdown.slice(0, range.start)}${replacement}${markdown.slice(range.end)}`,
+        selection: {
+            start: range.start,
+            end: range.start + replacement.length,
+            direction: selection.direction
+        }
+    };
+}
+function toggleCodeBlock(markdown, selection) {
+    const selected = markdown.slice(selection.start, selection.end);
+    if (selected.startsWith('```\n') && selected.endsWith('\n```')) {
+        const replacement = selected.slice(4, -4);
+        return replaceMarkdownSourceSelection(markdown, selection, replacement);
+    }
+    const before = markdown.slice(0, selection.start);
+    const after = markdown.slice(selection.end);
+    if (before.endsWith('```\n') && after.startsWith('\n```')) return {
+        markdown: `${before.slice(0, -4)}${selected}${after.slice(4)}`,
+        selection: {
+            start: selection.start - 4,
+            end: selection.end - 4,
+            direction: selection.direction
+        }
+    };
+    return replaceMarkdownSourceSelection(markdown, selection, `\`\`\`\n${selected}\n\`\`\``, {
+        start: 4,
+        end: 4 + selected.length
+    });
+}
+function insertMarkdownBlock(markdown, selection, block, selectedRange, appendBlank = false) {
+    const before = markdown.slice(0, selection.start);
+    const after = markdown.slice(selection.end);
+    const leading = before ? before.endsWith('\n\n') ? '' : before.endsWith('\n') ? '\n' : '\n\n' : '';
+    const trailing = after ? after.startsWith('\n\n') ? '' : after.startsWith('\n') ? '\n' : '\n\n' : appendBlank ? '\n\n' : '';
+    const replacement = `${leading}${block}${trailing}`;
+    const blockStart = selection.start + leading.length;
+    return {
+        markdown: `${before}${replacement}${after}`,
+        selection: selectedRange ? {
+            start: blockStart + selectedRange.start,
+            end: blockStart + selectedRange.end,
+            direction: 'none'
+        } : {
+            start: selection.start + replacement.length,
+            end: selection.start + replacement.length,
+            direction: 'none'
+        }
+    };
+}
+function selectedLineRange(markdown, selection) {
+    const start = 0 === selection.start ? 0 : markdown.lastIndexOf('\n', selection.start - 1) + 1;
+    const inclusiveEnd = selection.end > selection.start && '\n' === markdown[selection.end - 1] ? selection.end - 1 : selection.end;
+    const newline = markdown.indexOf('\n', inclusiveEnd);
+    return {
+        start,
+        end: newline < 0 ? markdown.length : newline
+    };
+}
+function stripBlockPrefix(line) {
+    return line.replace(/^(?:#{1,6}\s+|[-+*]\s+(?:\[[ xX]\]\s+)?|\d+[.)]\s+|>\s+)/, '');
+}
+function stripListPrefix(line) {
+    return line.replace(/^(?:[-+*]\s+(?:\[[ xX]\]\s+)?|\d+[.)]\s+)/, '');
+}
+function normalizeMarkdownSourceSelection(selection, markdownLength) {
+    const requestedStart = Math.min(selection.start, selection.end);
+    const requestedEnd = Math.max(selection.start, selection.end);
+    return {
+        start: Math.max(0, Math.min(markdownLength, requestedStart)),
+        end: Math.max(0, Math.min(markdownLength, requestedEnd)),
+        direction: selection.direction
+    };
+}
+const SURROUNDING_TEXT_LIMIT = 2000;
+function createWorkMarkdownSourceSelectionSnapshot(markdown, selection, content) {
+    const from = Math.max(0, Math.min(markdown.length, selection.start));
+    const to = Math.max(from, Math.min(markdown.length, selection.end));
+    const rawText = markdown.slice(from, to);
+    const text = rawText.trim();
+    if (!text) return null;
+    return {
+        selection: {
+            surface: 'source',
+            from,
+            to,
+            text,
+            rawText,
+            beforeText: markdown.slice(0, from).slice(-SURROUNDING_TEXT_LIMIT),
+            afterText: markdown.slice(to).slice(0, SURROUNDING_TEXT_LIMIT)
+        },
+        document: {
+            content: content.markdown === markdown ? content : {
+                ...content,
+                markdown
+            },
+            markdown,
+            text: markdown
+        }
+    };
+}
+function createWorkMarkdownVisualSelectionSnapshot(editor, content) {
+    const { from, to, empty } = editor.state.selection;
+    if (empty) return null;
+    const rawText = editor.state.doc.textBetween(from, to, '\n');
+    const text = rawText.trim();
+    if (!text) return null;
+    const markdown = editor.getMarkdown();
+    return {
+        selection: {
+            surface: 'visual',
+            from,
+            to,
+            text,
+            rawText,
+            beforeText: editor.state.doc.textBetween(0, from, '\n').slice(-SURROUNDING_TEXT_LIMIT),
+            afterText: editor.state.doc.textBetween(to, editor.state.doc.content.size, '\n').slice(0, SURROUNDING_TEXT_LIMIT)
+        },
+        document: {
+            content: content.markdown === markdown ? content : {
+                ...content,
+                markdown
+            },
+            markdown,
+            text: editor.state.doc.textBetween(0, editor.state.doc.content.size, '\n')
+        }
+    };
+}
+function createWorkMarkdownSourceSelectionAction(snapshot, getMarkdown, applyEdit) {
+    let from = snapshot.selection.from;
+    let to = snapshot.selection.to;
+    let expectedText = snapshot.selection.rawText;
+    let disposed = false;
+    const currentSelection = ()=>{
+        if (disposed) return 'editor-unavailable';
+        const markdown = getMarkdown();
+        if (markdown.slice(from, to) !== expectedText) return 'stale-selection';
+        return {
+            start: from,
+            end: to,
+            direction: 'none'
+        };
+    };
+    const editText = (text, placement)=>{
+        if ('string' != typeof text || 'replace' !== placement && !text) return {
+            applied: false,
+            reason: 'invalid-text'
+        };
+        const selection = currentSelection();
+        if ('string' == typeof selection) return {
+            applied: false,
+            reason: selection
+        };
+        const editSelection = 'before' === placement ? {
+            ...selection,
+            end: selection.start
+        } : 'after' === placement ? {
+            ...selection,
+            start: selection.end
+        } : selection;
+        const edit = replaceMarkdownSourceSelection(getMarkdown(), editSelection, text);
+        if (!applyEdit(edit)) return {
+            applied: false,
+            reason: 'command-rejected'
+        };
+        if ('before' === placement) {
+            from += text.length;
+            to += text.length;
+        } else if ('replace' === placement) {
+            to = from + text.length;
+            expectedText = text;
+        }
+        return {
+            applied: true
+        };
+    };
+    return {
+        context: {
+            ...snapshot,
+            commands: {
+                copyText: ()=>copyMarkdownSelection(snapshot.selection.rawText),
+                insertAfter: (text)=>editText(text, 'after'),
+                insertBefore: (text)=>editText(text, 'before'),
+                replaceText: (text)=>editText(text, 'replace')
+            }
+        },
+        dispose: ()=>{
+            disposed = true;
+        }
+    };
+}
+function createWorkMarkdownVisualSelectionAction(editor, snapshot) {
+    let from = snapshot.selection.from;
+    let to = snapshot.selection.to;
+    let stale = false;
+    let disposed = false;
+    const handleTransaction = ({ transaction })=>{
+        if (!transaction.docChanged || stale || disposed) return;
+        const mappedFrom = transaction.mapping.mapResult(from, 1);
+        const mappedTo = transaction.mapping.mapResult(to, -1);
+        from = mappedFrom.pos;
+        to = mappedTo.pos;
+        stale = mappedFrom.deletedAcross || mappedTo.deletedAcross || from > to || transaction.doc.textBetween(from, to, '\n') !== snapshot.selection.rawText;
+    };
+    editor.on('transaction', handleTransaction);
+    const currentRange = ()=>{
+        if (disposed || editor.isDestroyed) return 'editor-unavailable';
+        if (!editor.isEditable) return 'read-only';
+        if (stale || from < 0 || to < from || to > editor.state.doc.content.size || editor.state.doc.textBetween(from, to, '\n') !== snapshot.selection.rawText) return 'stale-selection';
+        return {
+            from,
+            to
+        };
+    };
+    const editText = (text, placement)=>{
+        if ('string' != typeof text || 'replace' !== placement && !text) return {
+            applied: false,
+            reason: 'invalid-text'
+        };
+        const range = currentRange();
+        if ('string' == typeof range) return {
+            applied: false,
+            reason: range
+        };
+        const editRange = 'before' === placement ? {
+            from: range.from,
+            to: range.from
+        } : 'after' === placement ? {
+            from: range.to,
+            to: range.to
+        } : range;
+        const applied = editor.chain().focus().setTextSelection(editRange).insertContent(documentPlainTextAsHtml(text)).run();
+        return applied ? {
+            applied: true
+        } : {
+            applied: false,
+            reason: 'command-rejected'
+        };
+    };
+    return {
+        context: {
+            ...snapshot,
+            commands: {
+                copyText: ()=>copyMarkdownSelection(snapshot.selection.rawText),
+                insertAfter: (text)=>editText(text, 'after'),
+                insertBefore: (text)=>editText(text, 'before'),
+                replaceText: (text)=>editText(text, 'replace')
+            }
+        },
+        dispose: ()=>{
+            if (disposed) return;
+            disposed = true;
+            editor.off('transaction', handleTransaction);
+        }
+    };
+}
+async function copyMarkdownSelection(text) {
+    try {
+        if ("u" < typeof navigator || !navigator.clipboard?.writeText) return false;
+        await navigator.clipboard.writeText(text);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+const MARKDOWN_SURFACE_FOCUS_RETRY_FRAMES = 4;
+function restoreMarkdownEditingSurfaceFocus(getTarget) {
+    const commandTrigger = document.activeElement;
+    let remainingFrames = MARKDOWN_SURFACE_FOCUS_RETRY_FRAMES;
+    const restore = ()=>{
+        if (remainingFrames <= 0) return;
+        remainingFrames -= 1;
+        const target = getTarget();
+        if (!target?.isConnected) return void requestAnimationFrame(restore);
+        const activeElement = document.activeElement;
+        const canRestore = activeElement === commandTrigger || activeElement === target || activeElement === document.body || activeElement === document.documentElement || !activeElement?.isConnected;
+        if (canRestore) target.focus({
+            preventScroll: true
+        });
+    };
+    requestAnimationFrame(restore);
+}
+function MarkdownSelectionContextMenu({ editor, menu, createSourceAction, onClose }) {
+    const createAction = ()=>'source' === menu.snapshot.selection.surface ? createSourceAction(menu.snapshot) : createWorkMarkdownVisualSelectionAction(editor, menu.snapshot);
+    return /*#__PURE__*/ jsx(WorkspaceContextMenu, {
+        label: "选中文本操作",
+        x: menu.x,
+        y: menu.y,
+        items: customSelectionMenuItems(menu.items, createAction),
+        onClose: onClose
+    });
+}
+const MARKDOWN_MIN_ZOOM = 60;
+const MARKDOWN_MAX_ZOOM = 180;
+function MarkdownStatus({ characterCount, lineCount, saveStatus, zoom, onZoomChange }) {
+    return /*#__PURE__*/ jsxs(WorkOfficeStatusBar, {
+        className: "work-markdown-status",
+        controls: /*#__PURE__*/ jsx(WorkOfficeZoomControls, {
+            zoom: zoom,
+            minimum: MARKDOWN_MIN_ZOOM,
+            maximum: MARKDOWN_MAX_ZOOM,
+            decreaseLabel: "缩小内容",
+            increaseLabel: "放大内容",
+            outputLabel: "Markdown 缩放比例",
+            sliderLabel: "调整 Markdown 缩放比例",
+            onChange: onZoomChange
+        }),
+        children: [
+            /*#__PURE__*/ jsxs("output", {
+                children: [
+                    lineCount,
+                    " 行"
+                ]
+            }),
+            /*#__PURE__*/ jsxs("output", {
+                children: [
+                    characterCount,
+                    " 字符"
+                ]
+            }),
+            saveStatus && /*#__PURE__*/ jsx("span", {
+                className: "work-office-save-status",
+                children: saveStatus
+            })
+        ]
+    });
+}
+const MARKDOWN_IMAGE_VALIDATION_MESSAGE = '请输入完整的 http、https 或相对图片地址。';
+function MarkdownInsertDialog({ request, restoreFocusTarget, onClose, onSubmit }) {
+    const formId = useId();
+    const textFieldId = useId();
+    const sourceFieldId = useId();
+    const submittedRef = useRef(false);
+    const [source, setSource] = useState(request.source);
+    const [text, setText] = useState('link' === request.kind ? request.label : request.altText);
+    const normalizedSource = normalizeMarkdownInsertSource(request.kind, source);
+    const sourceReady = null !== normalizedSource;
+    const sourceError = markdownInsertSourceError(request.kind, source);
+    const sourceErrorId = `${sourceFieldId}-error`;
+    const submit = (event)=>{
+        event.preventDefault();
+        if (submittedRef.current) return;
+        const completedSource = normalizeMarkdownInsertSource(request.kind, source);
+        if (!completedSource) return;
+        submittedRef.current = true;
+        onSubmit('link' === request.kind ? {
+            kind: 'link',
+            action: request.action,
+            label: text.trim() || completedSource,
+            source: completedSource
+        } : {
+            kind: 'image',
+            altText: text.trim(),
+            source: completedSource
+        });
+    };
+    const title = 'link' === request.kind ? 'edit' === request.action ? '编辑链接' : '添加链接' : '插入图片';
+    const submitLabel = 'link' === request.kind ? 'edit' === request.action ? '保存' : '添加' : '插入';
+    const focusText = 'link' === request.kind && !request.label.trim();
+    return /*#__PURE__*/ jsx(Dialog, {
+        title: title,
+        className: "work-office-dialog work-markdown-insert-dialog",
+        restoreFocusTarget: restoreFocusTarget,
+        onClose: onClose,
+        footer: /*#__PURE__*/ jsxs(Fragment, {
+            children: [
+                /*#__PURE__*/ jsx(button_Button, {
+                    tone: "quiet",
+                    onClick: onClose,
+                    children: "取消"
+                }),
+                /*#__PURE__*/ jsx(button_Button, {
+                    tone: "primary",
+                    type: "submit",
+                    form: formId,
+                    disabled: !sourceReady,
+                    children: submitLabel
+                })
+            ]
+        }),
+        children: /*#__PURE__*/ jsxs("form", {
+            id: formId,
+            className: "work-markdown-insert-form",
+            onSubmit: submit,
+            children: [
+                /*#__PURE__*/ jsxs("label", {
+                    className: "work-office-dialog-field",
+                    htmlFor: textFieldId,
+                    children: [
+                        /*#__PURE__*/ jsx("span", {
+                            className: "work-office-dialog-field-label",
+                            children: 'link' === request.kind ? '显示文字' : '替代文字（可选）'
+                        }),
+                        /*#__PURE__*/ jsx(office_text_field_OfficeTextField, {
+                            id: textFieldId,
+                            "aria-label": 'link' === request.kind ? '显示文字' : '替代文字（可选）',
+                            "data-autofocus": focusText || void 0,
+                            value: text,
+                            onChange: (event)=>setText(event.target.value)
+                        })
+                    ]
+                }),
+                /*#__PURE__*/ jsxs("label", {
+                    className: "work-office-dialog-field",
+                    htmlFor: sourceFieldId,
+                    children: [
+                        /*#__PURE__*/ jsx("span", {
+                            className: "work-office-dialog-field-label",
+                            children: 'link' === request.kind ? '链接地址' : '图片地址'
+                        }),
+                        /*#__PURE__*/ jsx(office_text_field_OfficeTextField, {
+                            id: sourceFieldId,
+                            "aria-label": 'link' === request.kind ? '链接地址' : '图片地址',
+                            "aria-describedby": sourceError ? sourceErrorId : void 0,
+                            "aria-invalid": sourceError ? true : void 0,
+                            inputMode: "url",
+                            placeholder: "https://",
+                            "data-autofocus": !focusText || void 0,
+                            value: source,
+                            onChange: (event)=>setSource(event.target.value)
+                        }),
+                        sourceError && /*#__PURE__*/ jsx("span", {
+                            id: sourceErrorId,
+                            className: "work-office-dialog-field-error",
+                            role: "alert",
+                            children: sourceError
+                        })
+                    ]
+                })
+            ]
+        })
+    });
+}
+function normalizeMarkdownInsertSource(kind, source) {
+    const value = source.trim();
+    if (!value || /[\u0000-\u001f\u007f\\<>]/u.test(value)) return null;
+    if ('link' === kind) {
+        const normalized = normalizeDocumentHref(value);
+        return normalized ? normalizeMarkdownSourceSpaces(normalized) : null;
+    }
+    if (/^https?:/iu.test(value)) {
+        const normalized = normalizeDocumentHref(value);
+        return normalized && /^https?:/iu.test(normalized) ? normalizeMarkdownSourceSpaces(normalized) : null;
+    }
+    try {
+        const base = new URL('https://a3s-office.invalid/');
+        const resolved = new URL(value, base);
+        const path = value.split(/[?#]/u, 1)[0] ?? '';
+        return resolved.protocol === base.protocol && resolved.origin === base.origin && /[^\s./]/u.test(path) ? normalizeMarkdownSourceSpaces(value) : null;
+    } catch  {
+        return null;
+    }
+}
+function normalizeMarkdownSourceSpaces(source) {
+    return source.replace(/ /gu, '%20');
+}
+function markdownInsertSourceError(kind, source) {
+    const value = source.trim();
+    if (!value || 'https://' === value) return null;
+    if (normalizeMarkdownInsertSource(kind, value)) return null;
+    return 'link' === kind ? DOCUMENT_LINK_VALIDATION_MESSAGE : MARKDOWN_IMAGE_VALIDATION_MESSAGE;
+}
+const markdownRibbonTabs = [
+    {
+        id: 'home',
+        label: '开始'
+    },
+    {
+        id: 'insert',
+        label: '插入'
+    },
+    {
+        id: 'view',
+        label: '视图'
+    }
+];
+const markdownToolbarShortcuts = {
+    bold: {
+        ariaKeyShortcuts: 'Control+B Meta+B',
+        label: 'Cmd/Ctrl+B'
+    },
+    italic: {
+        ariaKeyShortcuts: 'Control+I Meta+I',
+        label: 'Cmd/Ctrl+I'
+    },
+    redo: {
+        ariaKeyShortcuts: 'Control+Shift+Z Meta+Shift+Z Control+Y Meta+Y',
+        label: 'Cmd/Ctrl+Shift+Z 或 Cmd/Ctrl+Y'
+    },
+    undo: {
+        ariaKeyShortcuts: 'Control+Z Meta+Z',
+        label: 'Cmd/Ctrl+Z'
+    }
+};
+function MarkdownToolbar({ editor, fileActions, sourceEditing, canSourceRedo, canSourceUndo, viewMode, getSourceFocusTarget, getSourceSelection, onSourceCommand, onSourceRedo, onSourceReplace, onSourceUndo, onViewModeChange }) {
+    const [activeTab, setActiveTab] = useState('home');
+    const [insertDialog, setInsertDialog] = useState(null);
+    const sourceSelection = sourceEditing ? getSourceSelection() : null;
+    const sourceLink = sourceSelection ? findMarkdownSourceLink(sourceSelection.markdown, sourceSelection.selection) : null;
+    const commandIsActive = (command)=>sourceSelection ? isMarkdownSourceCommandActive(sourceSelection.markdown, sourceSelection.selection, command) : false;
+    const paragraphStyle = sourceEditing ? commandIsActive('heading-1') ? 'h1' : commandIsActive('heading-2') ? 'h2' : commandIsActive('heading-3') ? 'h3' : 'paragraph' : editor.isActive('heading', {
+        level: 1
+    }) ? 'h1' : editor.isActive('heading', {
+        level: 2
+    }) ? 'h2' : editor.isActive('heading', {
+        level: 3
+    }) ? 'h3' : 'paragraph';
+    const linkActive = sourceEditing ? Boolean(sourceLink) : editor.isActive('link');
+    const canUndo = sourceEditing ? canSourceUndo : canRunVisualEditorCommand(editor, ()=>editor.can().chain().focus().undo().run());
+    const canRedo = sourceEditing ? canSourceRedo : canRunVisualEditorCommand(editor, ()=>editor.can().chain().focus().redo().run());
+    const runCommand = (sourceCommand, visualCommand)=>{
+        if (sourceEditing) return void onSourceCommand(sourceCommand);
+        visualCommand();
+    };
+    const openLinkDialog = ()=>{
+        if (sourceEditing) {
+            const current = getSourceSelection();
+            if (!current) return;
+            const link = findMarkdownSourceLink(current.markdown, current.selection);
+            setInsertDialog({
+                surface: 'source',
+                target: link ? {
+                    markdown: current.markdown,
+                    selection: {
+                        start: link.range.start,
+                        end: link.range.end,
+                        direction: 'none'
+                    },
+                    text: current.markdown.slice(link.range.start, link.range.end)
+                } : current,
+                request: {
+                    kind: 'link',
+                    action: link ? 'edit' : 'insert',
+                    label: link?.label ?? current.text,
+                    source: link?.source ?? 'https://'
+                }
+            });
+            return;
+        }
+        const editingLink = editor.isActive('link');
+        if (editingLink) editor.commands.extendMarkRange('link');
+        const { from, to } = editor.state.selection;
+        setInsertDialog({
+            surface: 'visual',
+            target: {
+                document: editor.state.doc,
+                from,
+                text: editor.state.doc.textBetween(from, to, ' '),
+                to
+            },
+            request: {
+                kind: 'link',
+                action: editingLink ? 'edit' : 'insert',
+                label: editor.state.selection.empty ? '' : editor.state.doc.textBetween(from, to, ' '),
+                source: editingLink ? String(editor.getAttributes('link').href ?? '') : 'https://'
+            }
+        });
+    };
+    const removeLink = ()=>{
+        if (sourceEditing) {
+            const current = getSourceSelection();
+            if (!current) return;
+            const link = findMarkdownSourceLink(current.markdown, current.selection);
+            if (!link) return;
+            const removal = createMarkdownSourceLinkRemoval(link);
+            onSourceReplace(removal.replacement, removal.selectedRange, {
+                markdown: current.markdown,
+                selection: {
+                    start: link.range.start,
+                    end: link.range.end,
+                    direction: 'none'
+                },
+                text: current.markdown.slice(link.range.start, link.range.end)
+            });
+            return;
+        }
+        if (!editor.isActive('link')) return;
+        editor.chain().focus().extendMarkRange('link').unsetLink().run();
+    };
+    const openImageDialog = ()=>{
+        if (sourceEditing) {
+            const current = getSourceSelection();
+            if (!current) return;
+            setInsertDialog({
+                surface: 'source',
+                target: current,
+                request: {
+                    kind: 'image',
+                    altText: '',
+                    source: 'https://'
+                }
+            });
+            return;
+        }
+        const { from, to } = editor.state.selection;
+        setInsertDialog({
+            surface: 'visual',
+            target: {
+                document: editor.state.doc,
+                from,
+                text: editor.state.doc.textBetween(from, to, ' '),
+                to
+            },
+            request: {
+                kind: 'image',
+                altText: '',
+                source: 'https://'
+            }
+        });
+    };
+    const commitInsert = (result)=>{
+        const dialog = insertDialog;
+        if (!dialog) return;
+        if ('source' === dialog.surface) {
+            const insert = 'image' === result.kind ? createMarkdownImageSourceInsert(result.altText, result.source) : createMarkdownLinkSourceInsert(result.label, result.source);
+            onSourceReplace(insert.replacement, insert.selectedRange, dialog.target);
+            setInsertDialog(null);
+            return;
+        }
+        if (editor.isDestroyed || !editor.state.doc.eq(dialog.target.document)) return void setInsertDialog(null);
+        const chain = editor.chain().focus().setTextSelection({
+            from: dialog.target.from,
+            to: dialog.target.to
+        });
+        if ('image' === result.kind) {
+            chain.setImage({
+                src: result.source,
+                alt: result.altText || void 0
+            }).run();
+            setInsertDialog(null);
+            return;
+        }
+        if (dialog.target.text && dialog.target.text === result.label) {
+            chain.setLink({
+                href: result.source
+            }).run();
+            setInsertDialog(null);
+            return;
+        }
+        chain.insertContent({
+            type: 'text',
+            text: result.label,
+            marks: [
+                {
+                    type: 'link',
+                    attrs: {
+                        href: result.source
+                    }
+                }
+            ]
+        }).run();
+        setInsertDialog(null);
+    };
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            /*#__PURE__*/ jsx(WorkOfficeRibbon, {
+                ariaLabel: "Markdown 功能区",
+                tabs: markdownRibbonTabs,
+                defaultTab: "home",
+                activeTab: activeTab,
+                onTabChange: setActiveTab,
+                fileActions: fileActions,
+                className: "work-markdown-ribbon",
+                toolbarClassName: "markdown-toolbar",
+                panels: {
+                    home: /*#__PURE__*/ jsxs(Fragment, {
+                        children: [
+                            /*#__PURE__*/ jsxs(WorkOfficeRibbonGroup, {
+                                label: "撤销",
+                                children: [
+                                    /*#__PURE__*/ jsx(MarkdownToolbarButton, {
+                                        label: "撤销",
+                                        shortcut: markdownToolbarShortcuts.undo,
+                                        disabled: !canUndo,
+                                        onClick: ()=>{
+                                            if (sourceEditing) onSourceUndo();
+                                            else editor.chain().focus().undo().run();
+                                        },
+                                        children: /*#__PURE__*/ jsx(Undo2, {
+                                            size: 16
+                                        })
+                                    }),
+                                    /*#__PURE__*/ jsx(MarkdownToolbarButton, {
+                                        label: "重做",
+                                        shortcut: markdownToolbarShortcuts.redo,
+                                        disabled: !canRedo,
+                                        onClick: ()=>{
+                                            if (sourceEditing) onSourceRedo();
+                                            else editor.chain().focus().redo().run();
+                                        },
+                                        children: /*#__PURE__*/ jsx(Redo2, {
+                                            size: 16
+                                        })
+                                    })
+                                ]
+                            }),
+                            /*#__PURE__*/ jsx(WorkOfficeRibbonGroup, {
+                                label: "样式",
+                                children: /*#__PURE__*/ jsx(OfficeSelect, {
+                                    ariaLabel: "段落样式",
+                                    value: paragraphStyle,
+                                    options: [
+                                        {
+                                            value: 'paragraph',
+                                            label: '正文'
+                                        },
+                                        {
+                                            value: 'h1',
+                                            label: '标题 1'
+                                        },
+                                        {
+                                            value: 'h2',
+                                            label: '标题 2'
+                                        },
+                                        {
+                                            value: 'h3',
+                                            label: '标题 3'
+                                        }
+                                    ],
+                                    onValueChange: (value)=>{
+                                        if ('paragraph' === value) runCommand('paragraph', ()=>{
+                                            editor.chain().focus().setParagraph().run();
+                                        });
+                                        else {
+                                            const level = Number(value.slice(1));
+                                            runCommand(`heading-${level}`, ()=>{
+                                                editor.chain().focus().toggleHeading({
+                                                    level
+                                                }).run();
+                                            });
+                                        }
+                                    }
+                                })
+                            }),
+                            /*#__PURE__*/ jsxs(WorkOfficeRibbonGroup, {
+                                label: "文字",
+                                children: [
+                                    /*#__PURE__*/ jsx(MarkdownToolbarButton, {
+                                        label: "加粗",
+                                        shortcut: markdownToolbarShortcuts.bold,
+                                        active: sourceEditing ? commandIsActive('bold') : editor.isActive('bold'),
+                                        onClick: ()=>runCommand('bold', ()=>{
+                                                editor.chain().focus().toggleBold().run();
+                                            }),
+                                        children: /*#__PURE__*/ jsx(Bold, {
+                                            size: 16
+                                        })
+                                    }),
+                                    /*#__PURE__*/ jsx(MarkdownToolbarButton, {
+                                        label: "斜体",
+                                        shortcut: markdownToolbarShortcuts.italic,
+                                        active: sourceEditing ? commandIsActive('italic') : editor.isActive('italic'),
+                                        onClick: ()=>runCommand('italic', ()=>{
+                                                editor.chain().focus().toggleItalic().run();
+                                            }),
+                                        children: /*#__PURE__*/ jsx(Italic, {
+                                            size: 16
+                                        })
+                                    }),
+                                    /*#__PURE__*/ jsx(MarkdownToolbarButton, {
+                                        label: "删除线",
+                                        active: sourceEditing ? commandIsActive('strike') : editor.isActive('strike'),
+                                        onClick: ()=>runCommand('strike', ()=>{
+                                                editor.chain().focus().toggleStrike().run();
+                                            }),
+                                        children: /*#__PURE__*/ jsx(Strikethrough, {
+                                            size: 16
+                                        })
+                                    }),
+                                    /*#__PURE__*/ jsx(MarkdownToolbarButton, {
+                                        label: "行内代码",
+                                        active: sourceEditing ? commandIsActive('code') : editor.isActive('code'),
+                                        onClick: ()=>runCommand('code', ()=>{
+                                                editor.chain().focus().toggleCode().run();
+                                            }),
+                                        children: /*#__PURE__*/ jsx(Code2, {
+                                            size: 16
+                                        })
+                                    })
+                                ]
+                            }),
+                            /*#__PURE__*/ jsxs(WorkOfficeRibbonGroup, {
+                                label: "段落",
+                                children: [
+                                    /*#__PURE__*/ jsx(MarkdownToolbarButton, {
+                                        label: "项目列表",
+                                        active: sourceEditing ? commandIsActive('bullet-list') : editor.isActive('bulletList'),
+                                        onClick: ()=>runCommand('bullet-list', ()=>{
+                                                editor.chain().focus().toggleBulletList().run();
+                                            }),
+                                        children: /*#__PURE__*/ jsx(List, {
+                                            size: 16
+                                        })
+                                    }),
+                                    /*#__PURE__*/ jsx(MarkdownToolbarButton, {
+                                        label: "编号列表",
+                                        active: sourceEditing ? commandIsActive('ordered-list') : editor.isActive('orderedList'),
+                                        onClick: ()=>runCommand('ordered-list', ()=>{
+                                                editor.chain().focus().toggleOrderedList().run();
+                                            }),
+                                        children: /*#__PURE__*/ jsx(ListOrdered, {
+                                            size: 16
+                                        })
+                                    }),
+                                    /*#__PURE__*/ jsx(MarkdownToolbarButton, {
+                                        label: "任务列表",
+                                        active: sourceEditing ? commandIsActive('task-list') : editor.isActive('taskList'),
+                                        onClick: ()=>runCommand('task-list', ()=>{
+                                                editor.chain().focus().toggleTaskList().run();
+                                            }),
+                                        children: /*#__PURE__*/ jsx(ListChecks, {
+                                            size: 16
+                                        })
+                                    }),
+                                    /*#__PURE__*/ jsx(MarkdownToolbarButton, {
+                                        label: "引用",
+                                        active: sourceEditing ? commandIsActive('blockquote') : editor.isActive('blockquote'),
+                                        onClick: ()=>runCommand('blockquote', ()=>{
+                                                editor.chain().focus().toggleBlockquote().run();
+                                            }),
+                                        children: /*#__PURE__*/ jsx(Quote, {
+                                            size: 16
+                                        })
+                                    })
+                                ]
+                            })
+                        ]
+                    }),
+                    insert: /*#__PURE__*/ jsxs(Fragment, {
+                        children: [
+                            /*#__PURE__*/ jsxs(WorkOfficeRibbonGroup, {
+                                label: "链接",
+                                children: [
+                                    /*#__PURE__*/ jsx(MarkdownToolbarButton, {
+                                        label: linkActive ? '编辑链接' : '添加链接',
+                                        displayLabel: true,
+                                        active: linkActive,
+                                        onClick: openLinkDialog,
+                                        children: /*#__PURE__*/ jsx(Link2, {
+                                            size: 19
+                                        })
+                                    }),
+                                    /*#__PURE__*/ jsx(MarkdownToolbarButton, {
+                                        label: "移除链接",
+                                        displayLabel: true,
+                                        disabled: !linkActive,
+                                        onClick: removeLink,
+                                        children: /*#__PURE__*/ jsx(Unlink, {
+                                            size: 19
+                                        })
+                                    }),
+                                    /*#__PURE__*/ jsx(MarkdownToolbarButton, {
+                                        label: "插入图片",
+                                        displayLabel: true,
+                                        onClick: openImageDialog,
+                                        children: /*#__PURE__*/ jsx(Image, {
+                                            size: 19
+                                        })
+                                    })
+                                ]
+                            }),
+                            /*#__PURE__*/ jsxs(WorkOfficeRibbonGroup, {
+                                label: "内容",
+                                children: [
+                                    /*#__PURE__*/ jsx(MarkdownToolbarButton, {
+                                        label: "代码块",
+                                        displayLabel: true,
+                                        active: sourceEditing ? commandIsActive('code-block') : editor.isActive('codeBlock'),
+                                        onClick: ()=>runCommand('code-block', ()=>{
+                                                editor.chain().focus().toggleCodeBlock().run();
+                                            }),
+                                        children: /*#__PURE__*/ jsx(Code2, {
+                                            size: 19
+                                        })
+                                    }),
+                                    /*#__PURE__*/ jsx(MarkdownToolbarButton, {
+                                        label: "分隔线",
+                                        displayLabel: true,
+                                        onClick: ()=>runCommand('horizontal-rule', ()=>{
+                                                editor.chain().focus().setHorizontalRule().run();
+                                            }),
+                                        children: /*#__PURE__*/ jsx(Minus, {
+                                            size: 19
+                                        })
+                                    }),
+                                    /*#__PURE__*/ jsx(MarkdownToolbarButton, {
+                                        label: "表格",
+                                        displayLabel: true,
+                                        onClick: ()=>runCommand('table', ()=>{
+                                                editor.chain().focus().insertTable({
+                                                    rows: 3,
+                                                    cols: 3,
+                                                    withHeaderRow: true
+                                                }).run();
+                                            }),
+                                        children: /*#__PURE__*/ jsx(Table2, {
+                                            size: 19
+                                        })
+                                    })
+                                ]
+                            })
+                        ]
+                    }),
+                    view: /*#__PURE__*/ jsxs(WorkOfficeRibbonGroup, {
+                        label: "编辑方式",
+                        children: [
+                            /*#__PURE__*/ jsx(MarkdownToolbarButton, {
+                                label: "可视化编辑",
+                                visibleLabel: "可视化",
+                                displayLabel: true,
+                                active: 'visual' === viewMode,
+                                onClick: ()=>onViewModeChange('visual'),
+                                children: /*#__PURE__*/ jsx(PencilLine, {
+                                    size: 19
+                                })
+                            }),
+                            /*#__PURE__*/ jsx(MarkdownToolbarButton, {
+                                label: "源码编辑",
+                                visibleLabel: "源码",
+                                displayLabel: true,
+                                active: 'source' === viewMode,
+                                onClick: ()=>onViewModeChange('source'),
+                                children: /*#__PURE__*/ jsx(Code2, {
+                                    size: 19
+                                })
+                            }),
+                            /*#__PURE__*/ jsx(MarkdownToolbarButton, {
+                                label: "分屏编辑",
+                                visibleLabel: "分屏",
+                                displayLabel: true,
+                                active: 'split' === viewMode,
+                                onClick: ()=>onViewModeChange('split'),
+                                children: /*#__PURE__*/ jsx(Columns2, {
+                                    size: 19
+                                })
+                            })
+                        ]
+                    })
+                }
+            }),
+            insertDialog && /*#__PURE__*/ jsx(MarkdownInsertDialog, {
+                request: insertDialog.request,
+                restoreFocusTarget: ()=>'source' === insertDialog.surface ? getSourceFocusTarget() ?? editor.view.dom : editor.view.dom,
+                onClose: ()=>setInsertDialog(null),
+                onSubmit: commitInsert
+            })
+        ]
+    });
+}
+function canRunVisualEditorCommand(editor, command) {
+    if (editor.isDestroyed || !editor.view) return false;
+    return command();
+}
+function MarkdownToolbarButton({ label, visibleLabel, shortcut, active = false, displayLabel = false, children, ...props }) {
+    return /*#__PURE__*/ jsx(WorkOfficeRibbonButton, {
+        ...props,
+        label: label,
+        visibleLabel: visibleLabel,
+        title: shortcut ? `${label}（${shortcut.label}）` : label,
+        "aria-keyshortcuts": shortcut?.ariaKeyShortcuts,
+        active: active,
+        displayLabel: displayLabel,
+        children: children
+    });
+}
+const DEFAULT_MARKDOWN_SPLIT_PERCENT = 50;
+const MIN_MARKDOWN_SPLIT_PERCENT = 30;
+const MAX_MARKDOWN_SPLIT_PERCENT = 70;
+const MARKDOWN_SPLIT_KEYBOARD_STEP = 5;
+function proportionalMarkdownScrollTop(sourceScrollTop, sourceScrollHeight, sourceClientHeight, targetScrollHeight, targetClientHeight) {
+    const sourceRange = Math.max(0, sourceScrollHeight - sourceClientHeight);
+    const targetRange = Math.max(0, targetScrollHeight - targetClientHeight);
+    if (!sourceRange || !targetRange) return 0;
+    const progress = Math.min(1, Math.max(0, sourceScrollTop / sourceRange));
+    return progress * targetRange;
+}
+function MarkdownWorkspace({ editor, markdown, mode, readOnly = false, visualReadOnly = readOnly, sourceRef, sourceSelectionRequest, onSourceChange, onSourceCommand, onSourceContextMenu, onSourceIntent, onSourceRedo, onSourceSelectionChange, onSourceUndo, onVisualContextMenu, onVisualIntent }) {
+    const workspaceRef = useRef(null);
+    const visualRef = useRef(null);
+    const synchronizedTargetRef = useRef(null);
+    const releaseFrameRef = useRef(null);
+    const sourceInputTypeRef = useRef(void 0);
+    const [sourcePanePercent, setSourcePanePercent] = useState(DEFAULT_MARKDOWN_SPLIT_PERCENT);
+    const [resizing, setResizing] = useState(false);
+    const showSource = !readOnly && 'visual' !== mode;
+    const showVisual = readOnly || 'source' !== mode;
+    const visualIsReadOnly = readOnly || visualReadOnly;
+    const releaseScrollLock = useCallback(()=>{
+        if (null !== releaseFrameRef.current) cancelAnimationFrame(releaseFrameRef.current);
+        releaseFrameRef.current = requestAnimationFrame(()=>{
+            synchronizedTargetRef.current = null;
+            releaseFrameRef.current = null;
+        });
+    }, []);
+    useEffect(()=>()=>{
+            if (null !== releaseFrameRef.current) cancelAnimationFrame(releaseFrameRef.current);
+        }, []);
+    useLayoutEffect(()=>{
+        if (!sourceSelectionRequest) return;
+        const source = sourceRef.current;
+        if (!source) return;
+        source.focus({
+            preventScroll: true
+        });
+        source.setSelectionRange(sourceSelectionRequest.start, sourceSelectionRequest.end, sourceSelectionRequest.direction);
+        onSourceSelectionChange?.(sourceSelectionRequest);
+    }, [
+        onSourceSelectionChange,
+        sourceRef,
+        sourceSelectionRequest
+    ]);
+    const handleSourceScroll = useCallback((event)=>{
+        if ('split' !== mode) return;
+        if ('source' === synchronizedTargetRef.current) {
+            synchronizedTargetRef.current = null;
+            return;
+        }
+        const source = event.currentTarget;
+        const target = visualRef.current;
+        if (!target) return;
+        synchronizedTargetRef.current = 'visual';
+        target.scrollTop = proportionalMarkdownScrollTop(source.scrollTop, source.scrollHeight, source.clientHeight, target.scrollHeight, target.clientHeight);
+        releaseScrollLock();
+    }, [
+        mode,
+        releaseScrollLock
+    ]);
+    const handleVisualScroll = useCallback((event)=>{
+        if ('split' !== mode) return;
+        if ('visual' === synchronizedTargetRef.current) {
+            synchronizedTargetRef.current = null;
+            return;
+        }
+        const source = event.currentTarget;
+        const target = sourceRef.current;
+        if (!target) return;
+        synchronizedTargetRef.current = 'source';
+        target.scrollTop = proportionalMarkdownScrollTop(source.scrollTop, source.scrollHeight, source.clientHeight, target.scrollHeight, target.clientHeight);
+        releaseScrollLock();
+    }, [
+        mode,
+        releaseScrollLock
+    ]);
+    const resizeFromPointer = useCallback((clientX)=>{
+        const workspace = workspaceRef.current;
+        if (!workspace) return;
+        const bounds = workspace.getBoundingClientRect();
+        if (bounds.width <= 0) return;
+        setSourcePanePercent(clampMarkdownSplitPercent(Math.round((clientX - bounds.left) / bounds.width * 1000) / 10));
+    }, []);
+    const handleResizeStart = (event)=>{
+        event.preventDefault();
+        event.currentTarget.setPointerCapture(event.pointerId);
+        setResizing(true);
+        resizeFromPointer(event.clientX);
+    };
+    const handleResizeMove = (event)=>{
+        if (!event.currentTarget.hasPointerCapture(event.pointerId)) return;
+        resizeFromPointer(event.clientX);
+    };
+    const handleResizeEnd = (event)=>{
+        if (event.currentTarget.hasPointerCapture(event.pointerId)) event.currentTarget.releasePointerCapture(event.pointerId);
+        setResizing(false);
+    };
+    const handleResizeKeyDown = (event)=>{
+        let next = null;
+        if ('ArrowLeft' === event.key) next = sourcePanePercent - MARKDOWN_SPLIT_KEYBOARD_STEP;
+        else if ('ArrowRight' === event.key) next = sourcePanePercent + MARKDOWN_SPLIT_KEYBOARD_STEP;
+        else if ('Home' === event.key) next = MIN_MARKDOWN_SPLIT_PERCENT;
+        else if ('End' === event.key) next = MAX_MARKDOWN_SPLIT_PERCENT;
+        else if ('Enter' === event.key) next = DEFAULT_MARKDOWN_SPLIT_PERCENT;
+        if (null === next) return;
+        event.preventDefault();
+        setSourcePanePercent(clampMarkdownSplitPercent(next));
+    };
+    const workspaceStyle = {
+        '--work-markdown-source-pane': `${sourcePanePercent}%`
+    };
+    return /*#__PURE__*/ jsxs("div", {
+        ref: workspaceRef,
+        className: `work-markdown-workspace ${mode}`,
+        "data-split-resizing": resizing || void 0,
+        style: workspaceStyle,
+        children: [
+            showSource && /*#__PURE__*/ jsxs("section", {
+                "aria-label": "Markdown 源码窗格",
+                className: "work-markdown-pane source",
+                children: [
+                    'split' === mode && /*#__PURE__*/ jsx("header", {
+                        className: "work-markdown-pane-label",
+                        children: "编辑"
+                    }),
+                    /*#__PURE__*/ jsx("textarea", {
+                        ref: sourceRef,
+                        "aria-label": "Markdown 源码",
+                        placeholder: "开始写 Markdown…",
+                        value: markdown,
+                        spellCheck: true,
+                        onBeforeInput: (event)=>{
+                            const inputType = event.nativeEvent.inputType;
+                            if ('historyUndo' === inputType) {
+                                event.preventDefault();
+                                onSourceUndo?.();
+                                return;
+                            }
+                            if ('historyRedo' === inputType) {
+                                event.preventDefault();
+                                onSourceRedo?.();
+                                return;
+                            }
+                            sourceInputTypeRef.current = inputType || void 0;
+                        },
+                        onChange: (event)=>{
+                            onSourceIntent?.();
+                            const source = event.currentTarget;
+                            onSourceChange(source.value, markdown_workspace_sourceSelection(source), sourceInputTypeRef.current);
+                            sourceInputTypeRef.current = void 0;
+                        },
+                        onFocus: onSourceIntent,
+                        onContextMenu: onSourceContextMenu,
+                        onKeyDown: (event)=>{
+                            if (isWorkspaceContextMenuKeyboardEvent(event) && onSourceContextMenu?.(event)) return;
+                            if (event.altKey || !(event.metaKey || event.ctrlKey)) return;
+                            const key = event.key.toLocaleLowerCase();
+                            if ('z' === key) {
+                                event.preventDefault();
+                                if (event.shiftKey) onSourceRedo?.();
+                                else onSourceUndo?.();
+                                return;
+                            }
+                            if ('y' === key && !event.shiftKey) {
+                                event.preventDefault();
+                                onSourceRedo?.();
+                                return;
+                            }
+                            if (event.shiftKey) return;
+                            const command = 'b' === key ? 'bold' : 'i' === key ? 'italic' : null;
+                            if (!command || !onSourceCommand?.(command)) return;
+                            event.preventDefault();
+                        },
+                        onKeyUp: (event)=>onSourceSelectionChange?.(markdown_workspace_sourceSelection(event.currentTarget)),
+                        onPointerDown: onSourceIntent,
+                        onPointerUp: (event)=>{
+                            onSourceIntent?.();
+                            onSourceSelectionChange?.(markdown_workspace_sourceSelection(event.currentTarget));
+                        },
+                        onSelect: (event)=>{
+                            onSourceIntent?.();
+                            onSourceSelectionChange?.(markdown_workspace_sourceSelection(event.currentTarget));
+                        },
+                        onScroll: handleSourceScroll
+                    })
+                ]
+            }),
+            'split' === mode && /*#__PURE__*/ jsx("hr", {
+                className: "work-markdown-splitter",
+                "aria-label": "调整编辑与预览宽度",
+                "aria-orientation": "vertical",
+                "aria-valuemin": MIN_MARKDOWN_SPLIT_PERCENT,
+                "aria-valuemax": MAX_MARKDOWN_SPLIT_PERCENT,
+                "aria-valuenow": sourcePanePercent,
+                "aria-valuetext": `编辑窗格 ${sourcePanePercent}%`,
+                tabIndex: 0,
+                title: "拖动调整分栏宽度，双击恢复均分",
+                onDoubleClick: ()=>setSourcePanePercent(DEFAULT_MARKDOWN_SPLIT_PERCENT),
+                onKeyDown: handleResizeKeyDown,
+                onPointerCancel: handleResizeEnd,
+                onPointerDown: handleResizeStart,
+                onPointerMove: handleResizeMove,
+                onPointerUp: handleResizeEnd
+            }),
+            showVisual && /*#__PURE__*/ jsxs("section", {
+                ref: visualRef,
+                "aria-label": visualIsReadOnly ? 'Markdown 预览窗格' : 'Markdown 编辑窗格',
+                className: "work-markdown-pane visual",
+                "data-readonly": visualIsReadOnly ? 'true' : 'false',
+                onContextMenu: onVisualContextMenu,
+                onKeyDownCapture: (event)=>{
+                    if (!isWorkspaceContextMenuKeyboardEvent(event)) return;
+                    onVisualContextMenu?.(event);
+                },
+                onFocusCapture: onVisualIntent,
+                onPointerDownCapture: onVisualIntent,
+                onScroll: handleVisualScroll,
+                children: [
+                    'split' === mode && /*#__PURE__*/ jsx("header", {
+                        className: "work-markdown-pane-label",
+                        children: "预览"
+                    }),
+                    /*#__PURE__*/ jsx("div", {
+                        className: "work-markdown-canvas",
+                        children: /*#__PURE__*/ jsx(EditorContent, {
+                            editor: editor
+                        })
+                    })
+                ]
+            })
+        ]
+    });
+}
+function markdown_workspace_sourceSelection(source) {
+    return {
+        start: source.selectionStart,
+        end: source.selectionEnd,
+        direction: source.selectionDirection
+    };
+}
+function clampMarkdownSplitPercent(value) {
+    return Math.min(MAX_MARKDOWN_SPLIT_PERCENT, Math.max(MIN_MARKDOWN_SPLIT_PERCENT, value));
+}
+const MARKDOWN_SOURCE_HISTORY_LIMIT = 100;
+const MARKDOWN_TYPING_COALESCE_MS = 1000;
+function useMarkdownSourceHistory(initialMarkdown) {
+    const historyRef = useRef({
+        past: [],
+        present: {
+            markdown: initialMarkdown,
+            selection: collapsedSelection(0)
+        },
+        future: [],
+        typing: null
+    });
+    const [, setVersion] = useState(0);
+    const refresh = useCallback(()=>setVersion((value)=>value + 1), []);
+    const record = useCallback((edit, options = {})=>{
+        const history = historyRef.current;
+        const next = normalizeSnapshot(edit);
+        if (next.markdown === history.present.markdown) {
+            history.present = next;
+            return false;
+        }
+        const now = Date.now();
+        const coalesce = true === options.typing && canCoalesceTyping(history, next, options.inputType, now);
+        if (!coalesce) history.past = [
+            ...history.past.slice(-(MARKDOWN_SOURCE_HISTORY_LIMIT - 1)),
+            history.present
+        ];
+        history.present = next;
+        history.future = [];
+        history.typing = options.typing ? {
+            at: now,
+            inputType: options.inputType
+        } : null;
+        refresh();
+        return true;
+    }, [
+        refresh
+    ]);
+    const reset = useCallback((markdown, selection)=>{
+        const next = normalizeSnapshot({
+            markdown,
+            selection
+        });
+        const history = historyRef.current;
+        const changed = history.past.length > 0 || history.future.length > 0 || history.present.markdown !== next.markdown;
+        historyRef.current = {
+            past: [],
+            present: next,
+            future: [],
+            typing: null
+        };
+        if (changed) refresh();
+    }, [
+        refresh
+    ]);
+    const updateSelection = useCallback((selection)=>{
+        const history = historyRef.current;
+        const normalized = normalizeSelection(selection, history.present.markdown.length);
+        if (sameSelection(normalized, history.present.selection)) return;
+        history.present = {
+            ...history.present,
+            selection: normalized
+        };
+        history.typing = null;
+        refresh();
+    }, [
+        refresh
+    ]);
+    const undo = useCallback(()=>{
+        const history = historyRef.current;
+        const previous = history.past.at(-1);
+        if (!previous) return null;
+        history.past = history.past.slice(0, -1);
+        history.future = [
+            ...history.future.slice(-(MARKDOWN_SOURCE_HISTORY_LIMIT - 1)),
+            history.present
+        ];
+        history.present = previous;
+        history.typing = null;
+        refresh();
+        return previous;
+    }, [
+        refresh
+    ]);
+    const redo = useCallback(()=>{
+        const history = historyRef.current;
+        const next = history.future.at(-1);
+        if (!next) return null;
+        history.future = history.future.slice(0, -1);
+        history.past = [
+            ...history.past.slice(-(MARKDOWN_SOURCE_HISTORY_LIMIT - 1)),
+            history.present
+        ];
+        history.present = next;
+        history.typing = null;
+        refresh();
+        return next;
+    }, [
+        refresh
+    ]);
+    return {
+        canUndo: historyRef.current.past.length > 0,
+        canRedo: historyRef.current.future.length > 0,
+        record,
+        redo,
+        reset,
+        undo,
+        updateSelection
+    };
+}
+function canCoalesceTyping(history, next, inputType, now) {
+    const typing = history.typing;
+    if (!typing || now - typing.at > MARKDOWN_TYPING_COALESCE_MS) return false;
+    if (!isContinuousTypingInput(typing.inputType) || !isContinuousTypingInput(inputType)) return false;
+    return history.present.selection.start === history.present.selection.end && next.selection.start === next.selection.end;
+}
+function isContinuousTypingInput(inputType) {
+    return !inputType || 'insertText' === inputType || 'insertCompositionText' === inputType || 'insertLineBreak' === inputType || 'deleteContentBackward' === inputType || 'deleteContentForward' === inputType;
+}
+function normalizeSnapshot(snapshot) {
+    return {
+        markdown: snapshot.markdown,
+        selection: normalizeSelection(snapshot.selection, snapshot.markdown.length)
+    };
+}
+function normalizeSelection(selection, length) {
+    const start = Math.max(0, Math.min(length, selection.start));
+    const end = Math.max(start, Math.min(length, selection.end));
+    return {
+        start,
+        end,
+        direction: selection.direction
+    };
+}
+function collapsedSelection(position) {
+    return {
+        start: position,
+        end: position,
+        direction: 'none'
+    };
+}
+function sameSelection(left, right) {
+    return left.start === right.start && left.end === right.end && left.direction === right.direction;
+}
+const MARKDOWN_PREVIEW_SYNC_DELAY = 160;
+const EMPTY_MARKDOWN_EXTENSIONS = [];
+function MarkdownEditor({ content, extensions: additionalExtensions = EMPTY_MARKDOWN_EXTENSIONS, preview, saveStatus, fileActions, getSelectionMenuItems, onChange }) {
+    const contentRef = useRef(content);
+    const onChangeRef = useRef(onChange);
+    const receivedContentRef = useRef(content);
+    const appliedMarkdownRef = useRef(content.markdown);
+    const emittedMarkdownRef = useRef(null);
+    const sourceMarkdownRef = useRef(content.markdown);
+    const initialMarkdownRef = useRef(content.markdown);
+    const previewTimerRef = useRef(null);
+    const sourceTextareaRef = useRef(null);
+    const markdownRootRef = useRef(null);
+    const [sourceMarkdown, setSourceMarkdown] = useState(content.markdown);
+    const [selectionMenu, setSelectionMenu] = useState(null);
+    const [sourceSelectionRequest, setSourceSelectionRequest] = useState();
+    const [viewMode, setViewMode] = useState('split');
+    const [zoom, setZoom] = useState(100);
+    const [, setSelectionVersion] = useState(0);
+    const { canRedo: canRedoSource, canUndo: canUndoSource, record: recordSourceHistory, redo: redoSourceHistory, reset: resetSourceHistory, undo: undoSourceHistory, updateSelection: updateSourceHistorySelection } = useMarkdownSourceHistory(content.markdown);
+    contentRef.current = content;
+    onChangeRef.current = onChange;
+    const cancelPreviewSync = useCallback(()=>{
+        if (null === previewTimerRef.current) return;
+        clearTimeout(previewTimerRef.current);
+        previewTimerRef.current = null;
+    }, []);
+    const extensions = useMemo(()=>mergeOfficeTiptapExtensions('MarkdownEditor', createWorkMarkdownExtensions(), additionalExtensions), [
+        additionalExtensions
+    ]);
+    const editorProps = useMemo(()=>({
+            attributes: {
+                'aria-label': 'Markdown 编辑区',
+                'aria-multiline': 'true',
+                role: 'textbox',
+                spellcheck: 'true'
+            }
+        }), []);
+    const editor = useEditor({
+        extensions,
+        content: initialMarkdownRef.current,
+        contentType: 'markdown',
+        editable: !preview && 'visual' === viewMode,
+        editorProps,
+        onUpdate: ({ editor: current })=>{
+            const markdown = current.getMarkdown();
+            if (markdown === appliedMarkdownRef.current) return;
+            cancelPreviewSync();
+            const next = {
+                ...contentRef.current,
+                markdown
+            };
+            appliedMarkdownRef.current = markdown;
+            emittedMarkdownRef.current = markdown;
+            sourceMarkdownRef.current = markdown;
+            contentRef.current = next;
+            setSourceMarkdown(markdown);
+            resetSourceHistory(markdown, textareaSelection(sourceTextareaRef.current, markdown.length));
+            onChangeRef.current(next);
+        },
+        onSelectionUpdate: ()=>setSelectionVersion((value)=>value + 1)
+    }, [
+        extensions
+    ]);
+    const applyMarkdownToEditor = useCallback((markdown)=>{
+        cancelPreviewSync();
+        if (!editor || editor.isDestroyed || appliedMarkdownRef.current === markdown) return;
+        appliedMarkdownRef.current = markdown;
+        editor.commands.setWorkMarkdown(markdown, {
+            emitUpdate: false
+        });
+    }, [
+        cancelPreviewSync,
+        editor
+    ]);
+    const queueMarkdownPreview = useCallback((markdown, immediate = false)=>{
+        cancelPreviewSync();
+        if (!editor || editor.isDestroyed || appliedMarkdownRef.current === markdown) return;
+        if (immediate) return void applyMarkdownToEditor(markdown);
+        previewTimerRef.current = setTimeout(()=>{
+            previewTimerRef.current = null;
+            applyMarkdownToEditor(markdown);
+        }, MARKDOWN_PREVIEW_SYNC_DELAY);
+    }, [
+        applyMarkdownToEditor,
+        cancelPreviewSync,
+        editor
+    ]);
+    useEffect(()=>cancelPreviewSync, [
+        cancelPreviewSync
+    ]);
+    useEffect(()=>{
+        if (!editor) return;
+        const visualEditorReadOnly = preview || 'visual' !== viewMode;
+        let checkboxFrame = null;
+        const applyTaskCheckboxState = ()=>{
+            for (const checkbox of editor.view.dom.querySelectorAll('li[data-type="taskItem"] > label input[type="checkbox"]')){
+                checkbox.disabled = visualEditorReadOnly;
+                checkbox.setAttribute('aria-disabled', String(visualEditorReadOnly));
+                checkbox.setAttribute('aria-label', markdownTaskCheckboxLabel({
+                    attrs: {
+                        checked: checkbox.checked
+                    },
+                    textContent: checkbox.closest('li[data-type="taskItem"]')?.textContent ?? ''
+                }));
+            }
+        };
+        const scheduleTaskCheckboxState = ()=>{
+            if (null !== checkboxFrame) cancelAnimationFrame(checkboxFrame);
+            checkboxFrame = requestAnimationFrame(()=>{
+                checkboxFrame = null;
+                applyTaskCheckboxState();
+            });
+        };
+        const applyViewState = ()=>{
+            if (editor.isDestroyed) return;
+            editor.setEditable(!visualEditorReadOnly, false);
+            editor.view.dom.setAttribute('aria-label', visualEditorReadOnly ? 'Markdown 预览' : 'Markdown 编辑区');
+            editor.view.dom.setAttribute('aria-readonly', String(visualEditorReadOnly));
+            editor.view.dom.setAttribute('role', visualEditorReadOnly ? 'document' : 'textbox');
+            if (visualEditorReadOnly) {
+                editor.view.dom.removeAttribute('aria-multiline');
+                editor.view.dom.tabIndex = 0;
+            } else {
+                editor.view.dom.setAttribute('aria-multiline', 'true');
+                editor.view.dom.removeAttribute('tabindex');
+            }
+            applyTaskCheckboxState();
+            scheduleTaskCheckboxState();
+        };
+        applyViewState();
+        editor.on('mount', applyViewState);
+        editor.on('update', applyTaskCheckboxState);
+        editor.on('transaction', scheduleTaskCheckboxState);
+        return ()=>{
+            if (null !== checkboxFrame) cancelAnimationFrame(checkboxFrame);
+            editor.off('mount', applyViewState);
+            editor.off('update', applyTaskCheckboxState);
+            editor.off('transaction', scheduleTaskCheckboxState);
+        };
+    }, [
+        editor,
+        preview,
+        viewMode
+    ]);
+    useEffect(()=>{
+        if (!editor || receivedContentRef.current === content) return;
+        receivedContentRef.current = content;
+        const markdown = content.markdown;
+        if (sourceMarkdownRef.current !== markdown) {
+            sourceMarkdownRef.current = markdown;
+            setSourceMarkdown(markdown);
+        }
+        if (emittedMarkdownRef.current === markdown) {
+            emittedMarkdownRef.current = null;
+            return;
+        }
+        emittedMarkdownRef.current = null;
+        resetSourceHistory(markdown, textareaSelection(sourceTextareaRef.current, markdown.length));
+        if (preview || 'source' !== viewMode) queueMarkdownPreview(markdown, true);
+    }, [
+        content,
+        editor,
+        preview,
+        queueMarkdownPreview,
+        resetSourceHistory,
+        viewMode
+    ]);
+    const updateSource = useCallback((markdown)=>{
+        if (markdown === sourceMarkdownRef.current) return;
+        sourceMarkdownRef.current = markdown;
+        setSourceMarkdown(markdown);
+        const next = {
+            ...contentRef.current,
+            markdown
+        };
+        contentRef.current = next;
+        emittedMarkdownRef.current = markdown;
+        onChangeRef.current(next);
+        if ('source' !== viewMode) queueMarkdownPreview(markdown);
+    }, [
+        queueMarkdownPreview,
+        viewMode
+    ]);
+    const getSourceSelection = useCallback(()=>{
+        const source = sourceTextareaRef.current;
+        if (!source) return null;
+        const selection = textareaSelection(source, sourceMarkdownRef.current.length);
+        return {
+            markdown: sourceMarkdownRef.current,
+            selection,
+            text: sourceMarkdownRef.current.slice(selection.start, selection.end)
+        };
+    }, []);
+    const requestSourceSelection = useCallback((selection)=>{
+        setSourceSelectionRequest((current)=>({
+                ...selection,
+                revision: (current?.revision ?? 0) + 1
+            }));
+    }, []);
+    const applySourceEdit = useCallback((edit)=>{
+        recordSourceHistory(edit);
+        updateSource(edit.markdown);
+        requestSourceSelection(edit.selection);
+        return true;
+    }, [
+        recordSourceHistory,
+        requestSourceSelection,
+        updateSource
+    ]);
+    const changeSource = useCallback((markdown, selection, inputType)=>{
+        const edit = {
+            markdown,
+            selection
+        };
+        if (!recordSourceHistory(edit, {
+            typing: true,
+            inputType
+        })) return;
+        updateSource(markdown);
+    }, [
+        recordSourceHistory,
+        updateSource
+    ]);
+    const applySourceHistory = useCallback((edit)=>{
+        if (!edit) return false;
+        updateSource(edit.markdown);
+        requestSourceSelection(edit.selection);
+        return true;
+    }, [
+        requestSourceSelection,
+        updateSource
+    ]);
+    const undoSource = useCallback(()=>applySourceHistory(undoSourceHistory()), [
+        applySourceHistory,
+        undoSourceHistory
+    ]);
+    const redoSource = useCallback(()=>applySourceHistory(redoSourceHistory()), [
+        applySourceHistory,
+        redoSourceHistory
+    ]);
+    const runSourceCommand = useCallback((command)=>{
+        const current = getSourceSelection();
+        if (!current) return false;
+        return applySourceEdit(applyMarkdownSourceCommand(current.markdown, current.selection, command));
+    }, [
+        applySourceEdit,
+        getSourceSelection
+    ]);
+    const replaceSourceSelection = useCallback((replacement, selectedRange, target)=>{
+        const current = target ?? getSourceSelection();
+        if (!current) return false;
+        if (current.markdown !== sourceMarkdownRef.current) return false;
+        return applySourceEdit(replaceMarkdownSourceSelection(current.markdown, current.selection, replacement, selectedRange));
+    }, [
+        applySourceEdit,
+        getSourceSelection
+    ]);
+    const handleSourceSelectionChange = useCallback((selection)=>{
+        updateSourceHistorySelection(selection);
+        setSelectionVersion((value)=>value + 1);
+    }, [
+        updateSourceHistorySelection
+    ]);
+    const handleVisualIntent = useCallback(()=>{
+        applyMarkdownToEditor(sourceMarkdownRef.current);
+    }, [
+        applyMarkdownToEditor
+    ]);
+    const openSourceSelectionMenu = useCallback((event)=>{
+        if (!getSelectionMenuItems) return false;
+        const current = getSourceSelection();
+        if (!current) return false;
+        const snapshot = createWorkMarkdownSourceSelectionSnapshot(current.markdown, current.selection, contentRef.current);
+        if (!snapshot) return false;
+        event.preventDefault();
+        event.stopPropagation();
+        const position = workspaceContextMenuPosition(event, workspaceTextControlSelectionBounds(event.currentTarget));
+        const items = getSelectionMenuItems(snapshot);
+        setSelectionMenu(items.length ? {
+            x: position.x,
+            y: position.y,
+            snapshot,
+            items
+        } : null);
+        return items.length > 0;
+    }, [
+        getSelectionMenuItems,
+        getSourceSelection
+    ]);
+    const openVisualSelectionMenu = useCallback((event)=>{
+        if (!editor || !getSelectionMenuItems) return false;
+        const snapshot = createWorkMarkdownVisualSelectionSnapshot(editor, contentRef.current);
+        if (!snapshot) return false;
+        event.preventDefault();
+        event.stopPropagation();
+        const position = workspaceContextMenuPosition(event);
+        const items = getSelectionMenuItems(snapshot);
+        setSelectionMenu(items.length ? {
+            x: position.x,
+            y: position.y,
+            snapshot,
+            items
+        } : null);
+        return items.length > 0;
+    }, [
+        editor,
+        getSelectionMenuItems
+    ]);
+    const createSourceSelectionAction = useCallback((snapshot)=>createWorkMarkdownSourceSelectionAction(snapshot, ()=>sourceMarkdownRef.current, applySourceEdit), [
+        applySourceEdit
+    ]);
+    const changeViewMode = useCallback((mode)=>{
+        const focusSurface = 'visual' === mode ? 'visual' : 'source';
+        if ('source' !== mode) applyMarkdownToEditor(sourceMarkdownRef.current);
+        setViewMode(mode);
+        restoreMarkdownEditingSurfaceFocus(()=>{
+            if ('source' === focusSurface) return sourceTextareaRef.current;
+            return editor && !editor.isDestroyed ? editor.view.dom : null;
+        });
+    }, [
+        applyMarkdownToEditor,
+        editor
+    ]);
+    const deferredMarkdown = useDeferredValue(sourceMarkdown);
+    const metrics = useMemo(()=>markdownMetrics(deferredMarkdown), [
+        deferredMarkdown
+    ]);
+    const editorStyle = {
+        '--work-markdown-zoom': zoom
+    };
+    useOfficeEditorWheelZoom({
+        enabled: Boolean(editor),
+        scopeRef: markdownRootRef,
+        onZoomIn: ()=>setZoom((current)=>stepOfficeZoom(current, 'in', {
+                    minimum: 60,
+                    maximum: 180
+                })),
+        onZoomOut: ()=>setZoom((current)=>stepOfficeZoom(current, 'out', {
+                    minimum: 60,
+                    maximum: 180
+                }))
+    });
+    if (!editor) return /*#__PURE__*/ jsx(WorkEditorLoadingState, {
+        title: "正在准备 Markdown 编辑器"
+    });
+    if (preview) return /*#__PURE__*/ jsxs("section", {
+        ref: markdownRootRef,
+        className: "work-markdown-editor preview",
+        style: editorStyle,
+        children: [
+            /*#__PURE__*/ jsx(WorkOfficePreviewBar, {
+                ariaLabel: "Markdown 预览工具",
+                label: "只读预览",
+                detail: `${metrics.lineCount} 行`,
+                fileActions: fileActions,
+                className: "work-markdown-ribbon"
+            }),
+            /*#__PURE__*/ jsx(MarkdownWorkspace, {
+                editor: editor,
+                markdown: sourceMarkdown,
+                mode: "visual",
+                readOnly: true,
+                sourceRef: sourceTextareaRef,
+                onSourceChange: updateSource,
+                onVisualIntent: handleVisualIntent
+            }),
+            /*#__PURE__*/ jsx(MarkdownStatus, {
+                characterCount: metrics.characterCount,
+                lineCount: metrics.lineCount,
+                saveStatus: saveStatus,
+                zoom: zoom,
+                onZoomChange: setZoom
+            })
+        ]
+    });
+    return /*#__PURE__*/ jsxs("section", {
+        ref: markdownRootRef,
+        className: "work-markdown-editor",
+        style: editorStyle,
+        children: [
+            /*#__PURE__*/ jsx(MarkdownToolbar, {
+                editor: editor,
+                fileActions: fileActions,
+                sourceEditing: 'visual' !== viewMode,
+                canSourceRedo: canRedoSource,
+                canSourceUndo: canUndoSource,
+                viewMode: viewMode,
+                getSourceFocusTarget: ()=>sourceTextareaRef.current,
+                getSourceSelection: getSourceSelection,
+                onSourceCommand: runSourceCommand,
+                onSourceRedo: redoSource,
+                onSourceReplace: replaceSourceSelection,
+                onSourceUndo: undoSource,
+                onViewModeChange: changeViewMode
+            }),
+            /*#__PURE__*/ jsx(MarkdownWorkspace, {
+                editor: editor,
+                markdown: sourceMarkdown,
+                mode: viewMode,
+                visualReadOnly: 'split' === viewMode,
+                sourceRef: sourceTextareaRef,
+                sourceSelectionRequest: sourceSelectionRequest,
+                onSourceChange: changeSource,
+                onSourceCommand: runSourceCommand,
+                onSourceContextMenu: getSelectionMenuItems ? openSourceSelectionMenu : void 0,
+                onSourceRedo: redoSource,
+                onSourceSelectionChange: handleSourceSelectionChange,
+                onSourceUndo: undoSource,
+                onVisualContextMenu: getSelectionMenuItems ? openVisualSelectionMenu : void 0,
+                onVisualIntent: handleVisualIntent
+            }),
+            /*#__PURE__*/ jsx(MarkdownStatus, {
+                characterCount: metrics.characterCount,
+                lineCount: metrics.lineCount,
+                saveStatus: saveStatus,
+                zoom: zoom,
+                onZoomChange: setZoom
+            }),
+            selectionMenu && /*#__PURE__*/ jsx(MarkdownSelectionContextMenu, {
+                editor: editor,
+                menu: selectionMenu,
+                createSourceAction: createSourceSelectionAction,
+                onClose: ()=>setSelectionMenu(null)
+            })
+        ]
+    });
+}
+function textareaSelection(textarea, fallbackPosition) {
+    if (!textarea) return {
+        start: fallbackPosition,
+        end: fallbackPosition,
+        direction: 'none'
+    };
+    return {
+        start: textarea.selectionStart,
+        end: textarea.selectionEnd,
+        direction: textarea.selectionDirection
+    };
+}
+function markdownMetrics(markdown) {
+    return {
+        lineCount: markdown ? markdown.replace(/\r\n?/g, '\n').split('\n').length : 1,
+        characterCount: Array.from(markdown).length
+    };
+}
+export { markdown_editor_namespaceObject };