phormat 0.0.5

package/dist/editor/model/blockEditCommands.js

@@ -0,0 +1,719 @@
+import { headingDisplayPlain, headingMarkdown, headingPlainOffsetToSourceOffset } from '../block-specs/heading/edit';
+import { paragraphBlockFromPlainText, paragraphBlockToPlainText, paragraphDisplayPlain, paragraphPlainOffsetToSourceOffset, serializeParagraphData } from '../block-specs/paragraph';
+import { applyEditorTransaction, deleteBlockTransaction, duplicateBlockTransaction } from './editorTransactions';
+import { EMPTY_PARAGRAPH_MARKER, normalizeEmptySource } from './emptyParagraph';
+import { clampSelection } from './types';
+import { cloneInlineNodeDeep, inlineTextNode, mergePlainTypingIntoInlines, wrapInlineSelection } from './inlineEditCommands';
+import { inlineNodesToPlainText } from './inlinePlain';
+import { applyInlineSecondPass } from './inlineSecondPass';
+import { parseMarkdownDocument } from './parseMarkdownDocument';
+import { serializeInlineNodes } from './serializeInlineNodes';
+export const EDITOR_HISTORY_LIMIT = 120;
+export function replaceSourceRange(source, start, end, replacement) {
+    return source.slice(0, start) + replacement + source.slice(end);
+}
+/** Serialized block markdown often omits the final line terminator that `sourceRange.end` still covers. */
+export function normalizeBlockSliceReplacement(source, start, end, replacement) {
+    if (end > start &&
+        source.charCodeAt(end - 1) === 10 &&
+        replacement.length > 0 &&
+        !replacement.endsWith('\n')) {
+        return replacement + '\n';
+    }
+    return replacement;
+}
+export function replaceBlockSourceRange(source, start, end, replacement) {
+    return replaceSourceRange(source, start, end, normalizeBlockSliceReplacement(source, start, end, replacement));
+}
+export { paragraphBlockFromPlainText, paragraphBlockToPlainText, paragraphDisplayPlain, paragraphPlainOffsetToSourceOffset } from '../block-specs/paragraph';
+export { headingBodySourceRange, headingDisplayPlain, headingMarkdown, headingPlainOffsetToSourceOffset } from '../block-specs/heading/edit';
+/** Replace paragraph or heading body from a plain-text edit; preserves `inlines` when a single-character delta patches the AST. */
+export function updateBlockPlainText(source, doc, blockIndex, plainText, kind, selectionPlainOffset) {
+    const block = doc.blocks[blockIndex];
+    if (!block)
+        return { ok: false, error: 'Invalid block index.' };
+    if (block.sourceRange.synthetic || block.sourceRange.start < 0) {
+        return { ok: false, error: 'Block is not editable.' };
+    }
+    let replacement;
+    if (kind === 'paragraph' && block.type === 'paragraph') {
+        const prev = block.data;
+        if (block.inlines?.length) {
+            const oldPlain = inlineNodesToPlainText(block.inlines);
+            if (plainText === oldPlain || plainText === `${oldPlain}\n`) {
+                const anchor = block.sourceRange.end;
+                return {
+                    ok: true,
+                    source,
+                    selection: clampSelection({ anchor, focus: anchor }, source.length)
+                };
+            }
+            const merged = mergePlainTypingIntoInlines(block.inlines, plainText);
+            if (merged) {
+                replacement = serializeInlineNodes(merged);
+            }
+            else {
+                replacement = serializeParagraphData(paragraphBlockFromPlainText(plainText, prev.startLineIndex));
+            }
+        }
+        else {
+            replacement = serializeParagraphData(paragraphBlockFromPlainText(plainText, prev.startLineIndex));
+        }
+    }
+    else if (kind === 'heading' && block.type === 'heading') {
+        const prev = block.data;
+        if (block.inlines?.length) {
+            const merged = mergePlainTypingIntoInlines(block.inlines, plainText);
+            if (merged) {
+                replacement = headingMarkdown(prev.level, serializeInlineNodes(merged));
+            }
+            else {
+                replacement = headingMarkdown(prev.level, plainText);
+            }
+        }
+        else {
+            replacement = headingMarkdown(prev.level, plainText);
+        }
+    }
+    else {
+        return { ok: false, error: 'Block kind mismatch.' };
+    }
+    const newSource = replaceBlockSourceRange(source, block.sourceRange.start, block.sourceRange.end, replacement);
+    const co = Math.max(0, selectionPlainOffset);
+    let anchor;
+    if (kind === 'paragraph') {
+        const prev = block.data;
+        const tmpBlock = {
+            type: 'paragraph',
+            id: 'tmp',
+            sourceRange: { start: 0, end: replacement.length, startLine: 0, endLine: 0 },
+            data: paragraphBlockFromPlainText(plainText, prev.startLineIndex)
+        };
+        const inner = paragraphPlainOffsetToSourceOffset(tmpBlock, Math.min(co, plainText.length));
+        anchor = block.sourceRange.start + inner;
+    }
+    else {
+        const prev = block.data;
+        const tmpHeadingBlock = {
+            type: 'heading',
+            id: 'tmp',
+            sourceRange: { start: 0, end: replacement.length, startLine: 0, endLine: 0 },
+            data: { ...prev, text: plainText }
+        };
+        const inner = headingPlainOffsetToSourceOffset(tmpHeadingBlock, replacement, Math.min(co, plainText.length));
+        anchor = block.sourceRange.start + inner;
+    }
+    const sel = clampSelection({ anchor, focus: anchor }, newSource.length);
+    return { ok: true, source: newSource, selection: sel };
+}
+/** Wrap plain-text selection in Markdown inline spans (paragraph or heading body). */
+export function applyInlineWrap(source, doc, blockIndex, plainStart, plainEnd, kind, linkHref) {
+    const block = doc.blocks[blockIndex];
+    if (!block)
+        return { ok: false, error: 'Invalid block index.' };
+    if (block.sourceRange.synthetic || block.sourceRange.start < 0) {
+        return { ok: false, error: 'Block is not editable.' };
+    }
+    const a = Math.min(plainStart, plainEnd);
+    const b = Math.max(plainStart, plainEnd);
+    if (block.type === 'paragraph') {
+        const p = block.data;
+        const baseNodes = block.inlines?.length
+            ? block.inlines.map(cloneInlineNodeDeep)
+            : [inlineTextNode(paragraphBlockToPlainText(p))];
+        const wrapped = wrapInlineSelection(baseNodes, a, b, kind, linkHref);
+        if (!wrapped)
+            return { ok: false, error: 'Could not apply inline format.' };
+        const replacement = serializeInlineNodes(wrapped);
+        const newPlain = inlineNodesToPlainText(wrapped);
+        const newSource = replaceBlockSourceRange(source, block.sourceRange.start, block.sourceRange.end, replacement);
+        const tmpBlock = {
+            type: 'paragraph',
+            id: 'tmp',
+            sourceRange: { start: 0, end: replacement.length, startLine: 0, endLine: 0 },
+            data: paragraphBlockFromPlainText(newPlain, p.startLineIndex)
+        };
+        const inner = paragraphPlainOffsetToSourceOffset(tmpBlock, Math.min(b, newPlain.length));
+        const anchor = block.sourceRange.start + inner;
+        return {
+            ok: true,
+            source: newSource,
+            selection: clampSelection({ anchor, focus: anchor }, newSource.length)
+        };
+    }
+    if (block.type === 'heading') {
+        const hb = block.data;
+        const baseNodes = block.inlines?.length
+            ? block.inlines.map(cloneInlineNodeDeep)
+            : [inlineTextNode(hb.text)];
+        const wrapped = wrapInlineSelection(baseNodes, a, b, kind, linkHref);
+        if (!wrapped)
+            return { ok: false, error: 'Could not apply inline format.' };
+        const bodyMd = serializeInlineNodes(wrapped);
+        const replacement = headingMarkdown(hb.level, bodyMd);
+        const newPlain = inlineNodesToPlainText(wrapped);
+        const newSource = replaceBlockSourceRange(source, block.sourceRange.start, block.sourceRange.end, replacement);
+        const tmpHeadingBlock = {
+            type: 'heading',
+            id: 'tmp',
+            sourceRange: { start: 0, end: replacement.length, startLine: 0, endLine: 0 },
+            data: { ...hb, text: newPlain },
+            inlines: wrapped
+        };
+        const inner = headingPlainOffsetToSourceOffset(tmpHeadingBlock, replacement, Math.min(b, newPlain.length));
+        const anchor = block.sourceRange.start + inner;
+        return {
+            ok: true,
+            source: newSource,
+            selection: clampSelection({ anchor, focus: anchor }, newSource.length)
+        };
+    }
+    return { ok: false, error: 'Inline formatting applies to paragraphs and headings only.' };
+}
+/** Turn `# title` / `- item` / `1. item` plain lines into the corresponding Markdown block slice. */
+export function isStructuralMarkdownShortcutLine(plainText) {
+    return paragraphShortcutMarkdown(plainText) !== null;
+}
+/** Whether Space, Enter, or blur should run **structural markdown shortcut** for this plain line. */
+export function isStructuralMarkdownShortcutTrigger(plainText, trigger, options) {
+    if (paragraphShortcutMarkdown(plainText) !== null)
+        return true;
+    if (!options?.allowMarkerOnlyList || trigger === 'blur')
+        return false;
+    return markerOnlyListShortcutMarkdown(plainText) !== null;
+}
+/** Marker-only list/task prefixes completed by Space or Enter (not blur). Paragraph bodies only. */
+export function markerOnlyListShortcutMarkdown(plainText) {
+    const lines = plainText.split('\n');
+    if (lines.length !== 1)
+        return null;
+    const line = lines[0] ?? '';
+    const task = line.match(/^-\s+\[([ xX/>])\]$/);
+    if (task)
+        return `- [${task[1]}] `;
+    const bullet = line.match(/^[-*+]$/);
+    if (bullet)
+        return `${line} `;
+    const ordered = line.match(/^(\d+)$/);
+    if (ordered)
+        return `${ordered[1]}. `;
+    return null;
+}
+export function paragraphShortcutMarkdown(plainText) {
+    const lines = plainText.split('\n');
+    if (lines.length !== 1)
+        return null;
+    const line = lines[0] ?? '';
+    const hm = line.match(/^(#{1,6})\s+(.*)$/);
+    if (hm) {
+        const level = hm[1].length;
+        return headingMarkdown(level, hm[2].trimEnd());
+    }
+    const taskEmpty = line.match(/^-\s+\[([ xX/>])\]\s+$/);
+    if (taskEmpty)
+        return `- [${taskEmpty[1]}] `;
+    const task = line.match(/^-\s+\[([ xX/>])\]\s+(.+)$/);
+    if (task) {
+        const body = task[2].trimEnd();
+        return `- [${task[1]}] ${body}`;
+    }
+    const bulletEmpty = line.match(/^([-*+])\s+$/);
+    if (bulletEmpty)
+        return `${bulletEmpty[1]} `;
+    const um = line.match(/^([-*+])\s+(.+)$/);
+    if (um && !um[2].trimStart().startsWith('[')) {
+        const marker = um[1];
+        const body = um[2].trimEnd();
+        return `${marker} ${body}`;
+    }
+    const orderedEmpty = line.match(/^(\d+)\.\s+$/);
+    if (orderedEmpty)
+        return `${orderedEmpty[1]}. `;
+    const om = line.match(/^(\d+)\.\s+(.*)$/);
+    if (om) {
+        const n = om[1];
+        const body = om[2].trimEnd();
+        return body.length > 0 ? `${n}. ${body}` : `${n}. `;
+    }
+    return null;
+}
+function listShortcutBodyPlainLength(plainText, md) {
+    const task = plainText.match(/^-\s+\[([ xX/>])\](?:\s+(.*))?$/);
+    if (task && /^-\s+\[/.test(md))
+        return (task[2] ?? '').trimEnd().length;
+    const bullet = plainText.match(/^([-*+])(?:\s+(.*))?$/);
+    if (bullet && /^[-*+]\s/.test(md))
+        return (bullet[2] ?? '').trimEnd().length;
+    const ordered = plainText.match(/^(\d+)(?:\.\s+(.*))?$/);
+    if (ordered && /^\d+\.\s/.test(md))
+        return (ordered[2] ?? '').trimEnd().length;
+    return 0;
+}
+/** Focus after **structural markdown shortcut** conversion (heading body plain or list item body). */
+export function buildStructuralShortcutFocusOutcome(doc, blockIndex, plainText, md) {
+    const block = doc.blocks[blockIndex];
+    if (!block)
+        return { mode: 'blockId', blockId: '', plain: { start: 0, end: 0 } };
+    const hm = plainText.match(/^(#{1,6})\s+(.*)$/);
+    if (hm && /^#{1,6}\s/.test(md)) {
+        const bodyLen = hm[2].trimEnd().length;
+        return {
+            mode: 'sourceOffset',
+            offset: block.sourceRange.start,
+            plain: { start: bodyLen, end: bodyLen }
+        };
+    }
+    if (/^-\s+\[/.test(md) || /^[-*+]\s/.test(md) || /^\d+\.\s/.test(md)) {
+        const bodyLen = listShortcutBodyPlainLength(plainText, md);
+        return {
+            mode: 'sourceOffset',
+            offset: block.sourceRange.start,
+            plain: { start: bodyLen, end: bodyLen }
+        };
+    }
+    return { mode: 'blockId', blockId: block.id, plain: { start: 0, end: 0 } };
+}
+/** Apply line-start markdown shortcut on a top-level **paragraph** or **heading** body. */
+export function applyStructuralMarkdownShortcut(source, doc, blockIndex, plainText) {
+    const block = doc.blocks[blockIndex];
+    if (!block || (block.type !== 'paragraph' && block.type !== 'heading')) {
+        return { ok: false, error: 'Unsupported block type for shortcut.' };
+    }
+    if (block.sourceRange.synthetic || block.sourceRange.start < 0) {
+        return { ok: false, error: 'Block is not editable.' };
+    }
+    const md = paragraphShortcutMarkdown(plainText) ??
+        (block.type === 'paragraph' ? markerOnlyListShortcutMarkdown(plainText) : null);
+    if (!md)
+        return { ok: false, error: 'No shortcut applied.' };
+    const newSource = replaceBlockSourceRange(source, block.sourceRange.start, block.sourceRange.end, md);
+    const focusAfter = buildStructuralShortcutFocusOutcome(doc, blockIndex, plainText, md);
+    const sel = clampSelection({ anchor: block.sourceRange.start + md.length, focus: block.sourceRange.start + md.length }, newSource.length);
+    return { ok: true, source: newSource, selection: sel, focusAfter };
+}
+/** @deprecated Prefer {@link applyStructuralMarkdownShortcut}. */
+export function applyParagraphShortcut(source, doc, blockIndex, plainText) {
+    const r = applyStructuralMarkdownShortcut(source, doc, blockIndex, plainText);
+    if (!r.ok)
+        return r;
+    const { focusAfter: _, ...rest } = r;
+    return rest;
+}
+export function splitBlockAtPlainOffset(source, doc, blockIndex, plainOffset, kind) {
+    const block = doc.blocks[blockIndex];
+    if (!block)
+        return { ok: false, error: 'Invalid block index.' };
+    if (block.sourceRange.synthetic || block.sourceRange.start < 0) {
+        return { ok: false, error: 'Block is not splittable.' };
+    }
+    if (kind === 'paragraph' && block.type === 'paragraph') {
+        const p = block.data;
+        const plain = paragraphDisplayPlain(block);
+        if (plainOffset < 0 || plainOffset > plain.length) {
+            return { ok: false, error: 'Caret out of range.' };
+        }
+        if (plainOffset === 0 || plainOffset === plain.length) {
+            return { ok: false, error: 'Use empty paragraph insert for boundary split.' };
+        }
+        const left = plain.slice(0, plainOffset);
+        const right = plain.slice(plainOffset);
+        const leftMd = serializeParagraphData(paragraphBlockFromPlainText(left, p.startLineIndex));
+        const rightMd = serializeParagraphData(paragraphBlockFromPlainText(right, p.startLineIndex + left.split('\n').length));
+        const replacement = `${leftMd}\n\n${rightMd}`;
+        const newSource = replaceSourceRange(source, block.sourceRange.start, block.sourceRange.end, replacement);
+        const caretPlainInSecond = 0;
+        const para2ApproxStart = block.sourceRange.start + leftMd.length + 2;
+        const anchor = para2ApproxStart + caretPlainInSecond;
+        return {
+            ok: true,
+            source: newSource,
+            selection: clampSelection({ anchor, focus: anchor }, newSource.length)
+        };
+    }
+    if (kind === 'heading' && block.type === 'heading') {
+        const hb = block.data;
+        const text = headingDisplayPlain(block);
+        if (plainOffset < 0 || plainOffset > text.length) {
+            return { ok: false, error: 'Caret out of range.' };
+        }
+        if (plainOffset === 0 || plainOffset === text.length) {
+            return { ok: false, error: 'Use empty paragraph insert for boundary split.' };
+        }
+        const left = text.slice(0, plainOffset).trimEnd();
+        const right = text.slice(plainOffset).trimStart();
+        const leftMd = headingMarkdown(hb.level, left);
+        const rightMd = serializeParagraphData(paragraphBlockFromPlainText(right, hb.lineIndex + 1));
+        const replacement = `${leftMd}\n\n${rightMd}`;
+        const newSource = replaceSourceRange(source, block.sourceRange.start, block.sourceRange.end, replacement);
+        const anchor = block.sourceRange.start + leftMd.length + 2;
+        return {
+            ok: true,
+            source: newSource,
+            selection: clampSelection({ anchor, focus: anchor }, newSource.length)
+        };
+    }
+    return { ok: false, error: 'Split not supported for this block type.' };
+}
+/** Insert an empty paragraph before (`after === false`) or after the block. */
+export function insertEmptyParagraphRelative(source, doc, blockIndex, after) {
+    const block = doc.blocks[blockIndex];
+    if (!block) {
+        const normalized = normalizeEmptySource(source);
+        return {
+            ok: true,
+            source: normalized,
+            selection: clampSelection({ anchor: 0, focus: 0 }, normalized.length)
+        };
+    }
+    const emptyBody = EMPTY_PARAGRAPH_MARKER;
+    let pos;
+    let insertion;
+    if (after) {
+        pos = block.sourceRange.end;
+        let suffix = '';
+        for (let i = blockIndex + 1; i < doc.blocks.length; i++) {
+            const candidate = doc.blocks[i];
+            if (candidate.sourceRange.start >= 0) {
+                if (candidate.sourceRange.start === pos)
+                    suffix = '\n';
+                break;
+            }
+        }
+        insertion = `\n\n${emptyBody}${suffix}`;
+    }
+    else {
+        pos = block.sourceRange.start;
+        insertion = `${emptyBody}\n\n`;
+    }
+    const newSource = replaceSourceRange(source, pos, pos, insertion);
+    const caret = after ? pos + 2 + emptyBody.length : pos + emptyBody.length;
+    return {
+        ok: true,
+        source: newSource,
+        selection: clampSelection({ anchor: caret, focus: caret }, newSource.length)
+    };
+}
+/** Source transaction for inserting a canonical empty **paragraph** sibling. */
+export function buildEmptyParagraphInsertTransaction(source, doc, blockIndex, after, txId) {
+    const block = doc.blocks[blockIndex];
+    if (!block)
+        return { ok: false, error: 'Invalid block index.' };
+    if (block.sourceRange.start < 0)
+        return { ok: false, error: 'Block is not editable.' };
+    const before = source;
+    const edit = insertEmptyParagraphRelative(before, doc, blockIndex, after);
+    const pos = after ? block.sourceRange.end : block.sourceRange.start;
+    const insertion = edit.source.slice(pos, pos + (edit.source.length - before.length));
+    return {
+        ok: true,
+        transaction: {
+            id: txId,
+            operations: [{ type: 'replaceSlice', range: { start: pos, end: pos }, text: insertion }],
+            selection: edit.selection
+        }
+    };
+}
+export function mergeWithPreviousBlock(source, doc, blockIndex) {
+    if (blockIndex <= 0)
+        return { ok: false, error: 'Nothing to merge into.' };
+    const prev = doc.blocks[blockIndex - 1];
+    const curr = doc.blocks[blockIndex];
+    if (prev.sourceRange.synthetic || curr.sourceRange.synthetic) {
+        return { ok: false, error: 'Cannot merge synthetic blocks.' };
+    }
+    const start = prev.sourceRange.start;
+    const end = curr.sourceRange.end;
+    let replacement;
+    let anchor;
+    let focusAfter;
+    if (prev.type === 'paragraph' && curr.type === 'paragraph') {
+        const a = prev.data;
+        const b = curr.data;
+        const leftMd = serializeParagraphData(a).replace(/[ \t]+$/, '');
+        const rightMd = serializeParagraphData(b).replace(/^[ \t]+/, '');
+        const leftPlain = paragraphDisplayPlain(prev).replace(/[ \t]+$/, '');
+        const rightPlain = paragraphDisplayPlain(curr).replace(/^[ \t]+/, '');
+        const separator = leftMd.length > 0 && rightMd.length > 0 ? ' ' : '';
+        const plainSeparator = leftPlain.length > 0 && rightPlain.length > 0 ? 1 : 0;
+        replacement = `${leftMd}${separator}${rightMd}`;
+        anchor = start + leftMd.length + separator.length;
+        const joinPlain = leftPlain.length + plainSeparator;
+        focusAfter = {
+            mode: 'blockId',
+            blockId: prev.id,
+            plain: { start: joinPlain, end: joinPlain }
+        };
+    }
+    else if (prev.type === 'heading' && curr.type === 'heading') {
+        const a = prev.data;
+        const b = curr.data;
+        const level = Math.min(a.level, b.level);
+        const mergedText = `${a.text} ${b.text}`.trim();
+        replacement = headingMarkdown(level, mergedText);
+        const caretPlain = Math.min(a.text.length + 1, mergedText.length);
+        anchor = start + headingMarkdown(level, mergedText.slice(0, caretPlain)).length;
+        focusAfter = {
+            mode: 'blockId',
+            blockId: prev.id,
+            plain: { start: caretPlain, end: caretPlain }
+        };
+    }
+    else if (prev.type === 'heading' && curr.type === 'paragraph') {
+        const h = prev.data;
+        const p = curr.data;
+        const mergedBody = `${h.text} ${paragraphBlockToPlainText(p)}`.replace(/\n/g, ' ').trim();
+        replacement = headingMarkdown(h.level, mergedBody);
+        const caretPlain = Math.min(h.text.length + 1, mergedBody.length);
+        anchor = start + headingMarkdown(h.level, mergedBody.slice(0, caretPlain)).length;
+        const mergedHeading = {
+            type: 'heading',
+            id: 'tmp',
+            sourceRange: { start: 0, end: replacement.length, startLine: 0, endLine: 0 },
+            data: { ...h, text: mergedBody }
+        };
+        const joinPlain = headingDisplayPlain(mergedHeading).length - paragraphDisplayPlain(curr).length;
+        focusAfter = {
+            mode: 'blockId',
+            blockId: prev.id,
+            plain: { start: joinPlain, end: joinPlain }
+        };
+    }
+    else if (prev.type === 'paragraph' && curr.type === 'heading') {
+        const p = prev.data;
+        const h = curr.data;
+        const mergedPlain = `${paragraphBlockToPlainText(p)}\n${headingMarkdown(h.level, h.text)}`;
+        const caretPlainInMerged = paragraphBlockToPlainText(p).length + 1;
+        replacement = serializeParagraphData(paragraphBlockFromPlainText(mergedPlain, p.startLineIndex));
+        const mergedBlock = {
+            type: 'paragraph',
+            id: 'tmp',
+            sourceRange: { start: 0, end: replacement.length, startLine: 0, endLine: 0 },
+            data: paragraphBlockFromPlainText(mergedPlain, p.startLineIndex)
+        };
+        anchor = start + paragraphPlainOffsetToSourceOffset(mergedBlock, caretPlainInMerged);
+        const joinPlain = paragraphDisplayPlain(mergedBlock).length - headingDisplayPlain(curr).length;
+        focusAfter = {
+            mode: 'blockId',
+            blockId: prev.id,
+            plain: { start: joinPlain, end: joinPlain }
+        };
+    }
+    else {
+        return { ok: false, error: 'Merge not supported for this block pair.' };
+    }
+    const normalizedReplacement = normalizeBlockSliceReplacement(source, start, end, replacement);
+    const newSource = replaceSourceRange(source, start, end, normalizedReplacement);
+    return {
+        ok: true,
+        source: newSource,
+        selection: clampSelection({ anchor, focus: anchor }, newSource.length),
+        focusAfter
+    };
+}
+/** Replace the raw markdown slice for one block (used for list/code/blockquote textareas). */
+export function replaceBlockMarkdownSlice(source, doc, blockIndex, replacement) {
+    const block = doc.blocks[blockIndex];
+    const err = assertEditableBlock(block, 'replace');
+    if (err)
+        return err;
+    const start = block.sourceRange.start;
+    const end = block.sourceRange.end;
+    const newSource = replaceBlockSourceRange(source, start, end, replacement);
+    const anchor = Math.min(start + replacement.length, newSource.length);
+    return {
+        ok: true,
+        source: newSource,
+        selection: clampSelection({ anchor, focus: anchor }, newSource.length)
+    };
+}
+export function deleteBlock(source, doc, blockIndex) {
+    const built = deleteBlockTransaction(source, doc, blockIndex);
+    if (!built.ok)
+        return built;
+    return applyEditorTransaction(source, built.transaction);
+}
+function blockSlice(source, block) {
+    return source.slice(block.sourceRange.start, block.sourceRange.end);
+}
+function assertEditableBlock(block, label) {
+    if (!block)
+        return { ok: false, error: `Invalid block index (${label}).` };
+    if (block.sourceRange.synthetic || block.sourceRange.start < 0) {
+        return { ok: false, error: 'Block is not editable.' };
+    }
+    return null;
+}
+/** Inserts a copy of the block's markdown after it; caret at start of duplicate body region. */
+export function duplicateBlock(source, doc, blockIndex) {
+    const built = duplicateBlockTransaction(source, doc, blockIndex);
+    if (!built.ok)
+        return built;
+    return applyEditorTransaction(source, built.transaction);
+}
+/**
+ * Reorder two adjacent serialized blocks as `lower + inter + upper` while keeping the same
+ * total length when the stock join would collapse a `\n\n` top-level break into a single `\n`.
+ */
+function swapMarkdownAdjacentSlices(lowerMd, gap, upperMd) {
+    if (gap === '\n' && upperMd.endsWith('\n') && !lowerMd.endsWith('\n')) {
+        return `${lowerMd}\n\n${upperMd.slice(0, -1)}`;
+    }
+    return `${lowerMd}${gap}${upperMd}`;
+}
+/** Swap two adjacent blocks so the lower-index block moves earlier (same as moving block at `lowerIndex` up). */
+export function swapAdjacentBlocks(source, doc, upperBlockIndex) {
+    if (upperBlockIndex < 0 || upperBlockIndex >= doc.blocks.length - 1) {
+        return { ok: false, error: 'No adjacent pair to swap.' };
+    }
+    const upper = doc.blocks[upperBlockIndex];
+    const lower = doc.blocks[upperBlockIndex + 1];
+    const errU = assertEditableBlock(upper, 'upper');
+    if (errU)
+        return errU;
+    const errL = assertEditableBlock(lower, 'lower');
+    if (errL)
+        return errL;
+    const spanStart = upper.sourceRange.start;
+    const spanEnd = lower.sourceRange.end;
+    const upperMd = blockSlice(source, upper);
+    const gap = source.slice(upper.sourceRange.end, lower.sourceRange.start);
+    const lowerMd = blockSlice(source, lower);
+    /** Preserves a paragraph/heading boundary when the lower slice has no trailing `\n` but the upper ends with one and the stored gap is a single `\n` (blank line row). */
+    const swapped = swapMarkdownAdjacentSlices(lowerMd, gap, upperMd);
+    const newSource = replaceSourceRange(source, spanStart, spanEnd, swapped);
+    const anchor = spanStart;
+    return {
+        ok: true,
+        source: newSource,
+        selection: clampSelection({ anchor, focus: anchor }, newSource.length)
+    };
+}
+export function moveBlockUp(source, doc, blockIndex) {
+    if (blockIndex <= 0)
+        return { ok: false, error: 'Cannot move first block up.' };
+    return swapAdjacentBlocks(source, doc, blockIndex - 1);
+}
+export function moveBlockDown(source, doc, blockIndex) {
+    if (blockIndex >= doc.blocks.length - 1)
+        return { ok: false, error: 'Cannot move last block down.' };
+    return swapAdjacentBlocks(source, doc, blockIndex);
+}
+/**
+ * Reorders blocks by moving one block to a new index via repeated {@link swapAdjacentBlocks},
+ * reparsing between swaps so ranges stay valid. Preserves irregular inter-block gaps that would
+ * be lost by joining slices with a single `\n\n`.
+ */
+export function moveBlockToIndex(source, doc, fromIndex, toIndex) {
+    const n = doc.blocks.length;
+    if (n === 0)
+        return { ok: false, error: 'Document has no blocks.' };
+    if (fromIndex < 0 || fromIndex >= n || toIndex < 0 || toIndex >= n) {
+        return { ok: false, error: 'Invalid block index.' };
+    }
+    if (fromIndex === toIndex) {
+        const b = doc.blocks[fromIndex];
+        const err = assertEditableBlock(b, 'move');
+        if (err)
+            return err;
+        const anchor = b.sourceRange.start;
+        return {
+            ok: true,
+            source,
+            selection: clampSelection({ anchor, focus: anchor }, source.length)
+        };
+    }
+    for (const b of doc.blocks) {
+        const err = assertEditableBlock(b, 'reorder');
+        if (err)
+            return err;
+    }
+    let s = source;
+    const fileName = doc.fileName;
+    let idx = fromIndex;
+    while (idx < toIndex) {
+        const fresh = applyInlineSecondPass(parseMarkdownDocument(s, fileName));
+        const r = swapAdjacentBlocks(s, fresh, idx);
+        if (!r.ok)
+            return r;
+        s = r.source;
+        idx++;
+    }
+    while (idx > toIndex) {
+        const fresh = applyInlineSecondPass(parseMarkdownDocument(s, fileName));
+        const r = swapAdjacentBlocks(s, fresh, idx - 1);
+        if (!r.ok)
+            return r;
+        s = r.source;
+        idx--;
+    }
+    const finalDoc = applyInlineSecondPass(parseMarkdownDocument(s, fileName));
+    const moved = finalDoc.blocks[toIndex];
+    if (!moved || moved.sourceRange.synthetic || moved.sourceRange.start < 0) {
+        return { ok: false, error: 'Reorder produced invalid block.' };
+    }
+    const anchor = moved.sourceRange.start;
+    return {
+        ok: true,
+        source: s,
+        selection: clampSelection({ anchor, focus: anchor }, s.length)
+    };
+}
+export function convertParagraphToHeading(source, doc, blockIndex, level) {
+    const block = doc.blocks[blockIndex];
+    const err = assertEditableBlock(block, 'convert');
+    if (err)
+        return err;
+    if (block.type !== 'paragraph')
+        return { ok: false, error: 'Block is not a paragraph.' };
+    const plain = paragraphBlockToPlainText(block.data).trimEnd();
+    const replacement = headingMarkdown(level, plain);
+    const newSource = replaceBlockSourceRange(source, block.sourceRange.start, block.sourceRange.end, replacement);
+    const prefixLen = replacement.length - plain.length;
+    const anchor = block.sourceRange.start + prefixLen + plain.length;
+    return {
+        ok: true,
+        source: newSource,
+        selection: clampSelection({ anchor, focus: anchor }, newSource.length)
+    };
+}
+export function convertHeadingLevel(source, doc, blockIndex, level) {
+    const block = doc.blocks[blockIndex];
+    const err = assertEditableBlock(block, 'convert');
+    if (err)
+        return err;
+    if (block.type !== 'heading')
+        return { ok: false, error: 'Block is not a heading.' };
+    const hb = block.data;
+    const replacement = headingMarkdown(level, hb.text);
+    const newSource = replaceBlockSourceRange(source, block.sourceRange.start, block.sourceRange.end, replacement);
+    const prefixLen = replacement.length - hb.text.length;
+    const anchor = block.sourceRange.start + prefixLen + hb.text.length;
+    return {
+        ok: true,
+        source: newSource,
+        selection: clampSelection({ anchor, focus: anchor }, newSource.length)
+    };
+}
+export function convertHeadingToParagraph(source, doc, blockIndex) {
+    const block = doc.blocks[blockIndex];
+    const err = assertEditableBlock(block, 'convert');
+    if (err)
+        return err;
+    if (block.type !== 'heading')
+        return { ok: false, error: 'Block is not a heading.' };
+    const hb = block.data;
+    const replacement = serializeParagraphData(paragraphBlockFromPlainText(hb.text, hb.lineIndex));
+    const newSource = replaceBlockSourceRange(source, block.sourceRange.start, block.sourceRange.end, replacement);
+    const tmp = {
+        type: 'paragraph',
+        id: 'tmp',
+        sourceRange: { start: 0, end: replacement.length, startLine: 0, endLine: 0 },
+        data: paragraphBlockFromPlainText(hb.text, hb.lineIndex)
+    };
+    const anchor = block.sourceRange.start + paragraphPlainOffsetToSourceOffset(tmp, hb.text.length);
+    return {
+        ok: true,
+        source: newSource,
+        selection: clampSelection({ anchor, focus: anchor }, newSource.length)
+    };
+}